


from unittest import TestCase

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







class  snake_case__(							UpperCAmelCase__							):







						'''simple docstring'''




						def   lowercase_       ( self							)    ->			int:
										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   lowercase_       ( self							)    ->			Optional[int]:
										lowerCAmelCase_       :					int			 = {'''col_1''': [3, 2, 1, 0], '''col_2''': ['''a''', '''b''', '''c''', '''d''']}
										return Dataset.from_dict(SCREAMING_SNAKE_CASE__							)




						def   lowercase_       ( self							)    ->			List[Any]:
										lowerCAmelCase_       :					Any			 = self._create_example_records()
										lowerCAmelCase_       :					Optional[Any]			 = Dataset.from_list(SCREAMING_SNAKE_CASE__							)
										self.assertListEqual(dset.column_names      ,  ['''col_1''', '''col_2''']							)
										for i, r in enumerate(SCREAMING_SNAKE_CASE__							):
														self.assertDictEqual(SCREAMING_SNAKE_CASE__      ,  example_records[i]							)




						def   lowercase_       ( self							)    ->			Tuple:
										lowerCAmelCase_       :					List[str]			 = self._create_example_records()
										lowerCAmelCase_       :					Optional[int]			 = Dataset.from_list(SCREAMING_SNAKE_CASE__							)
										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   lowercase_       ( self							)    ->			Tuple:  # checks what happens with missing columns
										lowerCAmelCase_       :					Optional[int]			 = [{'''col_1''': 1}, {'''col_2''': '''x'''}]
										lowerCAmelCase_       :					List[str]			 = Dataset.from_list(SCREAMING_SNAKE_CASE__							)
										self.assertDictEqual(dset[0]      ,  {'''col_1''': 1}							)
										self.assertDictEqual(dset[1]      ,  {'''col_1''': None}							)  # NB: first record is used for columns




						def   lowercase_       ( self							)    ->			List[str]:  # checks if the type can be inferred from the second record
										lowerCAmelCase_       :					Optional[int]			 = [{'''col_1''': []}, {'''col_1''': [1, 2]}]
										lowerCAmelCase_       :					Optional[int]			 = Dataset.from_list(SCREAMING_SNAKE_CASE__							)
										self.assertEqual(dset.info.features['''col_1''']      ,  Sequence(Value('''int64'''							)							)							)




						def   lowercase_       ( self							)    ->			Dict:
										lowerCAmelCase_       :					str			 = Dataset.from_list([]							)
										self.assertEqual(len(SCREAMING_SNAKE_CASE__							)      ,  0							)
										self.assertListEqual(dset.column_names      ,  []							)






"""simple docstring"""
def      __lowerCamelCase   (							a_     :		Union[str, Any]							)			->      Optional[int]:
      __SCREAMING_SNAKE_CASE   :List[str]						=  1
      __SCREAMING_SNAKE_CASE   :Dict						=  2
      while i * i <= n:
            __SCREAMING_SNAKE_CASE   :Tuple						=  0
            while n % i == 0:
                  n //= i
                  multiplicity += 1
            n_divisors *= multiplicity + 1
            i += 1
      if n > 1:
            n_divisors *= 2
      return n_divisors



def      __lowerCamelCase   (							)			->      int:
      __SCREAMING_SNAKE_CASE   :Dict						=  1
      __SCREAMING_SNAKE_CASE   :Dict						=  1

      while True:
            i += 1
            t_num += i

            if count_divisors(a_							) > 5_00:
                  break

      return t_num


if __name__ == "__main__":
  print(solution())