




__lowerCAmelCase		:				Any       			=		range(2, 20 + 1)
__lowerCAmelCase		:				str       			=		[10**k for k in range(ks[-1] + 1)]
__lowerCAmelCase		:				dict[int, dict[int, list[list[int]]]]       			=		{}




def 			__magic_name__				( A		:					Optional[int],  A		:					List[Any],  A		:					List[Any],  A		:					Tuple   ):






			'''simple docstring'''







			a    =			sum(a_i[j] for j in range(A,  len(A   )   )   )
			a    =			sum(a_i[j] * base[j] for j in range(min(len(A   ),  A   )   )   )

			a    ,		a    =			0, 0
			a    =			n - i

			a    =			memo.get(A   )

			if sub_memo is not None:
						a    =			sub_memo.get(A   )

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

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

						else:
									a    =			[]
			else:
						a    =			{c: []}
						a    =			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    ,		a    =			next_term(A,  k - 1,  i + dn,  A   )
									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    ,		a    =			compute(A,  A,  i + dn,  A   )
						diff += _diff
						dn += terms_jumped

			a    =			sub_memo[c]

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

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




def 			__magic_name__				( A		:					str,  A		:					Union[str, Any],  A		:					Optional[int],  A		:					List[str]   ):






			'''simple docstring'''







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

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

			while i < n:
						i += 1
						a    =			ds_c + ds_b
						diff += addend
						a    =			0
						for j in range(A   ):
									a    =			a_i[j] + addend
									a    ,		a    =			divmod(A,  10   )

									ds_c += a_i[j]

						if addend > 0:
									break

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




def 			__magic_name__				( A		:					int,  A		:					Any,  A		:					Optional[Any]   ):






			'''simple docstring'''







			for j in range(A,  len(A   )   ):
						a    =			digits[j] + addend
						if s >= 10:
									a    ,		a    =			divmod(A,  10   )
									a    =			addend // 10 + quotient
						else:
									a    =			s
									a    =			addend // 10

						if addend == 0:
									break

			while addend > 0:
						a    ,		a    =			divmod(A,  10   )
						digits.append(A   )




def 			__magic_name__				( A		:					int = 10**15   ):






			'''simple docstring'''







			a    =			[1]
			a    =			1
			a    =			0
			while True:
						a    ,		a    =			next_term(A,  20,  i + dn,  A   )
						dn += terms_jumped
						if dn == n - i:
									break

			a    =			0
			for j in range(len(A   )   ):
						a_n += digits[j] * 10**j
			return a_n


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










'''simple docstring'''


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
				import torch

				from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin





class     lowercase__  :





							'''simple docstring'''


							def __init__(    self    ,					__snake_case    ,					__snake_case=None    ,					__snake_case=None    ,					__snake_case=None    ,					__snake_case="resnet50"    ,					__snake_case=3    ,					__snake_case=32    ,					__snake_case=3    ,					__snake_case=True    ,					__snake_case=True    ,					):
											_SCREAMING_SNAKE_CASE :       Tuple     		=      parent
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      out_indices if out_indices is not None else [4]
											_SCREAMING_SNAKE_CASE :       str     		=      stage_names
											_SCREAMING_SNAKE_CASE :       List[str]     		=      out_features
											_SCREAMING_SNAKE_CASE :       int     		=      backbone
											_SCREAMING_SNAKE_CASE :       Any     		=      batch_size
											_SCREAMING_SNAKE_CASE :       List[str]     		=      image_size
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      num_channels
											_SCREAMING_SNAKE_CASE :       int     		=      use_pretrained_backbone
											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      is_training






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       int     		=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )
											_SCREAMING_SNAKE_CASE :       List[Any]     		=      self.get_config()

											return config, pixel_values






							def UpperCAmelCase_	(    self  ):
											return TimmBackboneConfig(
											    image_size=self.image_size    ,					num_channels=self.num_channels    ,					out_features=self.out_features    ,					out_indices=self.out_indices    ,					stage_names=self.stage_names    ,					use_pretrained_backbone=self.use_pretrained_backbone    ,					backbone=self.backbone    ,					)






							def UpperCAmelCase_	(    self    ,					__snake_case    ,					__snake_case  ):
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      TimmBackbone(config=__snake_case  )
											model.to(__snake_case  )
											model.eval()
											with torch.no_grad():
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      model(__snake_case  )
											self.parent.assertEqual(
											    result.feature_map[-1].shape    ,					(self.batch_size, model.channels[-1], 14, 14)    ,					)






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Tuple     		=      self.prepare_config_and_inputs()
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       Any     		=      config_and_inputs
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      {"""pixel_values""": pixel_values}
											return config, inputs_dict





@require_torch
@require_timm
class     lowercase__  (						_snake_case     ,     _snake_case     ,     _snake_case     ,     unittest.TestCase					):





							'''simple docstring'''


							A_							:      Optional[Any]      	=  (TimmBackbone,) if is_torch_available() else ()
							A_							:      Tuple      	=  {"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
							A_							:      Optional[Any]      	=  False
							A_							:      List[Any]      	=  False
							A_							:      Dict      	=  False
							A_							:      int      	=  False






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Any     		=      TimmBackboneModelTester(self  )
											_SCREAMING_SNAKE_CASE :       int     		=      ConfigTester(self    ,					config_class=__snake_case    ,					has_text_modality=__snake_case  )






							def UpperCAmelCase_	(    self  ):
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      """resnet18"""
											_SCREAMING_SNAKE_CASE :       Tuple     		=      """microsoft/resnet-18"""

											_SCREAMING_SNAKE_CASE :       List[str]     		=      AutoBackbone.from_pretrained(__snake_case    ,					use_timm_backbone=__snake_case  )
											_SCREAMING_SNAKE_CASE :       Tuple     		=      AutoBackbone.from_pretrained(__snake_case  )

											self.assertEqual(len(timm_model.out_features  )    ,					len(transformers_model.out_features  )  )
											self.assertEqual(len(timm_model.stage_names  )    ,					len(transformers_model.stage_names  )  )
											self.assertEqual(timm_model.channels    ,					transformers_model.channels  )
											# Out indices are set to the last layer by default. For timm models, we don't know
											# the number of layers in advance, so we set it to (-1,), whereas for transformers
											# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
											self.assertEqual(timm_model.out_indices    ,					(-1,)  )
											self.assertEqual(transformers_model.out_indices    ,					[len(timm_model.stage_names  ) - 1]  )

											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      AutoBackbone.from_pretrained(__snake_case    ,					use_timm_backbone=__snake_case    ,					out_indices=[1, 2, 3]  )
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      AutoBackbone.from_pretrained(__snake_case    ,					out_indices=[1, 2, 3]  )

											self.assertEqual(timm_model.out_indices    ,					transformers_model.out_indices  )
											self.assertEqual(len(timm_model.out_features  )    ,					len(transformers_model.out_features  )  )
											self.assertEqual(timm_model.channels    ,					transformers_model.channels  )






							@unittest.skip("""TimmBackbone doesn't support feed forward chunking"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone initialization is managed on the timm side"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""model weights aren't tied in TimmBackbone."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""model weights aren't tied in TimmBackbone."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone doesn't support output_attentions."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Safetensors is not supported by timm."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       List[Any]     		=      self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE :       List[str]     		=      model_class(__snake_case  )
															_SCREAMING_SNAKE_CASE :       Tuple     		=      inspect.signature(model.forward  )
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_SCREAMING_SNAKE_CASE :       int     		=      [*signature.parameters.keys()]

															_SCREAMING_SNAKE_CASE :       List[Any]     		=      ["""pixel_values"""]
															self.assertListEqual(arg_names[:1]    ,					__snake_case  )






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       List[Any]     		=      self.model_tester.prepare_config_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE :       Tuple     		=      True
											_SCREAMING_SNAKE_CASE :       List[str]     		=      self.has_attentions

											# no need to test all models as different heads yield the same functionality
											_SCREAMING_SNAKE_CASE :       str     		=      self.all_model_classes[0]
											_SCREAMING_SNAKE_CASE :       str     		=      model_class(__snake_case  )
											model.to(__snake_case  )

											_SCREAMING_SNAKE_CASE :       Tuple     		=      self._prepare_for_class(__snake_case    ,					__snake_case  )
											_SCREAMING_SNAKE_CASE :       Tuple     		=      model(**__snake_case  )
											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      outputs[0][-1]

											# Encoder-/Decoder-only models
											_SCREAMING_SNAKE_CASE :       str     		=      outputs.hidden_states[0]
											hidden_states.retain_grad()

											if self.has_attentions:
															_SCREAMING_SNAKE_CASE :       Optional[int]     		=      outputs.attentions[0]
															attentions.retain_grad()

											output.flatten()[0].backward(retain_graph=__snake_case  )

											self.assertIsNotNone(hidden_states.grad  )

											if self.has_attentions:
															self.assertIsNotNone(attentions.grad  )






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE :       str     		=      model_class(__snake_case  )
															model.to(__snake_case  )
															model.eval()
															_SCREAMING_SNAKE_CASE :       List[str]     		=      model(**__snake_case  )

															self.assertEqual(len(result.feature_maps  )    ,					len(config.out_indices  )  )
															self.assertEqual(len(model.channels  )    ,					len(config.out_indices  )  )

															# Check output of last stage is taken if out_features=None, out_indices=None
															_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      copy.deepcopy(__snake_case  )
															_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      None
															_SCREAMING_SNAKE_CASE :       Tuple     		=      model_class(__snake_case  )
															model.to(__snake_case  )
															model.eval()
															_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      model(**__snake_case  )

															self.assertEqual(len(result.feature_maps  )    ,					1  )
															self.assertEqual(len(model.channels  )    ,					1  )

															# Check backbone can be initialized with fresh weights
															_SCREAMING_SNAKE_CASE :       str     		=      copy.deepcopy(__snake_case  )
															_SCREAMING_SNAKE_CASE :       Tuple     		=      False
															_SCREAMING_SNAKE_CASE :       Optional[int]     		=      model_class(__snake_case  )
															model.to(__snake_case  )
															model.eval()
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      model(**__snake_case  )




