
class      _lowerCAmelCase :




				def __init__( self					)    ->				None:
							# numbermap keys are the number and its values are lists of indexes sorted
							# in ascending order
							lowerCAmelCase_      =     {}
							# indexmap keys are an index and it's values are the number at that index
							lowerCAmelCase_      =     {}




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				list[int]:
							if isinstance(_UpperCamelCase    ,    (range, str)					):
										lowerCAmelCase_      =     list(_UpperCamelCase					)
							elif not isinstance(_UpperCamelCase    ,    _UpperCamelCase					):
										raise TypeError(
										    "binary_search_delete() only accepts either a list, range or str"					)

							lowerCAmelCase_      =     0
							lowerCAmelCase_      =     len(_UpperCamelCase					) - 1

							while low <= high:
										lowerCAmelCase_      =     (low + high) // 2
										if array[mid] == item:
													array.pop(_UpperCamelCase					)
													return array
										elif array[mid] < item:
													lowerCAmelCase_      =     mid + 1
										else:
													lowerCAmelCase_      =     mid - 1
							raise ValueError(
							    "Either the item is not in the array or the array was unsorted"					)




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				list[int]:
							if isinstance(_UpperCamelCase    ,    (range, str)					):
										lowerCAmelCase_      =     list(_UpperCamelCase					)
							elif not isinstance(_UpperCamelCase    ,    _UpperCamelCase					):
										raise TypeError(
										    "binary_search_insert() only accepts either a list, range or str"					)

							lowerCAmelCase_      =     0
							lowerCAmelCase_      =     len(_UpperCamelCase					) - 1

							while low <= high:
										lowerCAmelCase_      =     (low + high) // 2
										if array[mid] == index:
													# If the item already exists in the array,
													# insert it after the existing item
													array.insert(mid + 1    ,    _UpperCamelCase					)
													return array
										elif array[mid] < index:
													lowerCAmelCase_      =     mid + 1
										else:
													lowerCAmelCase_      =     mid - 1

        # If the item doesn't exist in the array, insert it at the appropriate position
							array.insert(_UpperCamelCase    ,    _UpperCamelCase					)
							return array




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				None:
							# Remove previous index
							if index in self.indexmap:
										lowerCAmelCase_      =     self.indexmap[index]
										if len(self.numbermap[n]					) == 1:
													del self.numbermap[n]
										else:
													lowerCAmelCase_      =     self.binary_search_delete(self.numbermap[n]    ,    _UpperCamelCase					)

        # Set new index
							lowerCAmelCase_      =     number

							# Number not seen before or empty so insert number value
							if number not in self.numbermap:
										lowerCAmelCase_      =     [index]

							# Here we need to perform a binary search insertion in order to insert
							# The item in the correct place
							else:
										lowerCAmelCase_      =     self.binary_search_insert(
										    self.numbermap[number]    ,    _UpperCamelCase					)




				def 					__a						( self    ,    _UpperCamelCase					)    ->				int:
							return self.numbermap.get(_UpperCamelCase    ,    [-1]					)[0]


if __name__ == "__main__":
			import doctest

			doctest.testmod()








import json
import os
from dataclasses import dataclass

import numpy as np
import pyarrow as pa

import datasets
from utils import get_duration


_A       =					10_00_00_00_00_00
_A       =					1_00_00

_A,				_A       =					os.path.split(__file__)
_A       =					os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json"))






def        lowerCamelCase__    (    __lowerCAmelCase  :  int   ,							__lowerCAmelCase  :  int    ):




			"""simple docstring"""


			lowerCAmelCase_      =     pa.Table.from_pydict({"col": [0] * chunk_size}    )
			lowerCAmelCase_      =     pa.concat_tables([table] * (num_examples // chunk_size)    )
			return datasets.Dataset(__lowerCAmelCase   ,							fingerprint="table_100B"    )





@dataclass
class      _lowerCAmelCase :
				_lowercase      		=42
				_lowercase      		=42
				_lowercase      		=42
				_lowercase      		=42




				def 					__a						( self					)    ->				List[Any]:
							lowerCAmelCase_      =     np.random.default_rng(self.seed					)
							lowerCAmelCase_      =     rng.integers(low=self.low    ,    high=self.high    ,    size=self.size					).tolist()




				def __iter__( self					)    ->				List[str]:
							return iter(self._sampled_values					)




				def __len__( self					)    ->				Optional[int]:
							return self.size






@get_duration
def        lowerCamelCase__    (    __lowerCAmelCase  :  datasets.Dataset    ):




			"""simple docstring"""


			lowerCAmelCase_      =     dataset[0]






@get_duration
def        lowerCamelCase__    (    __lowerCAmelCase  :  datasets.Dataset    ):




			"""simple docstring"""


			lowerCAmelCase_      =     dataset[-1]






@get_duration
def        lowerCamelCase__    (    __lowerCAmelCase  :  datasets.Dataset    ):




			"""simple docstring"""


			lowerCAmelCase_      =     dataset[range(len(__lowerCAmelCase    ) // 2   ,							len(__lowerCAmelCase    ) // 2 + 1024    )]






@get_duration
def        lowerCamelCase__    (    __lowerCAmelCase  :  datasets.Dataset    ):




			"""simple docstring"""


			lowerCAmelCase_      =     dataset[RandIter(0   ,							len(__lowerCAmelCase    )   ,							1024   ,							seed=42    )]






def        lowerCamelCase__    (    ):




			"""simple docstring"""


			lowerCAmelCase_      =     {"num examples": SPEED_TEST_N_EXAMPLES}
			lowerCAmelCase_      =     (get_first_row, get_last_row, get_batch_of_aaaa_rows, get_batch_of_aaaa_random_rows)
			print("generating dataset"    )
			lowerCAmelCase_      =     generate_100B_dataset(num_examples=__lowerCAmelCase   ,							chunk_size=__lowerCAmelCase    )
			print("Functions"    )
			for func in functions:
						print(func.__name__    )
						lowerCAmelCase_      =     func(__lowerCAmelCase    )

			with open(__lowerCAmelCase   ,							"wb"    ) as f:
						f.write(json.dumps(__lowerCAmelCase    ).encode("utf-8"    )    )


if __name__ == "__main__":  # useful to run the profiler
			benchmark_table_100B()



