





import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__A									=				logging.get_logger(__name__)

__A									=				{
    "google/pix2struct-textcaps-base": (
        "https://huggingface.co/google/pix2struct-textcaps-base/resolve/main/config.json"
    ),
}



class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ):







 '''simple docstring'''
 lowercase_		=			"pix2struct_text_model"
 lowercase_		=			["past_key_values"]
 lowercase_		=			{
     "hidden_size": "hidden_size",
     "num_attention_heads": "num_heads",
     "num_hidden_layers": "num_layers",
 }

 def __init__(self				:   Dict       , UpperCAmelCase_				:   Any=50_244       , UpperCAmelCase_				:   Union[str, Any]=768       , UpperCAmelCase_				:   Tuple=64       , UpperCAmelCase_				:   Tuple=2_048       , UpperCAmelCase_				:   Dict=12       , UpperCAmelCase_				:   List[Any]=12       , UpperCAmelCase_				:   Any=32       , UpperCAmelCase_				:   Union[str, Any]=128       , UpperCAmelCase_				:   List[str]=0.1       , UpperCAmelCase_				:   List[str]=1E-6       , UpperCAmelCase_				:   str=1.0       , UpperCAmelCase_				:   Dict="gelu_new"       , UpperCAmelCase_				:   List[Any]=0       , UpperCAmelCase_				:   Dict=False       , UpperCAmelCase_				:   Optional[int]=0       , UpperCAmelCase_				:   Union[str, Any]=1       , UpperCAmelCase_				:   Any=False       , UpperCAmelCase_				:   Union[str, Any]=True       , **UpperCAmelCase_				:   str       , )       ->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__:      Any			  =vocab_size
   lowerCamelCase__:      Union[str, Any]			  =hidden_size
   lowerCamelCase__:      Tuple			  =d_kv
   lowerCamelCase__:      Optional[int]			  =d_ff
   lowerCamelCase__:      Any			  =num_layers
   lowerCamelCase__:      int			  =num_heads
   lowerCamelCase__:      Any			  =relative_attention_num_buckets
   lowerCamelCase__:      List[str]			  =relative_attention_max_distance
   lowerCamelCase__:      Optional[int]			  =dropout_rate
   lowerCamelCase__:      Optional[int]			  =layer_norm_epsilon
   lowerCamelCase__:      Dict			  =initializer_factor
   lowerCamelCase__:      List[Any]			  =use_cache

   lowerCamelCase__:      Union[str, Any]			  =eos_token_id
   lowerCamelCase__:      List[Any]			  =decoder_start_token_id

   # for backwards compatibility
   lowerCamelCase__:      int			  =dense_act_fn

   super().__init__(
       pad_token_id=UpperCAmelCase_       , eos_token_id=UpperCAmelCase_       , decoder_start_token_id=UpperCAmelCase_       , tie_word_embeddings=UpperCAmelCase_       , is_decoder=UpperCAmelCase_       , **UpperCAmelCase_       , )







 @classmethod
 def 							SCREAMING_SNAKE_CASE_					(cls				:   Union[str, Any]       , UpperCAmelCase_				:   Union[str, os.PathLike]       , **UpperCAmelCase_				:   Any)       ->"PretrainedConfig":



   '''simple docstring'''



   cls._set_token_in_kwargs(UpperCAmelCase_)

   lowerCamelCase__  ,					lowerCamelCase__:      List[Any]			  =cls.get_config_dict(UpperCAmelCase_       , **UpperCAmelCase_)

   # get the text config dict if we are loading from Pix2StructConfig
   if config_dict.get("model_type") == "pix2struct":
     lowerCamelCase__:      Optional[Any]			  =config_dict["text_config"]

   if "model_type" in config_dict and hasattr(cls       , "model_type") and config_dict["model_type"] != cls.model_type:
     logger.warning(
         F"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """
         F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""")

   return cls.from_dict(UpperCAmelCase_       , **UpperCAmelCase_)



class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ):







 '''simple docstring'''
 lowercase_		=			"pix2struct_vision_model"

 def __init__(self				:   int       , UpperCAmelCase_				:   Optional[int]=768       , UpperCAmelCase_				:   Any=768       , UpperCAmelCase_				:   List[Any]=2_048       , UpperCAmelCase_				:   Optional[Any]=64       , UpperCAmelCase_				:   Dict=12       , UpperCAmelCase_				:   Optional[Any]=12       , UpperCAmelCase_				:   Tuple="gelu_new"       , UpperCAmelCase_				:   List[str]=1E-6       , UpperCAmelCase_				:   Dict=0.0       , UpperCAmelCase_				:   Optional[int]=0.0       , UpperCAmelCase_				:   Any=1E-1_0       , UpperCAmelCase_				:   Optional[int]=1.0       , UpperCAmelCase_				:   Dict=4_096       , UpperCAmelCase_				:   str=32       , UpperCAmelCase_				:   Any=128       , **UpperCAmelCase_				:   Union[str, Any]       , )       ->Optional[Any]:



   '''simple docstring'''



   super().__init__(**UpperCAmelCase_)

   lowerCamelCase__:      str			  =hidden_size
   lowerCamelCase__:      Union[str, Any]			  =patch_embed_hidden_size
   lowerCamelCase__:      str			  =d_ff
   lowerCamelCase__:      Any			  =dropout_rate
   lowerCamelCase__:      int			  =num_hidden_layers
   lowerCamelCase__:      int			  =num_attention_heads
   lowerCamelCase__:      str			  =initializer_range
   lowerCamelCase__:      Any			  =initializer_factor
   lowerCamelCase__:      Union[str, Any]			  =attention_dropout
   lowerCamelCase__:      Tuple			  =layer_norm_eps
   lowerCamelCase__:      int			  =dense_act_fn
   lowerCamelCase__:      Tuple			  =seq_len
   lowerCamelCase__:      Optional[Any]			  =relative_attention_num_buckets
   lowerCamelCase__:      int			  =relative_attention_max_distance
   lowerCamelCase__:      Dict			  =d_kv







 @classmethod
 def 							SCREAMING_SNAKE_CASE_					(cls				:   Any       , UpperCAmelCase_				:   Union[str, os.PathLike]       , **UpperCAmelCase_				:   List[str])       ->"PretrainedConfig":



   '''simple docstring'''



   cls._set_token_in_kwargs(UpperCAmelCase_)

   lowerCamelCase__  ,					lowerCamelCase__:      str			  =cls.get_config_dict(UpperCAmelCase_       , **UpperCAmelCase_)

   # get the vision config dict if we are loading from Pix2StructConfig
   if config_dict.get("model_type") == "pix2struct":
     lowerCamelCase__:      Tuple			  =config_dict["vision_config"]

   if "model_type" in config_dict and hasattr(cls       , "model_type") and config_dict["model_type"] != cls.model_type:
     logger.warning(
         F"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """
         F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""")

   return cls.from_dict(UpperCAmelCase_       , **UpperCAmelCase_)



class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ):







 '''simple docstring'''
 lowercase_		=			"pix2struct"
 lowercase_		=			True

 def __init__(self				:   Tuple       , UpperCAmelCase_				:   List[str]=None       , UpperCAmelCase_				:   Optional[int]=None       , UpperCAmelCase_				:   List[str]=1.0       , UpperCAmelCase_				:   Union[str, Any]=0.02       , UpperCAmelCase_				:   Any=False       , UpperCAmelCase_				:   List[Any]=False       , UpperCAmelCase_				:   Dict=True       , **UpperCAmelCase_				:   List[Any]       , )       ->List[str]:



   '''simple docstring'''



   super().__init__(tie_word_embeddings=UpperCAmelCase_       , is_encoder_decoder=UpperCAmelCase_       , **UpperCAmelCase_)

   if text_config is None:
     lowerCamelCase__:      List[str]			  ={}
     logger.info("text_config is None. Initializing the Pix2StructTextConfig with default values.")

   if vision_config is None:
     lowerCamelCase__:      str			  ={}
     logger.info("vision_config is None. Initializing the Pix2StructVisionConfig with default values.")

   lowerCamelCase__:      int			  =PixaStructTextConfig(**UpperCAmelCase_)
   lowerCamelCase__:      int			  =PixaStructVisionConfig(**UpperCAmelCase_)

   lowerCamelCase__:      Union[str, Any]			  =self.text_config.decoder_start_token_id
   lowerCamelCase__:      Tuple			  =self.text_config.pad_token_id
   lowerCamelCase__:      List[str]			  =self.text_config.eos_token_id

   lowerCamelCase__:      Union[str, Any]			  =initializer_factor
   lowerCamelCase__:      str			  =initializer_range

   lowerCamelCase__:      Optional[int]			  =self.initializer_range
   lowerCamelCase__:      Dict			  =self.initializer_range

   lowerCamelCase__:      str			  =is_vqa

 @classmethod
 def 							SCREAMING_SNAKE_CASE_					(cls				:   List[Any]       , UpperCAmelCase_				:   PixaStructTextConfig       , UpperCAmelCase_				:   PixaStructVisionConfig       , **UpperCAmelCase_				:   Optional[Any])       ->Optional[Any]:



   '''simple docstring'''



   return cls(text_config=text_config.to_dict()       , vision_config=vision_config.to_dict()       , **UpperCAmelCase_)







 def 							SCREAMING_SNAKE_CASE_					(self				:   str)       ->List[Any]:



   '''simple docstring'''



   lowerCamelCase__:      int			  =copy.deepcopy(self.__dict__)
   lowerCamelCase__:      List[Any]			  =self.text_config.to_dict()
   lowerCamelCase__:      List[str]			  =self.vision_config.to_dict()
   lowerCamelCase__:      Dict			  =self.__class__.model_type
   return output








from math import ceil, sqrt





def      lowerCAmelCase_ (       __a = 1000000		)     ->		int:







  """simple docstring"""





  lowerCamelCase__:      Optional[int]			  =0

  for outer_width in range(3	,    (limit // 4) + 2		):
    if outer_width**2 > limit:
      lowerCamelCase__:      Dict			  =max(ceil(sqrt(outer_width**2 - limit		)		)	,    1		)
    else:
      lowerCamelCase__:      str			  =1
    if (outer_width - hole_width_lower_bound) % 2:
      hole_width_lower_bound += 1

    answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

  return answer


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

