


'''simple docstring'''
from unittest import TestCase

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

class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''


 def 			snake_case__ (   self    ):

  """simple docstring"""







  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 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Optional[int]	  =      {'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']}
  return Dataset.from_dict(__lowercase    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Union[str, Any]	  =      self._create_example_records()
  __A	:		Dict	  =      Dataset.from_list(__lowercase    )
  self.assertListEqual(dset.column_names   ,   ['col_1', 'col_2']    )
  for i, r in enumerate(__lowercase    ):
   self.assertDictEqual(__lowercase   ,   example_records[i]    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Union[str, Any]	  =      self._create_example_records()
  __A	:		Optional[int]	  =      Dataset.from_list(__lowercase    )
  __A	:		List[str]	  =      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 			snake_case__ (   self    ):  # checks what happens with missing columns

  """simple docstring"""







  __A	:		Optional[Any]	  =      [{'col_1': 1}, {'col_2': 'x'}]
  __A	:		int	  =      Dataset.from_list(__lowercase    )
  self.assertDictEqual(dset[0]   ,   {'col_1': 1}    )
  self.assertDictEqual(dset[1]   ,   {'col_1': None}    )  # NB: first record is used for columns


 def 			snake_case__ (   self    ):  # checks if the type can be inferred from the second record

  """simple docstring"""







  __A	:		List[Any]	  =      [{'col_1': []}, {'col_1': [1, 2]}]
  __A	:		str	  =      Dataset.from_list(__lowercase    )
  self.assertEqual(dset.info.features['col_1']   ,   Sequence(Value('int64'    )    )    )







 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		List[Any]	  =      Dataset.from_list([]    )
  self.assertEqual(len(__lowercase    )   ,   0    )
  self.assertListEqual(dset.column_names   ,   []    )










'''simple docstring'''
from math import ceil


def       _lowercase							(					UpperCamelCase__							:       int = 1001      ):
 __A	:		int	  =      1

 for i in range(1,					int(ceil(n / 2.0      )      )      ):
  __A	:		Any	  =      2 * i + 1
  __A	:		List[str]	  =      2 * i
  __A	:		str	  =      total + 4 * odd**2 - 6 * even

 return total


if __name__ == "__main__":
 import sys

 if len(sys.argv) == 1:
  print(solution())
 else:
  try:
   UpperCAmelCase_			:  int										=   int(sys.argv[1])
   print(solution(n))
  except ValueError:
   print('Invalid entry - please enter a number')






