"""simple docstring"""



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





def    SCREAMING_SNAKE_CASE       (     snake_case):
     __snake_case				=							0
     while number:
          # Increased Speed Slightly by checking every 5 digits together.
          sum_of_digits_squared += DIGITS_SQUARED[number % 10_00_00]
          number //= 10_00_00

     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		:		Any														=							[None] * 1000_0000
__lowercase		:		List[str]														=							True
__lowercase		:		Optional[Any]														=							False





def    SCREAMING_SNAKE_CASE       (     snake_case):

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

     __snake_case				=							chain(next_number(a_))
     __snake_case				=							number_chain

     while number < 10_00_00_00:
          __snake_case				=							number_chain
          number *= 10

     return number_chain





def    SCREAMING_SNAKE_CASE       (     snake_case = 10_00_00_00):
     for i in range(1,      a_):
          if CHAINS[i] is None:
               chain(i + 1)

     return CHAINS[:number].count(a_)


if __name__ == "__main__":
       import doctest

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



"""simple docstring"""



import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()



@slow
@require_torch_gpu
class      _A	(						unittest.TestCase					):




    """simple docstring"""




    def  lowercase					(		self							:     Tuple    )    ->       str:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
    def  lowercase					(		self							:     int    )    ->       Tuple:
         __snake_case				=							StableDiffusionKDiffusionPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4'''    )
         __snake_case				=							sd_pipe.to(A_    )
         sd_pipe.set_progress_bar_config(disable=A_    )

         sd_pipe.set_scheduler('''sample_euler'''    )

         __snake_case				=							'''A painting of a squirrel eating a burger'''
         __snake_case				=							torch.manual_seed(0    )
         __snake_case				=							sd_pipe([prompt]	,      generator=A_	,      guidance_scale=9.0	,      num_inference_steps=20	,      output_type='''np'''    )

         __snake_case				=							output.images

         __snake_case				=							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         __snake_case				=							np.array([0.04_47, 0.04_92, 0.04_68, 0.04_08, 0.03_83, 0.04_08, 0.03_54, 0.03_80, 0.03_39]    )

         assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2
    def  lowercase					(		self							:     Optional[Any]    )    ->       Tuple:
         __snake_case				=							StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''    )
         __snake_case				=							sd_pipe.to(A_    )
         sd_pipe.set_progress_bar_config(disable=A_    )

         sd_pipe.set_scheduler('''sample_euler'''    )

         __snake_case				=							'''A painting of a squirrel eating a burger'''
         __snake_case				=							torch.manual_seed(0    )
         __snake_case				=							sd_pipe([prompt]	,      generator=A_	,      guidance_scale=9.0	,      num_inference_steps=20	,      output_type='''np'''    )

         __snake_case				=							output.images

         __snake_case				=							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         __snake_case				=							np.array([0.12_37, 0.13_20, 0.14_38, 0.13_59, 0.13_90, 0.11_32, 0.12_77, 0.11_75, 0.11_12]    )

         assert np.abs(image_slice.flatten() - expected_slice    ).max() < 5E-1







    def  lowercase					(		self							:     List[str]    )    ->       Optional[Any]:
         __snake_case				=							StableDiffusionKDiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base'''    )
         __snake_case				=							sd_pipe.to(A_    )
         sd_pipe.set_progress_bar_config(disable=A_    )

         sd_pipe.set_scheduler('''sample_dpmpp_2m'''    )

         __snake_case				=							'''A painting of a squirrel eating a burger'''
         __snake_case				=							torch.manual_seed(0    )
         __snake_case				=							sd_pipe(
             [prompt]	,      generator=A_	,      guidance_scale=7.5	,      num_inference_steps=15	,      output_type='''np'''	,      use_karras_sigmas=A_	,      )

         __snake_case				=							output.images

         __snake_case				=							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         __snake_case				=							np.array(
             [0.11_38_16_89, 0.12_11_29_21, 0.1_38_94_57, 0.12_54_96_06, 0.1_24_49_64, 0.10_83_15_17, 0.11_56_28_66, 0.10_86_78_16, 0.10_49_90_48]    )

         assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2