'''simple docstring'''

from __future__ import annotations

from math import ceil, floor, sqrt


def __a (	__lowerCamelCase			:						int = 2_000_000				)	->							int:
      '''simple docstring'''


      lowercase_     =      [0]
      lowercase_     =      42

      for idx in range(1 ,		ceil(sqrt(target * 2				) * 1.1				)				):
            triangle_numbers.append(triangle_numbers[-1] + idx				)

      # we want this to be as close as possible to target
      lowercase_     =      0
      # the area corresponding to the grid that gives the product closest to target
      lowercase_     =      0
      # an estimate of b, using the quadratic formula
      lowercase_     =      42
      # the largest integer less than b_estimate
      lowercase_     =      42
      # the largest integer less than b_estimate
      lowercase_     =      42
      # the triangle number corresponding to b_floor
      lowercase_     =      42
      # the triangle number corresponding to b_ceil
      lowercase_     =      42

      for idx_a, triangle_a in enumerate(triangle_numbers[1:] ,		1				):
            lowercase_     =      (-1 + sqrt(1 + 8 * target / triangle_a				)) / 2
            lowercase_     =      floor(__lowerCamelCase				)
            lowercase_     =      ceil(__lowerCamelCase				)
            lowercase_     =      triangle_numbers[b_floor]
            lowercase_     =      triangle_numbers[b_ceil]

            if abs(target - triangle_b_first_guess * triangle_a				) < abs(
                target - best_product				):
                  lowercase_     =      triangle_b_first_guess * triangle_a
                  lowercase_     =      idx_a * b_floor

            if abs(target - triangle_b_second_guess * triangle_a				) < abs(
                target - best_product				):
                  lowercase_     =      triangle_b_second_guess * triangle_a
                  lowercase_     =      idx_a * b_ceil

      return area


if __name__ == "__main__":
       print(F'''{solution() = }''')







'''simple docstring'''

import argparse
import os

import torch

from transformers import FlavaConfig, FlavaForPreTraining
from transformers.models.flava.convert_dalle_to_flava_codebook import convert_dalle_checkpoint


def __a (	__lowerCamelCase			:						List[Any]				)	->							Tuple:
      '''simple docstring'''


      return sum(param.float().sum() if "encoder.embeddings" not in key else 0 for key, param in state_dict.items()				)


def __a (	__lowerCamelCase			:						str ,		__lowerCamelCase			:						str				)	->							List[str]:
      '''simple docstring'''


      lowercase_     =      {}

      for key, value in state_dict.items():
            if "text_encoder.embeddings" in key or "image_encoder.embeddings" in key:
                  continue

            lowercase_     =      key.replace("heads.cmd.mim_head.cls.predictions" ,		"mmm_image_head"				)
            lowercase_     =      key.replace("heads.cmd.mlm_head.cls.predictions" ,		"mmm_text_head"				)
            lowercase_     =      key.replace("heads.cmd.itm_head.cls" ,		"itm_head"				)
            lowercase_     =      key.replace("heads.cmd.itm_head.pooler" ,		"itm_head.pooler"				)
            lowercase_     =      key.replace("heads.cmd.clip_head.logit_scale" ,		"flava.logit_scale"				)
            lowercase_     =      key.replace("heads.fairseq_mlm.cls.predictions" ,		"mlm_head"				)
            lowercase_     =      key.replace("heads.imagenet.mim_head.cls.predictions" ,		"mim_head"				)
            lowercase_     =      key.replace("mm_text_projection" ,		"flava.text_to_mm_projection"				)
            lowercase_     =      key.replace("mm_image_projection" ,		"flava.image_to_mm_projection"				)
            lowercase_     =      key.replace("image_encoder.module" ,		"flava.image_model"				)
            lowercase_     =      key.replace("text_encoder.module" ,		"flava.text_model"				)
            lowercase_     =      key.replace("mm_encoder.module.encoder.cls_token" ,		"flava.multimodal_model.cls_token"				)
            lowercase_     =      key.replace("mm_encoder.module" ,		"flava.multimodal_model"				)
            lowercase_     =      key.replace("text_projection" ,		"flava.text_projection"				)
            lowercase_     =      key.replace("image_projection" ,		"flava.image_projection"				)

            lowercase_     =      value.float()

      for key, value in codebook_state_dict.items():
            lowercase_     =      value

      return upgrade


@torch.no_grad()
def __a (	__lowerCamelCase			:						Dict ,		__lowerCamelCase			:						List[Any] ,		__lowerCamelCase			:						List[str] ,		__lowerCamelCase			:						Tuple=None				)	->							Optional[int]:
      '''simple docstring'''


      if config_path is not None:
            lowercase_     =      FlavaConfig.from_pretrained(__lowerCamelCase				)
      else:
            lowercase_     =      FlavaConfig()

      lowercase_     =      FlavaForPreTraining(__lowerCamelCase				).eval()

      lowercase_     =      convert_dalle_checkpoint(__lowerCamelCase ,		__lowerCamelCase ,		save_checkpoint=__lowerCamelCase				)

      if os.path.exists(__lowerCamelCase				):
            lowercase_     =      torch.load(__lowerCamelCase ,		map_location="cpu"				)
      else:
            lowercase_     =      torch.hub.load_state_dict_from_url(__lowerCamelCase ,		map_location="cpu"				)

      lowercase_     =      upgrade_state_dict(__lowerCamelCase ,		__lowerCamelCase				)
      hf_model.load_state_dict(__lowerCamelCase				)
      lowercase_     =      hf_model.state_dict()
      lowercase_     =      count_parameters(__lowerCamelCase				)
      lowercase_     =      count_parameters(__lowerCamelCase				) + count_parameters(__lowerCamelCase				)

      assert torch.allclose(__lowerCamelCase ,		__lowerCamelCase ,		atol=1e-3				)

      hf_model.save_pretrained(__lowerCamelCase				)


if __name__ == "__main__":
       lowerCAmelCase_ : List[str]						  =      argparse.ArgumentParser()
       parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
       parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to flava checkpoint")
       parser.add_argument("--codebook_path", default=None, type=str, help="Path to flava codebook checkpoint")
       parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
       lowerCAmelCase_ : List[Any]						  =      parser.parse_args()

       convert_flava_checkpoint(args.checkpoint_path, args.codebook_path, args.pytorch_dump_folder_path, args.config_path)






