

import os
import tempfile
from pathlib import Path
from unittest import TestCase

import pyarrow as pa
import pytest

from datasets.arrow_dataset import Dataset
from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions
from datasets.info import DatasetInfo
from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo

from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases






class 							A_			(		__lowerCAmelCase ):


     def   UpperCAmelCase  (							self      :		Optional[Any]      ,  UpperCAmelCase      :		Any      ,  UpperCAmelCase      :		Optional[int]=False )							->     int:
      __lowerCAmelCase     ,							__lowerCAmelCase     ,							__lowerCAmelCase:       str            =				(
          filename_skip_take['filename'],
          filename_skip_take['skip'] if 'skip' in filename_skip_take else None,
          filename_skip_take['take'] if 'take' in filename_skip_take else None,
      )
      open(os.path.join(__SCREAMING_SNAKE_CASE )      ,  'wb' ).close()
      __lowerCAmelCase:       Optional[int]            =				pa.Table.from_pydict({'filename': [Path(__SCREAMING_SNAKE_CASE ).name] * 1_0_0} )
      if take == -1:
       __lowerCAmelCase:       List[str]            =				len(__SCREAMING_SNAKE_CASE ) - skip
      if skip is not None and take is not None:
       __lowerCAmelCase:       int            =				pa_table.slice(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE )
      return pa_table







class 							A_			(		__lowerCAmelCase ):


     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     Any:
      __lowerCAmelCase:       Any            =				'my_name'
      __lowerCAmelCase:       Dict            =				SplitInfo(name='train'      ,  num_examples=1_0_0 )
      __lowerCAmelCase:       int            =				SplitInfo(name='test'      ,  num_examples=1_0_0 )
      __lowerCAmelCase:       int            =				[train_info, test_info]
      __lowerCAmelCase:       Tuple            =				SplitDict()
      split_dict.add(__SCREAMING_SNAKE_CASE )
      split_dict.add(__SCREAMING_SNAKE_CASE )
      __lowerCAmelCase:       Union[str, Any]            =				DatasetInfo(splits=__SCREAMING_SNAKE_CASE )

      with tempfile.TemporaryDirectory() as tmp_dir:
       __lowerCAmelCase:       Optional[Any]            =				ReaderTest(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE )

       __lowerCAmelCase:       int            =				'test[:33%]'
       __lowerCAmelCase:       List[Any]            =				Dataset(**reader.read(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE ) )
       self.assertEqual(dset['filename'][0]      ,  F'''{name}-test''' )
       self.assertEqual(dset.num_rows      ,  3_3 )
       self.assertEqual(dset.num_columns      ,  1 )

       __lowerCAmelCase:       Tuple            =				['train', 'test[:33%]']
       __lowerCAmelCase:       Optional[Any]            =				[Split.TRAIN, ReadInstruction.from_spec('test[:33%]' )]
       for instructions in [instructionsa, instructionsa]:
        __lowerCAmelCase:       Union[str, Any]            =				[reader.read(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE ) for instr in instructions]
        __lowerCAmelCase     ,							__lowerCAmelCase:       Tuple            =				(Dataset(**__SCREAMING_SNAKE_CASE ) for dataset_kwargs in datasets_kwargs)
        self.assertEqual(train_dset['filename'][0]      ,  F'''{name}-train''' )
        self.assertEqual(train_dset.num_rows      ,  1_0_0 )
        self.assertEqual(train_dset.num_columns      ,  1 )
        self.assertIsInstance(train_dset.split      ,  __SCREAMING_SNAKE_CASE )
        self.assertEqual(str(train_dset.split )      ,  'train' )
        self.assertEqual(test_dset['filename'][0]      ,  F'''{name}-test''' )
        self.assertEqual(test_dset.num_rows      ,  3_3 )
        self.assertEqual(test_dset.num_columns      ,  1 )
        self.assertIsInstance(test_dset.split      ,  __SCREAMING_SNAKE_CASE )
        self.assertEqual(str(test_dset.split )      ,  'test[:33%]' )
        del train_dset, test_dset


     def   UpperCAmelCase  (							self      :		List[str] )							->     int:
      __lowerCAmelCase:       str            =				'my_name'
      __lowerCAmelCase:       Optional[Any]            =				SplitInfo(name='train'      ,  num_examples=1_0_0_0      ,  shard_lengths=[1_0_0] * 1_0 )
      __lowerCAmelCase:       Any            =				[train_info]
      __lowerCAmelCase:       Optional[Any]            =				SplitDict()
      split_dict.add(__SCREAMING_SNAKE_CASE )
      __lowerCAmelCase:       Optional[Any]            =				DatasetInfo(splits=__SCREAMING_SNAKE_CASE )

      with tempfile.TemporaryDirectory() as tmp_dir:
       __lowerCAmelCase:       Any            =				ReaderTest(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE )

       __lowerCAmelCase:       Dict            =				'train[:33%]'
       __lowerCAmelCase:       Any            =				Dataset(**reader.read(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE ) )
       self.assertEqual(dset['filename'][0]      ,  F'''{name}-train-00000-of-00010''' )
       self.assertEqual(dset['filename'][-1]      ,  F'''{name}-train-00003-of-00010''' )
       self.assertEqual(dset.num_rows      ,  3_3_0 )
       self.assertEqual(dset.num_columns      ,  1 )


     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     List[str]:
      __lowerCAmelCase:       Optional[int]            =				SplitInfo(name='train'      ,  num_examples=1_0_0 )
      __lowerCAmelCase:       Dict            =				SplitInfo(name='test'      ,  num_examples=1_0_0 )
      __lowerCAmelCase:       Dict            =				SplitDict()
      split_dict.add(__SCREAMING_SNAKE_CASE )
      split_dict.add(__SCREAMING_SNAKE_CASE )
      __lowerCAmelCase:       Optional[Any]            =				DatasetInfo(splits=__SCREAMING_SNAKE_CASE )

      with tempfile.TemporaryDirectory() as tmp_dir:
       __lowerCAmelCase:       str            =				ReaderTest(__SCREAMING_SNAKE_CASE      ,  __SCREAMING_SNAKE_CASE )

       __lowerCAmelCase:       Any            =				[
           {'filename': os.path.join(__SCREAMING_SNAKE_CASE      ,  'train' )},
           {'filename': os.path.join(__SCREAMING_SNAKE_CASE      ,  'test' ), 'skip': 1_0, 'take': 1_0},
       ]
       __lowerCAmelCase:       List[str]            =				Dataset(**reader.read_files(__SCREAMING_SNAKE_CASE      ,  original_instructions='train+test[10:20]' ) )
       self.assertEqual(dset.num_rows      ,  1_1_0 )
       self.assertEqual(dset.num_columns      ,  1 )
       del dset







@pytest.mark.parametrize('in_memory'   , [False, True]		)
def _a			(	SCREAMING_SNAKE_CASE		:      Dict   , SCREAMING_SNAKE_CASE		:      Union[str, Any]   , SCREAMING_SNAKE_CASE		:      List[str]		)   ->   Optional[int]:

 """simple docstring"""






 __lowerCAmelCase:       Optional[int]            =				arrow_file
 with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
  __lowerCAmelCase:       Optional[Any]            =				ArrowReader.read_table(_lowerCamelCase   , in_memory=_lowerCamelCase		)
 assert table.shape == dataset.data.shape
 assert set(table.column_names		) == set(dataset.data.column_names		)
 assert dict(table.to_pydict()		) == dict(dataset.data.to_pydict()		)  # to_pydict returns OrderedDict







@pytest.mark.parametrize('in_memory'   , [False, True]		)
def _a			(	SCREAMING_SNAKE_CASE		:      Union[str, Any]   , SCREAMING_SNAKE_CASE		:      str   , SCREAMING_SNAKE_CASE		:      str		)   ->   Any:

 """simple docstring"""






 __lowerCAmelCase:       List[str]            =				arrow_file
 __lowerCAmelCase:       Union[str, Any]            =				ArrowReader(''   , _lowerCamelCase		)
 with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
  __lowerCAmelCase:       Optional[Any]            =				reader.read_files([{'filename': filename}]   , in_memory=_lowerCamelCase		)
 assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
 __lowerCAmelCase:       Optional[Any]            =				dataset_kwargs['arrow_table']
 assert table.shape == dataset.data.shape
 assert set(table.column_names		) == set(dataset.data.column_names		)
 assert dict(table.to_pydict()		) == dict(dataset.data.to_pydict()		)  # to_pydict returns OrderedDict







def _a			(	)   ->   int:

 """simple docstring"""






 assert ReadInstruction('train'   , to=10   , unit='abs'		).to_spec() == "train[:10]"
 assert ReadInstruction('train'   , from_=-80   , to=10   , unit='%'		).to_spec() == "train[-80%:10%]"

 __lowerCAmelCase:       Tuple            =				'train+test'
 assert ReadInstruction.from_spec(_lowerCamelCase		).to_spec() == spec_train_test

 __lowerCAmelCase:       Union[str, Any]            =				'train[2:10]'
 assert ReadInstruction.from_spec(_lowerCamelCase		).to_spec() == spec_train_abs

 __lowerCAmelCase:       Union[str, Any]            =				'train[15%:-20%]'
 assert ReadInstruction.from_spec(_lowerCamelCase		).to_spec() == spec_train_pct

 __lowerCAmelCase:       str            =				'train[:10%](closest)'
 assert ReadInstruction.from_spec(_lowerCamelCase		).to_spec() == "train[:10%]"

 __lowerCAmelCase:       Optional[Any]            =				'train[:10%](pct1_dropremainder)'
 assert ReadInstruction.from_spec(_lowerCamelCase		).to_spec() == spec_train_pct_rounding

 __lowerCAmelCase:       Dict            =				'train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)'
 assert ReadInstruction.from_spec(_lowerCamelCase		).to_spec() == spec_train_test_pct_rounding







def _a			(	)   ->   List[str]:

 """simple docstring"""






 __lowerCAmelCase:       Dict            =				'dummy'
 __lowerCAmelCase:       Union[str, Any]            =				[SplitInfo(name='train'   , num_examples=1_00		)]
 __lowerCAmelCase:       Optional[int]            =				'train[:33%]'
 __lowerCAmelCase:       Tuple            =				'arrow'
 __lowerCAmelCase:       Optional[int]            =				'prefix'

 __lowerCAmelCase:       Union[str, Any]            =				make_file_instructions(_lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase		)
 assert isinstance(_lowerCamelCase   , _lowerCamelCase		)
 assert file_instructions.num_examples == 33
 assert file_instructions.file_instructions == [
     {"filename": os.path.join(_lowerCamelCase   , f'''{name}-train.arrow'''		), "skip": 0, "take": 33}
 ]

 __lowerCAmelCase:       Tuple            =				[SplitInfo(name='train'   , num_examples=1_00   , shard_lengths=[10] * 10		)]
 __lowerCAmelCase:       Dict            =				make_file_instructions(_lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase		)
 assert isinstance(_lowerCamelCase   , _lowerCamelCase		)
 assert file_instructions.num_examples == 33
 assert file_instructions.file_instructions == [
     {"filename": os.path.join(_lowerCamelCase   , f'''{name}-train-00000-of-00010.arrow'''		), "skip": 0, "take": -1},
     {"filename": os.path.join(_lowerCamelCase   , f'''{name}-train-00001-of-00010.arrow'''		), "skip": 0, "take": -1},
     {"filename": os.path.join(_lowerCamelCase   , f'''{name}-train-00002-of-00010.arrow'''		), "skip": 0, "take": -1},
     {"filename": os.path.join(_lowerCamelCase   , f'''{name}-train-00003-of-00010.arrow'''		), "skip": 0, "take": 3},
 ]







@pytest.mark.parametrize('name, expected_exception'   , [(None, TypeError), ('', ValueError)]		)
def _a			(	SCREAMING_SNAKE_CASE		:      Optional[Any]   , SCREAMING_SNAKE_CASE		:      Tuple		)   ->   Union[str, Any]:

 """simple docstring"""






 __lowerCAmelCase:       List[str]            =				[SplitInfo(name='train'   , num_examples=1_00		)]
 __lowerCAmelCase:       Optional[int]            =				'train'
 __lowerCAmelCase:       List[Any]            =				'arrow'
 __lowerCAmelCase:       Tuple            =				'prefix_path'
 with pytest.raises(_lowerCamelCase		):
  __lowerCAmelCase:       Dict            =				make_file_instructions(_lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase   , _lowerCamelCase		)








def _a			(	SCREAMING_SNAKE_CASE		:      int = 10_00		)   ->   int:

 """simple docstring"""






 __lowerCAmelCase:       Union[str, Any]            =				[0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8]
 # number of letters in twenty, thirty, ..., ninety (0 for numbers less than
 # 20 due to inconsistency in teens)
 __lowerCAmelCase:       Union[str, Any]            =				[0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

 __lowerCAmelCase:       Optional[int]            =				0

 for i in range(1   , n + 1		):
  if i < 10_00:
   if i >= 1_00:
    # add number of letters for "n hundred"
    count += ones_counts[i // 1_00] + 7

    if i % 1_00 != 0:
     # add number of letters for "and" if number is not multiple
     # of 100
     count += 3

   if 0 < i % 1_00 < 20:
    # add number of letters for one, two, three, ..., nineteen
    # (could be combined with below if not for inconsistency in
    # teens)
    count += ones_counts[i % 1_00]
   else:
    # add number of letters for twenty, twenty one, ..., ninety
    # nine
    count += ones_counts[i % 10]
    count += tens_counts[(i % 1_00 - i % 10) // 10]
  else:
   count += ones_counts[i // 10_00] + 8
 return count


if __name__ == "__main__":
  print(solution(int(input().strip())))





