





import tempfile
import unittest

from diffusers import (
    DDIMScheduler,
    DDPMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    PNDMScheduler,
    logging,
)
from diffusers.configuration_utils import ConfigMixin, register_to_config
from diffusers.utils.testing_utils import CaptureLogger





class A_   (     _lowerCamelCase  ):
   lowerCAmelCase__  	=					"""config.json"""




   @register_to_config
   def __init__(self      :Tuple       ,  _UpperCamelCase      :Dict=2       ,  _UpperCamelCase      :Union[str, Any]=5       ,  _UpperCamelCase      :List[Any]=(2, 5)       ,  _UpperCamelCase      :List[Any]="for diffusion"       ,  _UpperCamelCase      :Dict=[1, 3]       ,  )->   List[str]:
         pass





class A_   (     _lowerCamelCase  ):
   lowerCAmelCase__  	=					"""config.json"""




   @register_to_config
   def __init__(self      :Optional[Any]       ,  _UpperCamelCase      :Optional[Any]=2       ,  _UpperCamelCase      :List[Any]=5       ,  _UpperCamelCase      :Any=(2, 5)       ,  _UpperCamelCase      :List[str]="for diffusion"       ,  _UpperCamelCase      :Tuple=[1, 3]       ,  )->   Tuple:
         pass





class A_   (     _lowerCamelCase  ):
   lowerCAmelCase__  	=					"""config.json"""




   @register_to_config
   def __init__(self      :List[Any]       ,  _UpperCamelCase      :Dict=2       ,  _UpperCamelCase      :Tuple=5       ,  _UpperCamelCase      :Union[str, Any]=(2, 5)       ,  _UpperCamelCase      :List[Any]="for diffusion"       ,  _UpperCamelCase      :int=[1, 3]       ,  _UpperCamelCase      :Optional[Any]=[1, 3]       ,  )->   Tuple:
         pass





class A_   (     _lowerCamelCase  ):
   lowerCAmelCase__  	=					"""config.json"""




   @register_to_config
   def __init__(self      :int       ,  _UpperCamelCase      :Optional[int]=2       ,  _UpperCamelCase      :int=5       ,  _UpperCamelCase      :Any=(2, 5)       ,  _UpperCamelCase      :List[str]="for diffusion"       ,  _UpperCamelCase      :Union[str, Any]=[1, 5]       ,  _UpperCamelCase      :Optional[Any]=[5, 4]       ,  )->   Any:
         pass





class A_   (     unittest.TestCase  ):




   def _lowerCAmelCase (self      :Tuple					)->   List[str]:
         with self.assertRaises(_UpperCamelCase					):
               ConfigMixin.load_config('''dummy_path'''					)




   def _lowerCAmelCase (self      :Tuple					)->   Dict:
         __A			  =							SampleObject()
         __A			  =							obj.config
         assert config["a"] == 2
         assert config["b"] == 5
         assert config["c"] == (2, 5)
         assert config["d"] == "for diffusion"
         assert config["e"] == [1, 3]

         # init ignore private arguments
         __A			  =							SampleObject(_name_or_path='''lalala'''					)
         __A			  =							obj.config
         assert config["a"] == 2
         assert config["b"] == 5
         assert config["c"] == (2, 5)
         assert config["d"] == "for diffusion"
         assert config["e"] == [1, 3]

         # can override default
         __A			  =							SampleObject(c=6					)
         __A			  =							obj.config
         assert config["a"] == 2
         assert config["b"] == 5
         assert config["c"] == 6
         assert config["d"] == "for diffusion"
         assert config["e"] == [1, 3]

         # can use positional arguments.
         __A			  =							SampleObject(1       ,  c=6					)
         __A			  =							obj.config
         assert config["a"] == 1
         assert config["b"] == 5
         assert config["c"] == 6
         assert config["d"] == "for diffusion"
         assert config["e"] == [1, 3]




   def _lowerCAmelCase (self      :Optional[Any]					)->   Union[str, Any]:
         __A			  =							SampleObject()
         __A			  =							obj.config

         assert config["a"] == 2
         assert config["b"] == 5
         assert config["c"] == (2, 5)
         assert config["d"] == "for diffusion"
         assert config["e"] == [1, 3]

         with tempfile.TemporaryDirectory() as tmpdirname:
               obj.save_config(_UpperCamelCase					)
               __A			  =							SampleObject.from_config(SampleObject.load_config(_UpperCamelCase					)					)
               __A			  =							new_obj.config

         # unfreeze configs
         __A			  =							dict(_UpperCamelCase					)
         __A			  =							dict(_UpperCamelCase					)

         assert config.pop('''c'''					) == (2, 5)  # instantiated as tuple
         assert new_config.pop('''c'''					) == [2, 5]  # saved & loaded as list because of json
         config.pop('''_use_default_values'''					)
         assert config == new_config




   def _lowerCAmelCase (self      :int					)->   List[Any]:
         __A			  =							logging.get_logger('''diffusers.configuration_utils'''					)
         # 30 for warning
         logger.setLevel(30					)

         with CaptureLogger(_UpperCamelCase					) as cap_logger:
               __A			  =							DDIMScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''       ,  subfolder='''scheduler'''					)

         assert ddim.__class__ == DDIMScheduler
         # no warning should be thrown
         assert cap_logger.out == ""




   def _lowerCAmelCase (self      :List[Any]					)->   Any:
         __A			  =							logging.get_logger('''diffusers.configuration_utils'''					)
         # 30 for warning
         logger.setLevel(30					)

         with CaptureLogger(_UpperCamelCase					) as cap_logger:
               __A			  =							EulerDiscreteScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''       ,  subfolder='''scheduler'''					)

         assert euler.__class__ == EulerDiscreteScheduler
         # no warning should be thrown
         assert cap_logger.out == ""




   def _lowerCAmelCase (self      :Dict					)->   Tuple:
         __A			  =							logging.get_logger('''diffusers.configuration_utils'''					)
         # 30 for warning
         logger.setLevel(30					)

         with CaptureLogger(_UpperCamelCase					) as cap_logger:
               __A			  =							EulerAncestralDiscreteScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''       ,  subfolder='''scheduler'''					)

         assert euler.__class__ == EulerAncestralDiscreteScheduler
         # no warning should be thrown
         assert cap_logger.out == ""




   def _lowerCAmelCase (self      :int					)->   List[Any]:
         __A			  =							logging.get_logger('''diffusers.configuration_utils'''					)
         # 30 for warning
         logger.setLevel(30					)

         with CaptureLogger(_UpperCamelCase					) as cap_logger:
               __A			  =							PNDMScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''       ,  subfolder='''scheduler'''					)

         assert pndm.__class__ == PNDMScheduler
         # no warning should be thrown
         assert cap_logger.out == ""




   def _lowerCAmelCase (self      :int					)->   Optional[int]:
         __A			  =							logging.get_logger('''diffusers.configuration_utils'''					)
         # 30 for warning
         logger.setLevel(30					)

         with CaptureLogger(_UpperCamelCase					) as cap_logger:
               __A			  =							DDPMScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''       ,  subfolder='''scheduler'''       ,  prediction_type='''sample'''       ,  beta_end=8       ,  )

         with CaptureLogger(_UpperCamelCase					) as cap_logger_a:
               __A			  =							DDPMScheduler.from_pretrained('''google/ddpm-celebahq-256'''       ,  beta_start=88					)

         assert ddpm.__class__ == DDPMScheduler
         assert ddpm.config.prediction_type == "sample"
         assert ddpm.config.beta_end == 8
         assert ddpm_a.config.beta_start == 88

         # no warning should be thrown
         assert cap_logger.out == ""
         assert cap_logger_a.out == ""




   def _lowerCAmelCase (self      :Union[str, Any]					)->   Any:
         __A			  =							logging.get_logger('''diffusers.configuration_utils'''					)
         # 30 for warning
         logger.setLevel(30					)

         with CaptureLogger(_UpperCamelCase					) as cap_logger:
               __A			  =							DPMSolverMultistepScheduler.from_pretrained(
                   '''hf-internal-testing/tiny-stable-diffusion-torch'''       ,  subfolder='''scheduler'''					)

         assert dpm.__class__ == DPMSolverMultistepScheduler
         # no warning should be thrown
         assert cap_logger.out == ""






   def _lowerCAmelCase (self      :Dict					)->   Tuple:
         # let's first save a config that should be in the form
         #    a=2,
         #    b=5,
         #    c=(2, 5),
         #    d="for diffusion",
         #    e=[1, 3],

         __A			  =							SampleObject()

         __A			  =							{k: v for k, v in config.config.items() if not k.startswith('''_'''					)}

         # make sure that default config has all keys in `_use_default_values`
         assert set(config_dict.keys()					) == set(config.config._use_default_values					)

         with tempfile.TemporaryDirectory() as tmpdirname:
               config.save_config(_UpperCamelCase					)

               # now loading it with SampleObject2 should put f into `_use_default_values`
               __A			  =							SampleObjecta.from_config(_UpperCamelCase					)

               assert "f" in config._use_default_values
               assert config.f == [1, 3]

         # now loading the config, should **NOT** use [1, 3] for `f`, but the default [1, 4] value
         # **BECAUSE** it is part of `config._use_default_values`
         __A			  =							SampleObjecta.from_config(config.config					)
         assert new_config.f == [5, 4]

         config.config._use_default_values.pop()
         __A			  =							SampleObjecta.from_config(config.config					)
         assert new_config_a.f == [1, 3]

         # Nevertheless "e" should still be correctly loaded to [1, 3] from SampleObject2 instead of defaulting to [1, 5]
         assert new_config_a.e == [1, 3]












import os



def _a							(      )      ->		int:







      '''simple docstring'''






      __A			  =							os.path.dirname(os.path.realpath(lowerCamelCase					)					)
      __A			  =							os.path.join(lowerCamelCase   ,							'''triangle.txt'''					)

      with open(lowerCamelCase					) as in_file:
            __A			  =							[[int(lowerCamelCase					) for i in line.split()] for line in in_file]

      while len(lowerCamelCase					) != 1:
            __A			  =							triangle.pop()
            __A			  =							triangle[-1]
            for j in range(len(lowerCamelCase					) - 1					):
                  curr_row[j] += max(last_row[j]   ,							last_row[j + 1]					)
      return triangle[0][0]


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





