
'''simple docstring'''





import itertools
from dataclasses import dataclass
from io import StringIO
from typing import Optional

import pyarrow as pa

import datasets
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


a__		: int  							=							datasets.utils.logging.get_logger(__name__)


@dataclass
class 			UpperCamelCase__	(     datasets.BuilderConfig):
 UpperCAmelCase__     :     Optional[datasets.Features]    					=       None
 UpperCAmelCase__     :     str    					=       "utf-8"
 UpperCAmelCase__     :     Optional[str]    					=       None
 UpperCAmelCase__     :     int    					=       1_0 << 2_0  # 10MB
 UpperCAmelCase__     :     bool    					=       False
 UpperCAmelCase__     :     str    					=       "line"


class 			UpperCamelCase__	(     datasets.ArrowBasedBuilder):
 UpperCAmelCase__     :     str    					=       TextConfig






 def 						lowercase_    (      self	:List[Any]      )					->      Dict:







       '''simple docstring'''



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






 def 						lowercase_    (      self	:int						,					_A	:Union[str, Any]      )					->      Any:







       '''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}'      )
       __A													=      dl_manager.download_and_extract(self.config.data_files      )
       if isinstance(_A						,					(str, list, tuple)      ):
             __A													=      data_files
             if isinstance(_A						,					_A      ):
                   __A													=      [files]
             __A													=      [dl_manager.iter_files(_A      ) for file in files]
             return [datasets.SplitGenerator(name=datasets.Split.TRAIN						,					gen_kwargs={'files': files}      )]
       __A													=      []
       for split_name, files in data_files.items():
             if isinstance(_A						,					_A      ):
                   __A													=      [files]
             __A													=      [dl_manager.iter_files(_A      ) for file in files]
             splits.append(datasets.SplitGenerator(name=_A						,					gen_kwargs={'files': files}      )      )
       return splits






 def 						lowercase_    (      self	:Optional[Any]						,					_A	:Dict      )					->      Optional[Any]:







       '''simple docstring'''



       if self.config.features is not None:
             __A													=      self.config.features.arrow_schema
             if all(not require_storage_cast(_A      ) for feature in self.config.features.values()      ):
                   # cheaper cast
                   __A													=      pa_table.cast(_A      )
             else:
                   # more expensive cast; allows str <-> int/float or str to Audio for example
                   __A													=      table_cast(_A						,					_A      )
             return pa_table
       else:
             return pa_table.cast(pa.schema({'text': pa.string()}      )      )






 def 						lowercase_    (      self	:int						,					_A	:Dict      )					->      Tuple:







       '''simple docstring'''



       __A													=      list(self.config.features      ) if self.config.features is not None else ['text']
       for file_idx, file in enumerate(itertools.chain.from_iterable(_A      )      ):
             # open in text mode, by default translates universal newlines ("\n", "\r\n" and "\r") into "\n"
             with open(_A						,					encoding=self.config.encoding						,					errors=self.config.errors      ) as f:
                   if self.config.sample_by == "line":
                         __A													=      0
                         while True:
                               __A													=      f.read(self.config.chunksize      )
                               if not batch:
                                     break
                               batch += f.readline()  # finish current line
                               # StringIO.readlines, by default splits only on "\n" (and keeps line breaks)
                               __A													=      StringIO(_A      ).readlines()
                               if not self.config.keep_linebreaks:
                                     __A													=      [line.rstrip('\n'      ) for line in batch]
                               __A													=      pa.Table.from_arrays([pa.array(_A      )]						,					names=_A      )
                               # 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 (file_idx, batch_idx), self._cast_table(_A      )
                               batch_idx += 1
                   elif self.config.sample_by == "paragraph":
                         __A													=      0
                         __A													=      ''
                         while True:
                               __A													=      f.read(self.config.chunksize      )
                               if not new_batch:
                                     break
                               batch += new_batch
                               batch += f.readline()  # finish current line
                               __A													=      batch.split('\n\n'      )
                               __A													=      pa.Table.from_arrays(
                                   [pa.array([example for example in batch[:-1] if example]      )]						,					names=_A      )
                               # 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 (file_idx, batch_idx), self._cast_table(_A      )
                               batch_idx += 1
                               __A													=      batch[-1]
                         if batch:
                               __A													=      pa.Table.from_arrays([pa.array([batch]      )]						,					names=_A      )
                               yield (file_idx, batch_idx), self._cast_table(_A      )
                   elif self.config.sample_by == "document":
                         __A													=      f.read()
                         __A													=      pa.Table.from_arrays([pa.array([text]      )]						,					names=_A      )
                         yield file_idx, self._cast_table(_A      )












def       _a (		SCREAMING_SNAKE_CASE_				:							int , SCREAMING_SNAKE_CASE_				:							int	):
					if a < b:
										return gcd(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_	)
					if a % b == 0:
										return b
					return gcd(SCREAMING_SNAKE_CASE_ , a % b	)







def       _a (		SCREAMING_SNAKE_CASE_				:							int , SCREAMING_SNAKE_CASE_				:							int , SCREAMING_SNAKE_CASE_				:							int	):
					if y == 0:
										return 1
					__lowerCAmelCase							  =			power(SCREAMING_SNAKE_CASE_ , y // 2 , SCREAMING_SNAKE_CASE_	) % mod
					__lowerCAmelCase							  =			(temp * temp) % mod
					if y % 2 == 1:
										__lowerCAmelCase							  =			(temp * x) % mod
					return temp







def       _a (		SCREAMING_SNAKE_CASE_				:							int	):
					__lowerCAmelCase							  =			2
					while b < n:
										if gcd(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_	) == 1 and power(SCREAMING_SNAKE_CASE_ , n - 1 , SCREAMING_SNAKE_CASE_	) != 1:
															return False
										b += 1
					return True


if __name__ == "__main__":
					UpperCamelCase__            =     int(input("""Enter number: """).strip())
					if is_carmichael_number(number):
										print(f'''{number} is a Carmichael Number.''')
					else:
										print(f'''{number} is not a Carmichael Number.''')




