


"""simple docstring"""




lowerCAmelCase	=							[sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(10_0000)]
def       _a			(				SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




		lowercase__						=				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
lowerCAmelCase	=							[None] * 1000_0000
lowerCAmelCase	=							True
lowerCAmelCase	=							False
def       _a			(				SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




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

		lowercase__						=				chain(next_number(SCREAMING_SNAKE_CASE					)					)
		lowercase__						=				number_chain

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

		return number_chain
def       _a			(				SCREAMING_SNAKE_CASE = 10_00_00_00					):


		"""simple docstring"""




		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() = }""")






import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
			import torch

			from transformers.activations import gelu_new, gelu_python, get_activation


@require_torch
class 	_a							(      unittest.TestCase      ):

							def 				lowerCamelCase_			(							self:     Dict							)      ->       Any:





									"""simple docstring"""







									lowercase__						=				torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]							)
									lowercase__						=				get_activation('''gelu'''							)
									self.assertTrue(torch.allclose(gelu_python(UpperCamelCase_							)   ,						torch_builtin(UpperCamelCase_							)							)							)
									self.assertFalse(torch.allclose(gelu_python(UpperCamelCase_							)   ,						gelu_new(UpperCamelCase_							)							)							)

							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       str:





									"""simple docstring"""







									lowercase__						=				torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]							)
									lowercase__						=				get_activation('''gelu'''							)
									lowercase__						=				get_activation('''gelu_10'''							)

									lowercase__						=				torch_builtin(UpperCamelCase_							)
									lowercase__						=				geluaa(UpperCamelCase_							)

									lowercase__						=				torch.where(y_gelu_aa < 10.0   ,						1   ,						0							)

									self.assertTrue(torch.max(UpperCamelCase_							).item() == 10.0							)
									self.assertTrue(torch.allclose(y_gelu * clipped_mask   ,						y_gelu_aa * clipped_mask							)							)

							def 				lowerCamelCase_			(							self:     Union[str, Any]							)      ->       Tuple:





									"""simple docstring"""







									get_activation('''gelu'''							)
									get_activation('''gelu_10'''							)
									get_activation('''gelu_fast'''							)
									get_activation('''gelu_new'''							)
									get_activation('''gelu_python'''							)
									get_activation('''gelu_pytorch_tanh'''							)
									get_activation('''linear'''							)
									get_activation('''mish'''							)
									get_activation('''quick_gelu'''							)
									get_activation('''relu'''							)
									get_activation('''sigmoid'''							)
									get_activation('''silu'''							)
									get_activation('''swish'''							)
									get_activation('''tanh'''							)
									with self.assertRaises(UpperCamelCase_							):
											get_activation('''bogus'''							)
									with self.assertRaises(UpperCamelCase_							):
											get_activation(UpperCamelCase_							)


							def 				lowerCamelCase_			(							self:     Tuple							)      ->       int:





									"""simple docstring"""







									lowercase__						=				get_activation('''gelu'''							)
									lowercase__						=				1
									lowercase__						=				get_activation('''gelu'''							)
									self.assertEqual(acta.a   ,						1							)
									with self.assertRaises(UpperCamelCase_							):
											lowercase__						=				acta.a


