

def 					lowerCamelCase_     (							UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     int	)						->				int:




	'''simple docstring'''




	while a != 0:
		_UpperCamelCase	,		_UpperCamelCase   :		List[str]			=						b % a, a
	return b







def 					lowerCamelCase_     (							UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     int	)						->				int:




	'''simple docstring'''




	if gcd(UpperCAmelCase_							,       UpperCAmelCase_	) != 1:
		_UpperCamelCase   :		Dict			=						F'''mod inverse of {a!r} and {m!r} does not exist'''
		raise ValueError(UpperCAmelCase_	)
	_UpperCamelCase	,		_UpperCamelCase	,		_UpperCamelCase   :		List[str]			=						1, 0, a
	_UpperCamelCase	,		_UpperCamelCase	,		_UpperCamelCase   :		List[str]			=						0, 1, m
	while va != 0:
		_UpperCamelCase   :		Any			=						ua // va
		_UpperCamelCase	,		_UpperCamelCase	,		_UpperCamelCase	,		_UpperCamelCase	,		_UpperCamelCase	,		_UpperCamelCase   :		int			=						(ua - q * va), (ua - q * va), (ua - q * va), va, va, va
	return ua % m







lowerCAmelCase__								=		range(2, 2_0 + 1)
lowerCAmelCase__								=		[1_0**k for k in range(ks[-1] + 1)]
lowerCAmelCase__								=		{}






def 					lowerCamelCase_     (							UpperCAmelCase_							:     Optional[Any]							,       UpperCAmelCase_							:     List[str]							,       UpperCAmelCase_							:     Any							,       UpperCAmelCase_							:     int	)						->				Tuple:




	'''simple docstring'''




	_UpperCamelCase   :		Dict			=						sum(a_i[j] for j in range(UpperCAmelCase_							,       len(UpperCAmelCase_	)	)	)
	_UpperCamelCase   :		Optional[int]			=						sum(a_i[j] * base[j] for j in range(min(len(UpperCAmelCase_	)							,       UpperCAmelCase_	)	)	)

	_UpperCamelCase	,		_UpperCamelCase   :		Dict			=						0, 0
	_UpperCamelCase   :		Optional[int]			=						n - i

	_UpperCamelCase   :		Union[str, Any]			=						memo.get(UpperCAmelCase_	)

	if sub_memo is not None:
		_UpperCamelCase   :		str			=						sub_memo.get(UpperCAmelCase_	)

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

			if max_jump >= 0:
				_UpperCamelCase	,		_UpperCamelCase	,		_UpperCamelCase   :		Optional[Any]			=						jumps[max_jump]
				# since the difference between jumps is cached, add c
				_UpperCamelCase   :		Tuple			=						diff + c
				for j in range(min(UpperCAmelCase_							,       len(UpperCAmelCase_	)	)	):
					_UpperCamelCase	,		_UpperCamelCase   :		Dict			=						divmod(UpperCAmelCase_							,       1_0	)
				if new_c > 0:
					add(UpperCAmelCase_							,       UpperCAmelCase_							,       UpperCAmelCase_	)

		else:
			_UpperCamelCase   :		Union[str, Any]			=						[]
	else:
		_UpperCamelCase   :		List[Any]			=						{c: []}
		_UpperCamelCase   :		Optional[int]			=						sub_memo

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

	if k > ks[0]:
		while True:
			# keep doing smaller jumps
			_UpperCamelCase	,		_UpperCamelCase   :		Optional[Any]			=						next_term(UpperCAmelCase_							,       k - 1							,       i + dn							,       UpperCAmelCase_	)
			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
		_UpperCamelCase	,		_UpperCamelCase   :		Any			=						compute(UpperCAmelCase_							,       UpperCAmelCase_							,       i + dn							,       UpperCAmelCase_	)
		diff += _diff
		dn += terms_jumped

	_UpperCamelCase   :		List[str]			=						sub_memo[c]

	# keep jumps sorted by # of terms skipped
	_UpperCamelCase   :		Union[str, Any]			=						0
	while j < len(UpperCAmelCase_	):
		if jumps[j][1] > dn:
			break
		j += 1

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






def 					lowerCamelCase_     (							UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     Dict							,       UpperCAmelCase_							:     Any							,       UpperCAmelCase_							:     Any	)						->				Dict:




	'''simple docstring'''




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

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

	while i < n:
		i += 1
		_UpperCamelCase   :		Union[str, Any]			=						ds_c + ds_b
		diff += addend
		_UpperCamelCase   :		Union[str, Any]			=						0
		for j in range(UpperCAmelCase_	):
			_UpperCamelCase   :		Union[str, Any]			=						a_i[j] + addend
			_UpperCamelCase	,		_UpperCamelCase   :		Any			=						divmod(UpperCAmelCase_							,       1_0	)

			ds_c += a_i[j]

		if addend > 0:
			break

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






def 					lowerCamelCase_     (							UpperCAmelCase_							:     Union[str, Any]							,       UpperCAmelCase_							:     Optional[int]							,       UpperCAmelCase_							:     Any	)						->				Dict:




	'''simple docstring'''




	for j in range(UpperCAmelCase_							,       len(UpperCAmelCase_	)	):
		_UpperCamelCase   :		List[str]			=						digits[j] + addend
		if s >= 1_0:
			_UpperCamelCase	,		_UpperCamelCase   :		Any			=						divmod(UpperCAmelCase_							,       1_0	)
			_UpperCamelCase   :		Union[str, Any]			=						addend // 1_0 + quotient
		else:
			_UpperCamelCase   :		Dict			=						s
			_UpperCamelCase   :		Optional[Any]			=						addend // 1_0

		if addend == 0:
			break

	while addend > 0:
		_UpperCamelCase	,		_UpperCamelCase   :		Dict			=						divmod(UpperCAmelCase_							,       1_0	)
		digits.append(UpperCAmelCase_	)






def 					lowerCamelCase_     (							UpperCAmelCase_							:     int = 1_0**1_5	)						->				int:




	'''simple docstring'''




	_UpperCamelCase   :		Optional[Any]			=						[1]
	_UpperCamelCase   :		Optional[int]			=						1
	_UpperCamelCase   :		int			=						0
	while True:
		_UpperCamelCase	,		_UpperCamelCase   :		List[Any]			=						next_term(UpperCAmelCase_							,       2_0							,       i + dn							,       UpperCAmelCase_	)
		dn += terms_jumped
		if dn == n - i:
			break

	_UpperCamelCase   :		str			=						0
	for j in range(len(UpperCAmelCase_	)	):
		a_n += digits[j] * 1_0**j
	return a_n


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




