




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


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






class      a__       (   datasets.ArrowBasedBuilder ):
						_a				:       str   =       TextConfig






						def 							__SCREAMING_SNAKE_CASE(  self     ):




											"""simple docstring"""



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






						def 							__SCREAMING_SNAKE_CASE(  self						,     _A     ):




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






						def 							__SCREAMING_SNAKE_CASE(  self						,     _A     ):




											"""simple docstring"""



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






						def 							__SCREAMING_SNAKE_CASE(  self						,     _A     ):




											"""simple docstring"""



											__lowerCAmelCase							  =			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":
																										__lowerCAmelCase							  =			0
																										while True:
																															__lowerCAmelCase							  =			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)
																															__lowerCAmelCase							  =			StringIO(_A     ).readlines()
																															if not self.config.keep_linebreaks:
																																				__lowerCAmelCase							  =			[line.rstrip("\n"     ) for line in batch]
																															__lowerCAmelCase							  =			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":
																										__lowerCAmelCase							  =			0
																										__lowerCAmelCase							  =			""
																										while True:
																															__lowerCAmelCase							  =			f.read(self.config.chunksize     )
																															if not new_batch:
																																				break
																															batch += new_batch
																															batch += f.readline()  # finish current line
																															__lowerCAmelCase							  =			batch.split("\n\n"     )
																															__lowerCAmelCase							  =			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
																															__lowerCAmelCase							  =			batch[-1]
																										if batch:
																															__lowerCAmelCase							  =			pa.Table.from_arrays([pa.array([batch]     )]						,     names=_A     )
																															yield (file_idx, batch_idx), self._cast_table(_A     )
																					elif self.config.sample_by == "document":
																										__lowerCAmelCase							  =			f.read()
																										__lowerCAmelCase							  =			pa.Table.from_arrays([pa.array([text]     )]						,     names=_A     )
																										yield file_idx, self._cast_table(_A     )










import decimal







def       _a (		):
					__lowerCAmelCase							  =			0
					__lowerCAmelCase							  =			decimal.Context(prec=1_05	)
					for i in range(2 , 1_00	):
										__lowerCAmelCase							  =			decimal.Decimal(SCREAMING_SNAKE_CASE_	)
										__lowerCAmelCase							  =			number.sqrt(SCREAMING_SNAKE_CASE_	)
										if len(str(SCREAMING_SNAKE_CASE_	)	) > 1:
															answer += int(str(SCREAMING_SNAKE_CASE_	)[0]	)
															__lowerCAmelCase							  =			str(SCREAMING_SNAKE_CASE_	)[2:1_01]
															answer += sum(int(SCREAMING_SNAKE_CASE_	) for x in sqrt_number_str	)
					return answer


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					print(f'''{solution() = }''')




