

"""simple docstring"""
import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


_A						 =   datasets.utils.logging.get_logger(__name__)

@dataclass
class 	lowerCamelCase     (    datasets.BuilderConfig					):


  '''simple docstring'''







  SCREAMING_SNAKE_CASE 	=   1_0_0_0_0
  SCREAMING_SNAKE_CASE 	=   None
  SCREAMING_SNAKE_CASE 	=   None




class 	lowerCamelCase     (    datasets.ArrowBasedBuilder					):


  '''simple docstring'''







  SCREAMING_SNAKE_CASE 	=   ParquetConfig



  def       _a	(self     ):


        """simple docstring"""

        return datasets.DatasetInfo(features=self.config.features     )



  def       _a	(self				,    _lowerCamelCase     ):


        """simple docstring"""

        if not self.config.data_files:
              raise ValueError(F"""At least one data file must be specified, but got data_files={self.config.data_files}"""     )
        UpperCAmelCase__       :				Optional[int]						 =  dl_manager.download_and_extract(self.config.data_files     )
        if isinstance(_a				,    (str, list, tuple)     ):
              UpperCAmelCase__       :				str						 =  data_files
              if isinstance(_a				,    _a     ):
                    UpperCAmelCase__       :				Any						 =  [files]
              # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
              UpperCAmelCase__       :				List[str]						 =  [dl_manager.iter_files(_a     ) for file in files]
              return [datasets.SplitGenerator(name=datasets.Split.TRAIN				,    gen_kwargs={"""files""": files}     )]
        UpperCAmelCase__       :				str						 =  []
        for split_name, files in data_files.items():
              if isinstance(_a				,    _a     ):
                    UpperCAmelCase__       :				str						 =  [files]
              # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
              UpperCAmelCase__       :				Union[str, Any]						 =  [dl_manager.iter_files(_a     ) for file in files]
              # Infer features is they are stoed in the arrow schema
              if self.info.features is None:
                    for file in itertools.chain.from_iterable(_a     ):
                          with open(_a				,    """rb"""     ) as f:
                                UpperCAmelCase__       :				List[str]						 =  datasets.Features.from_arrow_schema(pq.read_schema(_a     )     )
                          break
              splits.append(datasets.SplitGenerator(name=_a				,    gen_kwargs={"""files""": files}     )     )
        return splits



  def       _a	(self				,    _lowerCamelCase     ):


        """simple docstring"""

        if self.info.features is not None:
              # more expensive cast to support nested features with keys in a different order
              # allows str <-> int/float or str to Audio for example
              UpperCAmelCase__       :				Optional[Any]						 =  table_cast(_a				,    self.info.features.arrow_schema     )
        return pa_table




  def       _a	(self				,    _lowerCamelCase     ):


        """simple docstring"""

        UpperCAmelCase__       :				Tuple						 =  self.info.features.arrow_schema if self.info.features is not None else None
        if self.info.features is not None and self.config.columns is not None:
              if sorted(field.name for field in schema     ) != sorted(self.config.columns     ):
                    raise ValueError(
                        F"""Tried to load parquet data with columns '{self.config.columns}' with mismatching features '{self.info.features}'"""     )
        for file_idx, file in enumerate(itertools.chain.from_iterable(_a     )     ):
              with open(_a				,    """rb"""     ) as f:
                    UpperCAmelCase__       :				Any						 =  pq.ParquetFile(_a     )
                    try:
                          for batch_idx, record_batch in enumerate(
                              parquet_file.iter_batches(batch_size=self.config.batch_size				,    columns=self.config.columns     )     ):
                                UpperCAmelCase__       :				str						 =  pa.Table.from_batches([record_batch]     )
                                # Uncomment for debugging (will print the Arrow table size and elements)
                                # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                                # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                                yield F"""{file_idx}_{batch_idx}""", self._cast_table(_a     )
                    except ValueError as e:
                          logger.error(F"""Failed to read file '{file}' with error {type(_a     )}: {e}"""     )
                          raise




from math import ceil



def    __UpperCAmelCase (	__a      :			int = 1_001	)			->     int:

					"""simple docstring"""

					_a	:    List[Any]         =		1

					for i in range(1		,int(ceil(n / 2.0	)	)	):
										_a	:    Optional[Any]         =		2 * i + 1
										_a	:    Optional[int]         =		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:
									a__				=		int(sys.argv[1])
									print(solution(n))
						except ValueError:
									print('''Invalid entry - please enter a number''')



