



"""simple docstring"""
A:   int								=		[sum(int(c, 1_0) ** 2 for c in i.__str__()) for i in range(1_0_0_0_0_0)]

def       _snake_case						(						UpperCamelCase						:		int						):
 UpperCAmelCase	:					Optional[int]	=	0
 while number:
  # Increased Speed Slightly by checking every 5 digits together.
  sum_of_digits_squared += DIGITS_SQUARED[number % 100000]
  number //= 100000

 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
A:   list[bool | None]								=		[None] * 1_0_0_0_0_0_0_0
A:   List[str]								=		True
A:   Optional[int]								=		False

def       _snake_case						(						UpperCamelCase						:		int						):





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

 UpperCAmelCase	:					Tuple	=	chain(next_number(__SCREAMING_SNAKE_CASE						)						)
 UpperCAmelCase	:					Union[str, Any]	=	number_chain

 while number < 10000000:
  UpperCAmelCase	:					int	=	number_chain
  number *= 10

 return number_chain

def       _snake_case						(						UpperCamelCase						:		int = 10000000						):





 for i in range(1			,		__SCREAMING_SNAKE_CASE						):
  if CHAINS[i] is None:
   chain(i + 1						)

 return CHAINS[:number].count(__SCREAMING_SNAKE_CASE						)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      print(f"""{solution() = }""")


'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_lowercase :  Union[str, Any]    							=       {
    "configuration_pix2struct": [
        "PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Pix2StructConfig",
        "Pix2StructTextConfig",
        "Pix2StructVisionConfig",
    ],
    "processing_pix2struct": ["Pix2StructProcessor"],
}

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_lowercase :  Dict    							=       ["Pix2StructImageProcessor"]


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_lowercase :  List[str]    							=       [
							    "PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "Pix2StructPreTrainedModel",
							    "Pix2StructForConditionalGeneration",
							    "Pix2StructVisionModel",
							    "Pix2StructTextModel",
							]

if TYPE_CHECKING:
							from .configuration_pixastruct import (
							    PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    PixaStructConfig,
							    PixaStructTextConfig,
							    PixaStructVisionConfig,
							)
							from .processing_pixastruct import PixaStructProcessor

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .image_processing_pixastruct import PixaStructImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_pixastruct import (
														    PIX2STRUCT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    PixaStructForConditionalGeneration,
														    PixaStructPreTrainedModel,
														    PixaStructTextModel,
														    PixaStructVisionModel,
														)

else:
							import sys

							_lowercase :  Optional[int]    							=       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



