
lowercase__		:Optional[Any]			  =   [sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(10_0000)]



def 	UpperCamelCase   (							lowerCAmelCase__		):
					'''simple docstring'''
					lowercase						     =						0
					while number:
										# Increased Speed Slightly by checking every 5 digits together.
										sum_of_digits_squared += DIGITS_SQUARED[number % 10_0000]
										number //= 10_0000

					return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
lowercase__		:list[bool | None]			  =   [None] * 1000_0000
lowercase__		:Optional[Any]			  =   True
lowercase__		:str			  =   False



def 	UpperCamelCase   (							lowerCAmelCase__		):
					'''simple docstring'''

					if CHAINS[number - 1] is not None:
										return CHAINS[number - 1]  # type: ignore

					lowercase						     =						chain(next_number(lowerCAmelCase__		)		)
					lowercase						     =						number_chain

					while number < 1000_0000:
										lowercase						     =						number_chain
										number *= 10

					return number_chain



def 	UpperCamelCase   (							lowerCAmelCase__ = 1000_0000		):
					'''simple docstring'''
					for i in range(1			,      lowerCAmelCase__		):
										if CHAINS[i] is None:
															chain(i + 1		)

					return CHAINS[:number].count(lowerCAmelCase__		)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							print(F'{solution() = }')






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__		:Dict			  =   {
    "configuration_luke": ["LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP", "LukeConfig"],
    "tokenization_luke": ["LukeTokenizer"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__		:List[str]			  =   [
							    "LUKE_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "LukeForEntityClassification",
							    "LukeForEntityPairClassification",
							    "LukeForEntitySpanClassification",
							    "LukeForMultipleChoice",
							    "LukeForQuestionAnswering",
							    "LukeForSequenceClassification",
							    "LukeForTokenClassification",
							    "LukeForMaskedLM",
							    "LukeModel",
							    "LukePreTrainedModel",
							]


if TYPE_CHECKING:
							from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
							from .tokenization_luke import LukeTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_luke import (
														    LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
														    LukeForEntityClassification,
														    LukeForEntityPairClassification,
														    LukeForEntitySpanClassification,
														    LukeForMaskedLM,
														    LukeForMultipleChoice,
														    LukeForQuestionAnswering,
														    LukeForSequenceClassification,
														    LukeForTokenClassification,
														    LukeModel,
														    LukePreTrainedModel,
														)

else:
							import sys

							lowercase__		:Tuple			  =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




