
import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
lowercase  :					List[Any]						    =							sys.version_info >= (3, 10)







def 						_snake_case(  SCREAMING_SNAKE_CASE__=None					,	SCREAMING_SNAKE_CASE__=None				) ->    Tuple:
       return field(default_factory=lambda: default					,	metadata=SCREAMING_SNAKE_CASE__				)

@dataclass
class __snake_case		:
    _a		:						int
    _a		:						float
    _a		:						str
    _a		:						bool






@dataclass
class __snake_case		:
    _a		:						int=				42
    _a		:						str=				field(default="toto"					,	metadata={"help": "help message"}     )






@dataclass
class __snake_case		:
    _a		:						bool=				False
    _a		:						bool=				True
    _a		:						Optional[bool]=				None






class __snake_case		(      lowerCAmelCase     ):
    _a		:						Optional[Any]=				"titi"
    _a		:						Dict=				"toto"






class __snake_case		(      lowerCAmelCase     ):
    _a		:						Optional[Any]=				"titi"
    _a		:						str=				"toto"
    _a		:						Tuple=				42






@dataclass
class __snake_case		:
    _a		:						BasicEnum=				"toto"
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      BasicEnum(self.foo      )






@dataclass
class __snake_case		:
    _a		:						MixedTypeEnum=				"toto"
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      MixedTypeEnum(self.foo      )






@dataclass
class __snake_case		:
    _a		:						Optional[int]=				None
    _a		:						Optional[float]=				field(default=lowerCAmelCase					,	metadata={"help": "help message"}     )
    _a		:						Optional[str]=				None
    _a		:						Optional[List[str]]=				list_field(default=[]     )
    _a		:						Optional[List[int]]=				list_field(default=[]     )






@dataclass
class __snake_case		:
    _a		:						List[int]=				list_field(default=[]     )
    _a		:						List[int]=				list_field(default=[1, 2, 3]     )
    _a		:						List[str]=				list_field(default=["Hallo", "Bonjour", "Hello"]     )
    _a		:						List[float]=				list_field(default=[0.1, 0.2, 0.3]     )






@dataclass
class __snake_case		:
    _a		:						List[int]=				field()
    _a		:						str=				field()
    _a		:						BasicEnum=				field()
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      BasicEnum(self.required_enum      )






@dataclass
class __snake_case		:
    _a		:						int
    _a		:						"BasicEnum"=				field()
    _a		:						"Optional[bool]"=				None
    _a		:						"str"=				field(default="toto"					,	metadata={"help": "help message"}     )
    _a		:						"List[str]"=				list_field(default=["Hallo", "Bonjour", "Hello"]     )


if is_python_no_less_than_3_10:

  @dataclass
  class __snake_case		:
      _a		:						bool=				False
      _a		:						bool=				True
      _a		:						bool | None=				None






  @dataclass
  class __snake_case		:
      _a		:						int | None=				None
      _a		:						float | None=				field(default=lowerCAmelCase					,	metadata={"help": "help message"}     )
      _a		:						str | None=				None
      _a		:						list[str] | None=				list_field(default=[]     )
      _a		:						list[int] | None=				list_field(default=[]     )




class __snake_case		(      unittest.TestCase     ):
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case      ):



           '''simple docstring'''







           self.assertEqual(len(a._actions      )		,len(b._actions      )      )
           for x, y in zip(a._actions		,b._actions      ):
                  lowercase							:     Any       	=      {k: v for k, v in vars(snake_case      ).items() if k != """container"""}
                  lowercase							:     str       	=      {k: v for k, v in vars(snake_case      ).items() if k != """container"""}

                  # Choices with mixed type have custom function as "type"
                  # So we need to compare results directly for equality
                  if xx.get("""choices"""		,snake_case      ) and yy.get("""choices"""		,snake_case      ):
                         for expected_choice in yy["choices"] + xx["choices"]:
                                self.assertEqual(xx["""type"""](snake_case      )		,yy["""type"""](snake_case      )      )
                         del xx["type"], yy["type"]

                  self.assertEqual(snake_case		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Tuple       	=      HfArgumentParser(snake_case      )

           lowercase							:     str       	=      argparse.ArgumentParser()
           expected.add_argument("""--foo"""		,type=snake_case		,required=snake_case      )
           expected.add_argument("""--bar"""		,type=snake_case		,required=snake_case      )
           expected.add_argument("""--baz"""		,type=snake_case		,required=snake_case      )
           expected.add_argument("""--flag"""		,type=snake_case		,default=snake_case		,const=snake_case		,nargs="""?"""      )
           self.argparsersEqual(snake_case		,snake_case      )

           lowercase							:     List[Any]       	=      ["""--foo""", """1""", """--baz""", """quux""", """--bar""", """0.5"""]
           ((lowercase)	,			)							:     Union[str, Any]       	=      parser.parse_args_into_dataclasses(snake_case		,look_for_args_file=snake_case      )
           self.assertFalse(example.flag      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Union[str, Any]       	=      HfArgumentParser(snake_case      )

           lowercase							:     int       	=      argparse.ArgumentParser()
           expected.add_argument("""--foo"""		,default=42		,type=snake_case      )
           expected.add_argument("""--baz"""		,default="""toto"""		,type=snake_case		,help="""help message"""      )
           self.argparsersEqual(snake_case		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     int       	=      argparse.ArgumentParser()
           expected.add_argument("""--foo"""		,type=snake_case		,default=snake_case		,const=snake_case		,nargs="""?"""      )
           expected.add_argument("""--baz"""		,type=snake_case		,default=snake_case		,const=snake_case		,nargs="""?"""      )
           # A boolean no_* argument always has to come after its "default: True" regular counter-part
           # and its default must be set to False
           expected.add_argument("""--no_baz"""		,action="""store_false"""		,default=snake_case		,dest="""baz"""      )
           expected.add_argument("""--opt"""		,type=snake_case		,default=snake_case      )

           lowercase							:     Union[str, Any]       	=      [WithDefaultBoolExample]
           if is_python_no_less_than_3_10:
                  dataclass_types.append(snake_case      )

           for dataclass_type in dataclass_types:
                  lowercase							:     Optional[Any]       	=      HfArgumentParser(snake_case      )
                  self.argparsersEqual(snake_case		,snake_case      )

                  lowercase							:     Dict       	=      parser.parse_args([]      )
                  self.assertEqual(snake_case		,Namespace(foo=snake_case		,baz=snake_case		,opt=snake_case      )      )

                  lowercase							:     int       	=      parser.parse_args(["""--foo""", """--no_baz"""]      )
                  self.assertEqual(snake_case		,Namespace(foo=snake_case		,baz=snake_case		,opt=snake_case      )      )

                  lowercase							:     Optional[Any]       	=      parser.parse_args(["""--foo""", """--baz"""]      )
                  self.assertEqual(snake_case		,Namespace(foo=snake_case		,baz=snake_case		,opt=snake_case      )      )

                  lowercase							:     int       	=      parser.parse_args(["""--foo""", """True""", """--baz""", """True""", """--opt""", """True"""]      )
                  self.assertEqual(snake_case		,Namespace(foo=snake_case		,baz=snake_case		,opt=snake_case      )      )

                  lowercase							:     Dict       	=      parser.parse_args(["""--foo""", """False""", """--baz""", """False""", """--opt""", """False"""]      )
                  self.assertEqual(snake_case		,Namespace(foo=snake_case		,baz=snake_case		,opt=snake_case      )      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[Any]       	=      HfArgumentParser(snake_case      )

           lowercase							:     List[Any]       	=      argparse.ArgumentParser()
           expected.add_argument(
               """--foo"""		,default="""toto"""		,choices=["""titi""", """toto""", 42]		,type=make_choice_type_function(["""titi""", """toto""", 42]      )		,)
           self.argparsersEqual(snake_case		,snake_case      )

           lowercase							:     Union[str, Any]       	=      parser.parse_args([]      )
           self.assertEqual(args.foo		,"""toto"""      )
           lowercase							:     Optional[Any]       	=      parser.parse_args_into_dataclasses([]      )[0]
           self.assertEqual(enum_ex.foo		,MixedTypeEnum.toto      )

           lowercase							:     int       	=      parser.parse_args(["""--foo""", """titi"""]      )
           self.assertEqual(args.foo		,"""titi"""      )
           lowercase							:     List[str]       	=      parser.parse_args_into_dataclasses(["""--foo""", """titi"""]      )[0]
           self.assertEqual(enum_ex.foo		,MixedTypeEnum.titi      )

           lowercase							:     Tuple       	=      parser.parse_args(["""--foo""", """42"""]      )
           self.assertEqual(args.foo		,42      )
           lowercase							:     str       	=      parser.parse_args_into_dataclasses(["""--foo""", """42"""]      )[0]
           self.assertEqual(enum_ex.foo		,MixedTypeEnum.fourtytwo      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           @dataclass
           class __snake_case		:
               _a		:						Literal["titi", "toto", 42]=				"toto"






           lowercase							:     Union[str, Any]       	=      HfArgumentParser(snake_case      )

           lowercase							:     Any       	=      argparse.ArgumentParser()
           expected.add_argument(
               """--foo"""		,default="""toto"""		,choices=("""titi""", """toto""", 42)		,type=make_choice_type_function(["""titi""", """toto""", 42]      )		,)
           self.argparsersEqual(snake_case		,snake_case      )

           lowercase							:     Any       	=      parser.parse_args([]      )
           self.assertEqual(args.foo		,"""toto"""      )

           lowercase							:     str       	=      parser.parse_args(["""--foo""", """titi"""]      )
           self.assertEqual(args.foo		,"""titi"""      )

           lowercase							:     Optional[Any]       	=      parser.parse_args(["""--foo""", """42"""]      )
           self.assertEqual(args.foo		,42      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     str       	=      HfArgumentParser(snake_case      )

           lowercase							:     Optional[Any]       	=      argparse.ArgumentParser()
           expected.add_argument("""--foo_int"""		,nargs="""+"""		,default=[]		,type=snake_case      )
           expected.add_argument("""--bar_int"""		,nargs="""+"""		,default=[1, 2, 3]		,type=snake_case      )
           expected.add_argument("""--foo_str"""		,nargs="""+"""		,default=["""Hallo""", """Bonjour""", """Hello"""]		,type=snake_case      )
           expected.add_argument("""--foo_float"""		,nargs="""+"""		,default=[0.1, 0.2, 0.3]		,type=snake_case      )

           self.argparsersEqual(snake_case		,snake_case      )

           lowercase							:     int       	=      parser.parse_args([]      )
           self.assertEqual(
               snake_case		,Namespace(foo_int=[]		,bar_int=[1, 2, 3]		,foo_str=["""Hallo""", """Bonjour""", """Hello"""]		,foo_float=[0.1, 0.2, 0.3]      )		,)

           lowercase							:     Optional[int]       	=      parser.parse_args("""--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7""".split()      )
           self.assertEqual(snake_case		,Namespace(foo_int=[1]		,bar_int=[2, 3]		,foo_str=["""a""", """b""", """c"""]		,foo_float=[0.1, 0.7]      )      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     str       	=      argparse.ArgumentParser()
           expected.add_argument("""--foo"""		,default=snake_case		,type=snake_case      )
           expected.add_argument("""--bar"""		,default=snake_case		,type=snake_case		,help="""help message"""      )
           expected.add_argument("""--baz"""		,default=snake_case		,type=snake_case      )
           expected.add_argument("""--ces"""		,nargs="""+"""		,default=[]		,type=snake_case      )
           expected.add_argument("""--des"""		,nargs="""+"""		,default=[]		,type=snake_case      )

           lowercase							:     List[Any]       	=      [OptionalExample]
           if is_python_no_less_than_3_10:
                  dataclass_types.append(snake_case      )

           for dataclass_type in dataclass_types:
                  lowercase							:     Union[str, Any]       	=      HfArgumentParser(snake_case      )

                  self.argparsersEqual(snake_case		,snake_case      )

                  lowercase							:     Optional[int]       	=      parser.parse_args([]      )
                  self.assertEqual(snake_case		,Namespace(foo=snake_case		,bar=snake_case		,baz=snake_case		,ces=[]		,des=[]      )      )

                  lowercase							:     Any       	=      parser.parse_args("""--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3""".split()      )
                  self.assertEqual(snake_case		,Namespace(foo=12		,bar=3.14		,baz="""42"""		,ces=["""a""", """b""", """c"""]		,des=[1, 2, 3]      )      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Dict       	=      HfArgumentParser(snake_case      )

           lowercase							:     Any       	=      argparse.ArgumentParser()
           expected.add_argument("""--required_list"""		,nargs="""+"""		,type=snake_case		,required=snake_case      )
           expected.add_argument("""--required_str"""		,type=snake_case		,required=snake_case      )
           expected.add_argument(
               """--required_enum"""		,type=make_choice_type_function(["""titi""", """toto"""]      )		,choices=["""titi""", """toto"""]		,required=snake_case		,)
           self.argparsersEqual(snake_case		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     str       	=      HfArgumentParser(snake_case      )

           lowercase							:     Union[str, Any]       	=      argparse.ArgumentParser()
           expected.add_argument("""--foo"""		,type=snake_case		,required=snake_case      )
           expected.add_argument(
               """--required_enum"""		,type=make_choice_type_function(["""titi""", """toto"""]      )		,choices=["""titi""", """toto"""]		,required=snake_case		,)
           expected.add_argument("""--opt"""		,type=snake_case		,default=snake_case      )
           expected.add_argument("""--baz"""		,default="""toto"""		,type=snake_case		,help="""help message"""      )
           expected.add_argument("""--foo_str"""		,nargs="""+"""		,default=["""Hallo""", """Bonjour""", """Hello"""]		,type=snake_case      )
           self.argparsersEqual(snake_case		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Dict       	=      HfArgumentParser(snake_case      )

           lowercase							:     List[str]       	=      {
               """foo""": 12,
               """bar""": 3.14,
               """baz""": """42""",
               """flag""": True,
           }

           lowercase							:     Dict       	=      parser.parse_dict(snake_case      )[0]
           lowercase							:     Any       	=      BasicExample(**snake_case      )
           self.assertEqual(snake_case		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Optional[int]       	=      HfArgumentParser(snake_case      )

           lowercase							:     Optional[Any]       	=      {
               """foo""": 12,
               """bar""": 3.14,
               """baz""": """42""",
               """flag""": True,
               """extra""": 42,
           }

           self.assertRaises(snake_case		,parser.parse_dict		,snake_case		,allow_extra_keys=snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      HfArgumentParser(snake_case      )

           lowercase							:     List[str]       	=      {
               """foo""": 12,
               """bar""": 3.14,
               """baz""": """42""",
               """flag""": True,
           }
           with tempfile.TemporaryDirectory() as tmp_dir:
                  lowercase							:     Dict       	=      os.path.join(snake_case		,"""temp_json"""      )
                  os.mkdir(snake_case      )
                  with open(temp_local_path + """.json"""		,"""w+"""      ) as f:
                         json.dump(snake_case		,snake_case      )
                  lowercase							:     Dict       	=      parser.parse_yaml_file(Path(temp_local_path + """.json"""      )      )[0]

           lowercase							:     Any       	=      BasicExample(**snake_case      )
           self.assertEqual(snake_case		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     int       	=      HfArgumentParser(snake_case      )

           lowercase							:     Optional[Any]       	=      {
               """foo""": 12,
               """bar""": 3.14,
               """baz""": """42""",
               """flag""": True,
           }
           with tempfile.TemporaryDirectory() as tmp_dir:
                  lowercase							:     Optional[Any]       	=      os.path.join(snake_case		,"""temp_yaml"""      )
                  os.mkdir(snake_case      )
                  with open(temp_local_path + """.yaml"""		,"""w+"""      ) as f:
                         yaml.dump(snake_case		,snake_case      )
                  lowercase							:     List[str]       	=      parser.parse_yaml_file(Path(temp_local_path + """.yaml"""      )      )[0]
           lowercase							:     Any       	=      BasicExample(**snake_case      )
           self.assertEqual(snake_case		,snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self      ):



           '''simple docstring'''







           lowercase							:     Any       	=      HfArgumentParser(snake_case      )
           self.assertIsNotNone(snake_case      )








"""simple docstring"""


from collections import defaultdict
from math import ceil, sqrt



def 					lowerCAmelCase				(    __UpperCamelCase = 1_0_0_0_0_0_0		,       __UpperCamelCase = 1_0 ):




  """simple docstring"""







  __A									= defaultdict(__UpperCamelCase )

  for outer_width in range(3		,       (t_limit // 4) + 2 ):
    if outer_width * outer_width > t_limit:
      __A									= max(
          ceil(sqrt(outer_width * outer_width - t_limit ) )		,       1 )
    else:
      __A									= 1

    hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

    for hole_width in range(__UpperCamelCase		,       outer_width - 1		,       2 ):
      count[outer_width * outer_width - hole_width * hole_width] += 1

  return sum(1 for n in count.values() if 1 <= n <= 1_0 )


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




