



_lowercase		:      Optional[Any]					=range(2, 20 + 1)
_lowercase		:      Optional[Any]					=[10**k for k in range(ks[-1] + 1)]
_lowercase		:      int					={}

def 	lowerCAmelCase_     (  _lowercase				:   str						,   _lowercase				:   Optional[Any]						,   _lowercase				:   List[str]						,   _lowercase				:   Any)							->       List[Any]:







			"""simple docstring"""
			a__   :						List[str]						       =  sum(a_i[j] for j in range(_lowerCamelCase						,   len(_lowerCamelCase)))
			a__   :						Tuple						       =  sum(a_i[j] * base[j] for j in range(min(len(_lowerCamelCase)						,   _lowerCamelCase)))

			a__   :						str						       =  0, 0
			a__   :						Optional[Any]						       =  n - i

			a__   :						Tuple						       =  memo.get(_lowerCamelCase)

			if sub_memo is not None:
						a__   :						List[str]						       =  sub_memo.get(_lowerCamelCase)

						if jumps is not None and len(_lowerCamelCase) > 0:
									# find and make the largest jump without going over
									a__   :						Optional[int]						       =  -1
									for _k in range(len(_lowerCamelCase) - 1						,   -1						,   -1):
												if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
															a__   :						Optional[int]						       =  _k
															break

									if max_jump >= 0:
												a__   :						List[str]						       =  jumps[max_jump]
												# since the difference between jumps is cached, add c
												a__   :						int						       =  diff + c
												for j in range(min(_lowerCamelCase						,   len(_lowerCamelCase))):
															a__   :						List[str]						       =  divmod(_lowerCamelCase						,   10)
												if new_c > 0:
															add(_lowerCamelCase						,   _lowerCamelCase						,   _lowerCamelCase)

						else:
									a__   :						Optional[int]						       =  []
			else:
						a__   :						int						       =  {c: []}
						a__   :						Tuple						       =  sub_memo

			if dn >= max_dn or c + diff >= base[k]:
						return diff, dn

			if k > ks[0]:
						while True:
									# keep doing smaller jumps
									a__   :						Union[str, Any]						       =  next_term(_lowerCamelCase						,   k - 1						,   i + dn						,   _lowerCamelCase)
									diff += _diff
									dn += terms_jumped

									if dn >= max_dn or c + diff >= base[k]:
												break
			else:
						# would be too small a jump, just compute sequential terms instead
						a__   :						List[str]						       =  compute(_lowerCamelCase						,   _lowerCamelCase						,   i + dn						,   _lowerCamelCase)
						diff += _diff
						dn += terms_jumped

			a__   :						Optional[int]						       =  sub_memo[c]

			# keep jumps sorted by # of terms skipped
			a__   :						Dict						       =  0
			while j < len(_lowerCamelCase):
						if jumps[j][1] > dn:
									break
						j += 1

			# cache the jump for this value digitsum(b) and c
			sub_memo[c].insert(_lowerCamelCase						,   (diff, dn, k))
			return (diff, dn)

def 	lowerCAmelCase_     (  _lowercase				:   Tuple						,   _lowercase				:   Any						,   _lowercase				:   Tuple						,   _lowercase				:   List[Any])							->       Dict:







			"""simple docstring"""
			if i >= n:
						return 0, i
			if k > len(_lowerCamelCase):
						a_i.extend([0 for _ in range(k - len(_lowerCamelCase))])

			# note: a_i -> b * 10^k + c
			# ds_b -> digitsum(b)
			# ds_c -> digitsum(c)
			a__   :						Dict						       =  i
			a__   :						Optional[Any]						       =  0, 0, 0
			for j in range(len(_lowerCamelCase)):
						if j >= k:
									ds_b += a_i[j]
						else:
									ds_c += a_i[j]

			while i < n:
						i += 1
						a__   :						Union[str, Any]						       =  ds_c + ds_b
						diff += addend
						a__   :						Union[str, Any]						       =  0
						for j in range(_lowerCamelCase):
									a__   :						Any						       =  a_i[j] + addend
									a__   :						Optional[Any]						       =  divmod(_lowerCamelCase						,   10)

									ds_c += a_i[j]

						if addend > 0:
									break

			if addend > 0:
						add(_lowerCamelCase						,   _lowerCamelCase						,   _lowerCamelCase)
			return diff, i - start_i

def 	lowerCAmelCase_     (  _lowercase				:   Union[str, Any]						,   _lowercase				:   List[str]						,   _lowercase				:   List[Any])							->       int:







			"""simple docstring"""
			for j in range(_lowerCamelCase						,   len(_lowerCamelCase)):
						a__   :						Tuple						       =  digits[j] + addend
						if s >= 10:
									a__   :						List[Any]						       =  divmod(_lowerCamelCase						,   10)
									a__   :						Dict						       =  addend // 10 + quotient
						else:
									a__   :						Union[str, Any]						       =  s
									a__   :						Optional[int]						       =  addend // 10

						if addend == 0:
									break

			while addend > 0:
						a__   :						int						       =  divmod(_lowerCamelCase						,   10)
						digits.append(_lowerCamelCase)

def 	lowerCAmelCase_     (  _lowercase				:   int = 10**15)							->       Tuple:







			"""simple docstring"""
			a__   :						str						       =  [1]
			a__   :						Dict						       =  1
			a__   :						Optional[int]						       =  0
			while True:
						a__   :						Any						       =  next_term(_lowerCamelCase						,   20						,   i + dn						,   _lowerCamelCase)
						dn += terms_jumped
						if dn == n - i:
									break

			a__   :						int						       =  0
			for j in range(len(_lowerCamelCase)):
						a_n += digits[j] * 10**j
			return a_n


if __name__ == "__main__":
		print(f'{solution() = }')





import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases

def 			lowercase_				(			_lowerCamelCase							:       Optional[Any]		,	_lowerCamelCase							:       int):
    assert isinstance(_lowerCamelCase		,	_lowerCamelCase)
    assert dataset.num_rows == 4
    assert dataset.num_columns == 3
    assert dataset.column_names == ["col_1", "col_2", "col_3"]
    for feature, expected_dtype in expected_features.items():
        assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize("keep_in_memory"		,	[False, True])
def 			lowercase_				(			_lowerCamelCase							:       List[Any]		,	_lowerCamelCase							:       Any		,	_lowerCamelCase							:       str):
    lowercase__ :   Optional[int]    					=				tmp_path / "cache"
    lowercase__ :   str    					=				{"col_1": "string", "col_2": "int64", "col_3": "float64"}
    with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
        lowercase__ :   Union[str, Any]    					=				JsonDatasetReader(_lowerCamelCase		,	cache_dir=_lowerCamelCase		,	keep_in_memory=_lowerCamelCase).read()
    _check_json_dataset(_lowerCamelCase		,	_lowerCamelCase)

@pytest.mark.parametrize(
    "features"		,	[
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]		,	)
def 			lowercase_				(			_lowerCamelCase							:       List[str]		,	_lowerCamelCase							:       Dict		,	_lowerCamelCase							:       Dict):
    lowercase__ :   List[Any]    					=				tmp_path / "cache"
    lowercase__ :   Union[str, Any]    					=				{"col_1": "string", "col_2": "int64", "col_3": "float64"}
    lowercase__ :   List[Any]    					=				features.copy() if features else default_expected_features
    lowercase__ :   List[Any]    					=				(
        Features({feature: Value(_lowerCamelCase) for feature, dtype in features.items()}) if features is not None else None
    )
    lowercase__ :   Any    					=				JsonDatasetReader(_lowerCamelCase		,	features=_lowerCamelCase		,	cache_dir=_lowerCamelCase).read()
    _check_json_dataset(_lowerCamelCase		,	_lowerCamelCase)

@pytest.mark.parametrize(
    "features"		,	[
        None,
        {"col_3": "float64", "col_1": "string", "col_2": "int64"},
    ]		,	)
def 			lowercase_				(			_lowerCamelCase							:       Any		,	_lowerCamelCase							:       Any		,	_lowerCamelCase							:       List[str]):
    lowercase__ :   Optional[Any]    					=				tmp_path / "cache"
    lowercase__ :   Tuple    					=				{"col_3": "float64", "col_1": "string", "col_2": "int64"}
    lowercase__ :   List[Any]    					=				features.copy() if features else default_expected_features
    lowercase__ :   int    					=				(
        Features({feature: Value(_lowerCamelCase) for feature, dtype in features.items()}) if features is not None else None
    )
    lowercase__ :   Any    					=				JsonDatasetReader(_lowerCamelCase		,	features=_lowerCamelCase		,	cache_dir=_lowerCamelCase).read()
    assert isinstance(_lowerCamelCase		,	_lowerCamelCase)
    assert dataset.num_rows == 2
    assert dataset.num_columns == 3
    assert dataset.column_names == ["col_3", "col_1", "col_2"]
    for feature, expected_dtype in expected_features.items():
        assert dataset.features[feature].dtype == expected_dtype

def 			lowercase_				(			_lowerCamelCase							:       List[Any]		,	_lowerCamelCase							:       Optional[int]):
    # jsonl_312_path features are {"col_3": "float64", "col_1": "string", "col_2": "int64"}
    lowercase__ :   Any    					=				{"col_2": "int64", "col_3": "float64", "col_1": "string"}
    lowercase__ :   str    					=				features.copy()
    lowercase__ :   str    					=				(
        Features({feature: Value(_lowerCamelCase) for feature, dtype in features.items()}) if features is not None else None
    )
    lowercase__ :   Optional[int]    					=				tmp_path / "cache"
    lowercase__ :   Any    					=				JsonDatasetReader(_lowerCamelCase		,	features=_lowerCamelCase		,	cache_dir=_lowerCamelCase).read()
    assert isinstance(_lowerCamelCase		,	_lowerCamelCase)
    assert dataset.num_rows == 2
    assert dataset.num_columns == 3
    assert dataset.column_names == ["col_2", "col_3", "col_1"]
    for feature, expected_dtype in expected_features.items():
        assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize("split"		,	[None, NamedSplit("train"), "train", "test"])
def 			lowercase_				(			_lowerCamelCase							:       Dict		,	_lowerCamelCase							:       Optional[int]		,	_lowerCamelCase							:       List[str]):
    lowercase__ :   Union[str, Any]    					=				tmp_path / "cache"
    lowercase__ :   List[Any]    					=				{"col_1": "string", "col_2": "int64", "col_3": "float64"}
    lowercase__ :   Union[str, Any]    					=				JsonDatasetReader(_lowerCamelCase		,	cache_dir=_lowerCamelCase		,	split=_lowerCamelCase).read()
    _check_json_dataset(_lowerCamelCase		,	_lowerCamelCase)
    assert dataset.split == split if split else "train"

@pytest.mark.parametrize("path_type"		,	[str, list])
def 			lowercase_				(			_lowerCamelCase							:       Union[str, Any]		,	_lowerCamelCase							:       str		,	_lowerCamelCase							:       int):
    if issubclass(_lowerCamelCase		,	_lowerCamelCase):
        lowercase__ :   Tuple    					=				jsonl_path
    elif issubclass(_lowerCamelCase		,	_lowerCamelCase):
        lowercase__ :   str    					=				[jsonl_path]
    lowercase__ :   str    					=				tmp_path / "cache"
    lowercase__ :   Optional[Any]    					=				{"col_1": "string", "col_2": "int64", "col_3": "float64"}
    lowercase__ :   Tuple    					=				JsonDatasetReader(_lowerCamelCase		,	cache_dir=_lowerCamelCase).read()
    _check_json_dataset(_lowerCamelCase		,	_lowerCamelCase)

def 			lowercase_				(			_lowerCamelCase							:       List[Any]		,	_lowerCamelCase							:       Optional[Any]		,	_lowerCamelCase							:       Optional[int]=("train",)):
    assert isinstance(_lowerCamelCase		,	_lowerCamelCase)
    for split in splits:
        lowercase__ :   Optional[Any]    					=				dataset_dict[split]
        assert dataset.num_rows == 4
        assert dataset.num_columns == 3
        assert dataset.column_names == ["col_1", "col_2", "col_3"]
        for feature, expected_dtype in expected_features.items():
            assert dataset.features[feature].dtype == expected_dtype

@pytest.mark.parametrize("keep_in_memory"		,	[False, True])
def 			lowercase_				(			_lowerCamelCase							:       Union[str, Any]		,	_lowerCamelCase							:       str		,	_lowerCamelCase							:       str):
    lowercase__ :   List[str]    					=				tmp_path / "cache"
    lowercase__ :   str    					=				{"col_1": "string", "col_2": "int64", "col_3": "float64"}
    with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
        lowercase__ :   Optional[Any]    					=				JsonDatasetReader({"train": jsonl_path}		,	cache_dir=_lowerCamelCase		,	keep_in_memory=_lowerCamelCase).read()
    _check_json_datasetdict(_lowerCamelCase		,	_lowerCamelCase)

@pytest.mark.parametrize(
    "features"		,	[
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]		,	)
def 			lowercase_				(			_lowerCamelCase							:       Any		,	_lowerCamelCase							:       List[str]		,	_lowerCamelCase							:       List[str]):
    lowercase__ :   str    					=				tmp_path / "cache"
    lowercase__ :   Tuple    					=				{"col_1": "string", "col_2": "int64", "col_3": "float64"}
    lowercase__ :   Tuple    					=				features.copy() if features else default_expected_features
    lowercase__ :   Union[str, Any]    					=				(
        Features({feature: Value(_lowerCamelCase) for feature, dtype in features.items()}) if features is not None else None
    )
    lowercase__ :   Tuple    					=				JsonDatasetReader({"train": jsonl_path}		,	features=_lowerCamelCase		,	cache_dir=_lowerCamelCase).read()
    _check_json_datasetdict(_lowerCamelCase		,	_lowerCamelCase)

@pytest.mark.parametrize("split"		,	[None, NamedSplit("train"), "train", "test"])
def 			lowercase_				(			_lowerCamelCase							:       str		,	_lowerCamelCase							:       Dict		,	_lowerCamelCase							:       Tuple):
    if split:
        lowercase__ :   Tuple    					=				{split: jsonl_path}
    else:
        lowercase__ :   Tuple    					=				"train"
        lowercase__ :   int    					=				{"train": jsonl_path, "test": jsonl_path}
    lowercase__ :   Dict    					=				tmp_path / "cache"
    lowercase__ :   Union[str, Any]    					=				{"col_1": "string", "col_2": "int64", "col_3": "float64"}
    lowercase__ :   Union[str, Any]    					=				JsonDatasetReader(_lowerCamelCase		,	cache_dir=_lowerCamelCase).read()
    _check_json_datasetdict(_lowerCamelCase		,	_lowerCamelCase		,	splits=list(path.keys()))
    assert all(dataset[split].split == split for split in path.keys())

def 			lowercase_				(			_lowerCamelCase							:       Union[str, Any]):
    return json.load(_lowerCamelCase)

def 			lowercase_				(			_lowerCamelCase							:       Optional[int]):
    return [json.loads(_lowerCamelCase) for line in buffer]



class   snake_case_       :






   @pytest.mark.parametrize("lines, load_json_function"	,						[(True, load_json_lines), (False, load_json)]  )
   def       __UpperCamelCase     (      self				:     List[Any]	,						lowercase_				:     Any	,						lowercase_				:     Optional[Any]	,						lowercase_				:     Dict  )					->						Optional[Any]:
       with io.BytesIO() as buffer:
           JsonDatasetWriter(lowercase_	,						lowercase_	,						lines=lowercase_  ).write()
           buffer.seek(0  )
           lowercase__ :   Optional[int]    					=				load_json_function(lowercase_  )
       assert isinstance(lowercase_	,						lowercase_  )
       assert isinstance(exported_content[0]	,						lowercase_  )
       assert len(lowercase_  ) == 10






   @pytest.mark.parametrize(
       "orient, container, keys, len_at"	,						[
           ("records", list, {"tokens", "labels", "answers", "id"}, None),
           ("split", dict, {"columns", "data"}, "data"),
           ("index", dict, set("0123456789"  ), None),
           ("columns", dict, {"tokens", "labels", "answers", "id"}, "tokens"),
           ("values", list, None, None),
           ("table", dict, {"schema", "data"}, "data"),
       ]	,						)
   def       __UpperCamelCase     (      self				:     str	,						lowercase_				:     int	,						lowercase_				:     str	,						lowercase_				:     Union[str, Any]	,						lowercase_				:     Dict	,						lowercase_				:     Tuple  )					->						List[str]:
       with io.BytesIO() as buffer:
           JsonDatasetWriter(lowercase_	,						lowercase_	,						lines=lowercase_	,						orient=lowercase_  ).write()
           buffer.seek(0  )
           lowercase__ :   str    					=				load_json(lowercase_  )
       assert isinstance(lowercase_	,						lowercase_  )
       if keys:
           if container is dict:
               assert exported_content.keys() == keys
           else:
               assert exported_content[0].keys() == keys
       else:
           assert not hasattr(lowercase_	,						"keys"  ) and not hasattr(exported_content[0]	,						"keys"  )
       if len_at:
           assert len(exported_content[len_at]  ) == 10
       else:
           assert len(lowercase_  ) == 10






   @pytest.mark.parametrize("lines, load_json_function"	,						[(True, load_json_lines), (False, load_json)]  )
   def       __UpperCamelCase     (      self				:     List[Any]	,						lowercase_				:     int	,						lowercase_				:     Optional[Any]	,						lowercase_				:     Dict  )					->						Optional[int]:
       with io.BytesIO() as buffer:
           JsonDatasetWriter(lowercase_	,						lowercase_	,						lines=lowercase_	,						num_proc=2  ).write()
           buffer.seek(0  )
           lowercase__ :   str    					=				load_json_function(lowercase_  )
       assert isinstance(lowercase_	,						lowercase_  )
       assert isinstance(exported_content[0]	,						lowercase_  )
       assert len(lowercase_  ) == 10






   @pytest.mark.parametrize(
       "orient, container, keys, len_at"	,						[
           ("records", list, {"tokens", "labels", "answers", "id"}, None),
           ("split", dict, {"columns", "data"}, "data"),
           ("index", dict, set("0123456789"  ), None),
           ("columns", dict, {"tokens", "labels", "answers", "id"}, "tokens"),
           ("values", list, None, None),
           ("table", dict, {"schema", "data"}, "data"),
       ]	,						)
   def       __UpperCamelCase     (      self				:     Union[str, Any]	,						lowercase_				:     Dict	,						lowercase_				:     Dict	,						lowercase_				:     Optional[int]	,						lowercase_				:     Optional[Any]	,						lowercase_				:     Dict  )					->						Any:
       with io.BytesIO() as buffer:
           JsonDatasetWriter(lowercase_	,						lowercase_	,						lines=lowercase_	,						orient=lowercase_	,						num_proc=2  ).write()
           buffer.seek(0  )
           lowercase__ :   Optional[Any]    					=				load_json(lowercase_  )
       assert isinstance(lowercase_	,						lowercase_  )
       if keys:
           if container is dict:
               assert exported_content.keys() == keys
           else:
               assert exported_content[0].keys() == keys
       else:
           assert not hasattr(lowercase_	,						"keys"  ) and not hasattr(exported_content[0]	,						"keys"  )
       if len_at:
           assert len(exported_content[len_at]  ) == 10
       else:
           assert len(lowercase_  ) == 10






   def       __UpperCamelCase     (      self				:     Dict	,						lowercase_				:     List[str]  )					->						str:
       with pytest.raises(lowercase_  ):
           with io.BytesIO() as buffer:
               JsonDatasetWriter(lowercase_	,						lowercase_	,						num_proc=0  )







   @pytest.mark.parametrize("compression, extension"	,						[("gzip", "gz"), ("bz2", "bz2"), ("xz", "xz")]  )
   def       __UpperCamelCase     (      self				:     List[Any]	,						lowercase_				:     Tuple	,						lowercase_				:     List[str]	,						lowercase_				:     Optional[Any]	,						lowercase_				:     str	,						lowercase_				:     List[Any]  )					->						Any:
       lowercase__ :   Dict    					=				tmp_path_factory.mktemp("data"  ) / F'''test.json.{extension}'''
       lowercase__ :   Optional[int]    					=				str(shared_datadir / F'''test_file.json.{extension}'''  )
       JsonDatasetWriter(lowercase_	,						lowercase_	,						compression=lowercase_  ).write()

       with fsspec.open(lowercase_	,						"rb"	,						compression="infer"  ) as f:
           lowercase__ :   List[Any]    					=				f.read()
       with fsspec.open(lowercase_	,						"rb"	,						compression="infer"  ) as f:
           lowercase__ :   str    					=				f.read()
       assert exported_content == original_content



