
'''simple docstring'''






from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset

class  UpperCAmelCase__						(       snake_case_ ):



    def   lowerCamelCase_  (	self      :       Any     ):
          return [
              {"col_1": 3, "col_2": "a"},
              {"col_1": 2, "col_2": "b"},
              {"col_1": 1, "col_2": "c"},
              {"col_1": 0, "col_2": "d"},
          ]



    def   lowerCamelCase_  (	self      :       Dict     ):
          _lowerCamelCase				:   List[Any]								=   {"col_1": [3, 2, 1, 0], "col_2": ["a", "b", "c", "d"]}
          return Dataset.from_dict(__A     )



    def   lowerCamelCase_  (	self      :       str     ):
          _lowerCamelCase				:   List[Any]								=   self._create_example_records()
          _lowerCamelCase				:   Union[str, Any]								=   Dataset.from_list(__A     )
          self.assertListEqual(dset.column_names,["col_1", "col_2"]     )
          for i, r in enumerate(__A     ):
                self.assertDictEqual(__A,example_records[i]     )



    def   lowerCamelCase_  (	self      :       List[Any]     ):
          _lowerCamelCase				:   Dict								=   self._create_example_records()
          _lowerCamelCase				:   int								=   Dataset.from_list(__A     )
          _lowerCamelCase				:   int								=   Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]}     )
          self.assertEqual(dset.info,dset_from_dict.info     )



    def   lowerCamelCase_  (	self      :       Tuple     ):  # checks what happens with missing columns
          _lowerCamelCase				:   List[str]								=   [{"col_1": 1}, {"col_2": "x"}]
          _lowerCamelCase				:   Tuple								=   Dataset.from_list(__A     )
          self.assertDictEqual(dset[0],{"col_1": 1}     )
          self.assertDictEqual(dset[1],{"col_1": None}     )  # NB: first record is used for columns



    def   lowerCamelCase_  (	self      :       Optional[int]     ):  # checks if the type can be inferred from the second record
          _lowerCamelCase				:   List[Any]								=   [{"col_1": []}, {"col_1": [1, 2]}]
          _lowerCamelCase				:   Optional[int]								=   Dataset.from_list(__A     )
          self.assertEqual(dset.info.features["col_1"],Sequence(Value("int64"     )     )     )



    def   lowerCamelCase_  (	self      :       Any     ):
          _lowerCamelCase				:   Any								=   Dataset.from_list([]     )
          self.assertEqual(len(__A     ),0     )
          self.assertListEqual(dset.column_names,[]     )

'''simple docstring'''






from math import sqrt







def 		A_       (	_lowerCAmelCase   :    int = 1000000							):



      """simple docstring"""




      _lowerCamelCase				:   int								=   0
      _lowerCamelCase				:   int								=   0
      _lowerCamelCase				:   int

      while num_cuboids <= limit:
            max_cuboid_size += 1
            for sum_shortest_sides in range(2				,	2 * max_cuboid_size + 1							):
                  if sqrt(sum_shortest_sides**2 + max_cuboid_size**2							).is_integer():
                        num_cuboids += (
                            min(_lowerCAmelCase				,	sum_shortest_sides // 2							)
                            - max(1				,	sum_shortest_sides - max_cuboid_size							)
                            + 1
                        )

      return max_cuboid_size


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