






def        lowerCAmelCase (      )       ->							List[Any]:







  '''simple docstring'''







  _a							=	[]
  _a							=	1

  while len(A_					) < 1E6:
    constant.append(str(A_					)					)
    i += 1

  _a							=	"".join(A_					)

  return (
      int(constant[0]					)
      * int(constant[9]					)
      * int(constant[99]					)
      * int(constant[999]					)
      * int(constant[9999]					)
      * int(constant[99999]					)
      * int(constant[999999]					)
  )


if __name__ == "__main__":
     print(solution())










"""simple docstring"""




import torch

from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest




class    lowercase_    (_UpperCAmelCase     ):
      A__	:		Tuple       			=				(KDPMaDiscreteScheduler,)
      A__	:		Tuple       			=				10






      def 			lowerCamelCase__    (    self     ,     **a_	)	->List[str]:







        '''simple docstring'''


        _a							=	{
            "num_train_timesteps": 1_1_0_0,
            "beta_start": 0.0_001,
            "beta_end": 0.02,
            "beta_schedule": "linear",
        }

        config.update(**a_	)
        return config






      def 			lowerCamelCase__    (    self	)	->Tuple:







        '''simple docstring'''


        for timesteps in [1_0, 5_0, 1_0_0, 1_0_0_0]:
          self.check_over_configs(num_train_timesteps=a_	)






      def 			lowerCamelCase__    (    self	)	->List[Any]:







        '''simple docstring'''


        for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001]     ,     [0.0_002, 0.002, 0.02]	):
          self.check_over_configs(beta_start=a_     ,     beta_end=a_	)






      def 			lowerCamelCase__    (    self	)	->Any:







        '''simple docstring'''


        for schedule in ["linear", "scaled_linear"]:
          self.check_over_configs(beta_schedule=a_	)






      def 			lowerCamelCase__    (    self	)	->int:







        '''simple docstring'''


        for prediction_type in ["epsilon", "v_prediction"]:
          self.check_over_configs(prediction_type=a_	)






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







        '''simple docstring'''


        _a							=	self.scheduler_classes[0]
        _a							=	self.get_scheduler_config(prediction_type="v_prediction"	)
        _a							=	scheduler_class(**a_	)

        scheduler.set_timesteps(self.num_inference_steps	)

        _a							=	self.dummy_model()
        _a							=	self.dummy_sample_deter * scheduler.init_noise_sigma
        _a							=	sample.to(a_	)

        for i, t in enumerate(scheduler.timesteps	):
          _a							=	scheduler.scale_model_input(a_     ,     a_	)

          _a							=	model(a_     ,     a_	)

          _a							=	scheduler.step(a_     ,     a_     ,     a_	)
          _a							=	output.prev_sample

        _a							=	torch.sum(torch.abs(a_	)	)
        _a							=	torch.mean(torch.abs(a_	)	)

        if torch_device in ["cpu", "mps"]:
          assert abs(result_sum.item() - 4.6_934E-07	) < 1E-2
          assert abs(result_mean.item() - 6.1_112E-10	) < 1E-3
        else:
          # CUDA
          assert abs(result_sum.item() - 4.693_428_650_170_972E-07	) < 1E-2
          assert abs(result_mean.item() - 0.0_002	) < 1E-3






      def 			lowerCamelCase__    (    self	)	->Any:







        '''simple docstring'''


        if torch_device == "mps":
          return
        _a							=	self.scheduler_classes[0]
        _a							=	self.get_scheduler_config()
        _a							=	scheduler_class(**a_	)

        scheduler.set_timesteps(self.num_inference_steps	)

        _a							=	self.dummy_model()
        _a							=	self.dummy_sample_deter * scheduler.init_noise_sigma
        _a							=	sample.to(a_	)

        for i, t in enumerate(scheduler.timesteps	):
          _a							=	scheduler.scale_model_input(a_     ,     a_	)

          _a							=	model(a_     ,     a_	)

          _a							=	scheduler.step(a_     ,     a_     ,     a_	)
          _a							=	output.prev_sample

        _a							=	torch.sum(torch.abs(a_	)	)
        _a							=	torch.mean(torch.abs(a_	)	)

        if torch_device in ["cpu", "mps"]:
          assert abs(result_sum.item() - 20.4_125	) < 1E-2
          assert abs(result_mean.item() - 0.0_266	) < 1E-3
        else:
          # CUDA
          assert abs(result_sum.item() - 20.4_125	) < 1E-2
          assert abs(result_mean.item() - 0.0_266	) < 1E-3






      def 			lowerCamelCase__    (    self	)	->int:







        '''simple docstring'''


        if torch_device == "mps":
          return
        _a							=	self.scheduler_classes[0]
        _a							=	self.get_scheduler_config()
        _a							=	scheduler_class(**a_	)

        scheduler.set_timesteps(self.num_inference_steps     ,     device=a_	)

        _a							=	self.dummy_model()
        _a							=	self.dummy_sample_deter.to(a_	) * scheduler.init_noise_sigma

        for t in scheduler.timesteps:
          _a							=	scheduler.scale_model_input(a_     ,     a_	)

          _a							=	model(a_     ,     a_	)

          _a							=	scheduler.step(a_     ,     a_     ,     a_	)
          _a							=	output.prev_sample

        _a							=	torch.sum(torch.abs(a_	)	)
        _a							=	torch.mean(torch.abs(a_	)	)

        if str(a_	).startswith("cpu"	):
          # The following sum varies between 148 and 156 on mps. Why?
          assert abs(result_sum.item() - 20.4_125	) < 1E-2
          assert abs(result_mean.item() - 0.0_266	) < 1E-3
        else:
          # CUDA
          assert abs(result_sum.item() - 20.4_125	) < 1E-2
          assert abs(result_mean.item() - 0.0_266	) < 1E-3


