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






def        a_		(       __lowercase   :	int ) ->  int:
			_snake_case		=			0
			while number:
						# Increased Speed Slightly by checking every 5 digits together.
						sum_of_digits_squared += DIGITS_SQUARED[number % 100_000]
						number //= 100_000

			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
_lowerCamelCase       :				list[bool | None]       =			[None] * 10_000_000
_lowerCamelCase       :				Optional[Any]       =			True
_lowerCamelCase       :				int       =			False






def        a_		(       __lowercase   :	int ) ->  bool:

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

			_snake_case		=			chain(next_number(__lowercase ) )
			_snake_case		=			number_chain

			while number < 10_000_000:
						_snake_case		=			number_chain
						number *= 10

			return number_chain






def        a_		(       __lowercase   :	int = 10_000_000 ) ->  int:
			for i in range(1       ,					__lowercase ):
						if CHAINS[i] is None:
									chain(i + 1 )

			return CHAINS[:number].count(__lowercase )


if __name__ == "__main__":
			import doctest

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

import unittest

import torch

from diffusers import DDIMScheduler, DDPMScheduler, UNetaDModel
from diffusers.training_utils import set_seed
from diffusers.utils.testing_utils import slow


_lowerCamelCase       :				int       =			False




class    SCREAMING_SNAKE_CASE__     (	unittest.TestCase					):





	'''simple docstring'''



	def  A							(  self	:    Union[str, Any]			,  lowercase	:    Optional[int]=32	):


				'''simple docstring'''


				set_seed(0	)
				_snake_case		=			UNetaDModel(sample_size=lowercase			,  in_channels=3			,  out_channels=3	)
				_snake_case		=			torch.optim.SGD(model.parameters()			,  lr=0.0001	)
				return model, optimizer





	@slow
	def  A							(  self	:    List[str]	):


				'''simple docstring'''


				_snake_case		=			'cpu'  # ensure full determinism without setting the CUBLAS_WORKSPACE_CONFIG env variable
				_snake_case		=			DDPMScheduler(
				    num_train_timesteps=1_000			,  beta_start=0.0001			,  beta_end=0.02			,  beta_schedule='linear'			,  clip_sample=lowercase			,  )
				_snake_case		=			DDIMScheduler(
				    num_train_timesteps=1_000			,  beta_start=0.0001			,  beta_end=0.02			,  beta_schedule='linear'			,  clip_sample=lowercase			,  )

				assert ddpm_scheduler.config.num_train_timesteps == ddim_scheduler.config.num_train_timesteps

				# shared batches for DDPM and DDIM
				set_seed(0	)
				_snake_case		=			[torch.randn((4, 3, 32, 32)	).clip(-1			,  1	).to(lowercase	) for _ in range(4	)]
				_snake_case		=			[torch.randn((4, 3, 32, 32)	).to(lowercase	) for _ in range(4	)]
				_snake_case		=			[torch.randint(0			,  1_000			,  (4,)	).long().to(lowercase	) for _ in range(4	)]

				# train with a DDPM scheduler
				_snake_case	,					_snake_case		=			self.get_model_optimizer(resolution=32	)
				model.train().to(lowercase	)
				for i in range(4	):
							optimizer.zero_grad()
							_snake_case		=			ddpm_scheduler.add_noise(clean_images[i]			,  noise[i]			,  timesteps[i]	)
							_snake_case		=			model(lowercase			,  timesteps[i]	).sample
							_snake_case		=			torch.nn.functional.mse_loss(lowercase			,  noise[i]	)
							loss.backward()
							optimizer.step()
				del model, optimizer

				# recreate the model and optimizer, and retry with DDIM
				_snake_case	,					_snake_case		=			self.get_model_optimizer(resolution=32	)
				model.train().to(lowercase	)
				for i in range(4	):
							optimizer.zero_grad()
							_snake_case		=			ddim_scheduler.add_noise(clean_images[i]			,  noise[i]			,  timesteps[i]	)
							_snake_case		=			model(lowercase			,  timesteps[i]	).sample
							_snake_case		=			torch.nn.functional.mse_loss(lowercase			,  noise[i]	)
							loss.backward()
							optimizer.step()
				del model, optimizer

				self.assertTrue(torch.allclose(lowercase			,  lowercase			,  atol=1E-5	)	)
				self.assertTrue(torch.allclose(lowercase			,  lowercase			,  atol=1E-5	)	)