'''simple docstring'''

from unittest import TestCase

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





class 							lowercase						(						__lowerCamelCase ):


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


   def lowerCamelCase__       (   self				:	Optional[Any])      ->					Dict:
         lowercase_     =      self._create_example_records()
         lowercase_     =      Dataset.from_list(__lowerCAmelCase)
         self.assertListEqual(dset.column_names   ,		["col_1", "col_2"])
         for i, r in enumerate(__lowerCAmelCase):
               self.assertDictEqual(__lowerCAmelCase   ,		example_records[i])


   def lowerCamelCase__       (   self				:	Any)      ->					Optional[Any]:
         lowercase_     =      self._create_example_records()
         lowercase_     =      Dataset.from_list(__lowerCAmelCase)
         lowercase_     =      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				:	List[Any])      ->					Optional[Any]:  # checks what happens with missing columns
         lowercase_     =      [{"col_1": 1}, {"col_2": "x"}]
         lowercase_     =      Dataset.from_list(__lowerCAmelCase)
         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])      ->					List[Any]:  # checks if the type can be inferred from the second record
         lowercase_     =      [{"col_1": []}, {"col_1": [1, 2]}]
         lowercase_     =      Dataset.from_list(__lowerCAmelCase)
         self.assertEqual(dset.info.features["col_1"]   ,		Sequence(Value("int64")))


   def lowerCamelCase__       (   self				:	Optional[int])      ->					List[str]:
         lowercase_     =      Dataset.from_list([])
         self.assertEqual(len(__lowerCAmelCase)   ,		0)
         self.assertListEqual(dset.column_names   ,		[])







'''simple docstring'''

from __future__ import annotations


def __a (	__lowerCamelCase			:						int				)	->							list[int]:
      '''simple docstring'''


      lowercase_     =      [True] * limit
      lowercase_     =      False
      lowercase_     =      False
      lowercase_     =      True

      for i in range(3 ,		int(limit**0.5 + 1				) ,		2				):
            lowercase_     =      i * 2
            while index < limit:
                  lowercase_     =      False
                  lowercase_     =      index + i

      lowercase_     =      [2]

      for i in range(3 ,		__lowerCamelCase ,		2				):
            if is_prime[i]:
                  primes.append(__lowerCamelCase				)

      return primes


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


      lowercase_     =      prime_sieve(__lowerCamelCase				)
      lowercase_     =      0
      lowercase_     =      0

      for i in range(len(__lowerCamelCase				)				):
            for j in range(i + length ,		len(__lowerCamelCase				)				):
                  lowercase_     =      sum(primes[i:j]				)
                  if sol >= ceiling:
                        break

                  if sol in primes:
                        lowercase_     =      j - i
                        lowercase_     =      sol

      return largest


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






