




from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


SCREAMING_SNAKE_CASE:     str									= '''CompVis/stable-diffusion-v1-1'''
SCREAMING_SNAKE_CASE:     Union[str, Any]									= '''CompVis/stable-diffusion-v1-2'''
SCREAMING_SNAKE_CASE:     Dict									= '''CompVis/stable-diffusion-v1-3'''
SCREAMING_SNAKE_CASE:     Optional[Any]									= '''CompVis/stable-diffusion-v1-4'''



class    lowercase_		(SCREAMING_SNAKE_CASE__ ):



						def __init__(			self	:   Optional[int]					,							snake_case__	:   AutoencoderKL					,							snake_case__	:   CLIPTextModel					,							snake_case__	:   CLIPTokenizer					,							snake_case__	:   UNetaDConditionModel					,							snake_case__	:   Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]					,							snake_case__	:   StableDiffusionSafetyChecker					,							snake_case__	:   CLIPImageProcessor					,							snake_case__	:   bool = True					,							):

								"""simple docstring"""

								super()._init_()

								SCREAMING_SNAKE_CASE_					      =							StableDiffusionPipeline.from_pretrained(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							StableDiffusionPipeline.from_pretrained(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							StableDiffusionPipeline.from_pretrained(snake_case__  )
								SCREAMING_SNAKE_CASE_					      =							StableDiffusionPipeline(
								    vae=snake_case__					,							text_encoder=snake_case__					,							tokenizer=snake_case__					,							unet=snake_case__					,							scheduler=snake_case__					,							safety_checker=snake_case__					,							feature_extractor=snake_case__					,							requires_safety_checker=snake_case__					,							)

								self.register_modules(pipelinea=self.pipea					,							pipelinea=self.pipea					,							pipelinea=self.pipea					,							pipelinea=self.pipea  )



						@property
						def 	__a					(			self	:   Tuple  ):

								"""simple docstring"""

								return {k: getattr(self					,							snake_case__  ) for k in self.config.keys() if not k.startswith('_'  )}



						def 	__a					(			self	:   str					,							snake_case__	:   Optional[Union[str, int]] = "auto"  ):

								"""simple docstring"""

								if slice_size == "auto":
										# half the attention head size is usually a good trade-off between
										# speed and memory
										SCREAMING_SNAKE_CASE_					      =							self.unet.config.attention_head_dim // 2
								self.unet.set_attention_slice(snake_case__  )



						def 	__a					(			self	:   Dict  ):

								"""simple docstring"""

								self.enable_attention_slicing(snake_case__  )



						@torch.no_grad()
						def 	__a					(			self	:   int					,							snake_case__	:   Union[str, List[str]]					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 50					,							snake_case__	:   float = 7.5					,							snake_case__	:   Optional[Union[str, List[str]]] = None					,							snake_case__	:   Optional[int] = 1					,							snake_case__	:   float = 0.0					,							snake_case__	:   Optional[torch.Generator] = None					,							snake_case__	:   Optional[torch.FloatTensor] = None					,							snake_case__	:   Optional[str] = "pil"					,							snake_case__	:   bool = True					,							snake_case__	:   Optional[Callable[[int, int, torch.FloatTensor], None]] = None					,							snake_case__	:   int = 1					,							**snake_case__	:   Any					,							):

								"""simple docstring"""

								return self.pipea(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)



						@torch.no_grad()
						def 	__a					(			self	:   List[Any]					,							snake_case__	:   Union[str, List[str]]					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 50					,							snake_case__	:   float = 7.5					,							snake_case__	:   Optional[Union[str, List[str]]] = None					,							snake_case__	:   Optional[int] = 1					,							snake_case__	:   float = 0.0					,							snake_case__	:   Optional[torch.Generator] = None					,							snake_case__	:   Optional[torch.FloatTensor] = None					,							snake_case__	:   Optional[str] = "pil"					,							snake_case__	:   bool = True					,							snake_case__	:   Optional[Callable[[int, int, torch.FloatTensor], None]] = None					,							snake_case__	:   int = 1					,							**snake_case__	:   Optional[Any]					,							):

								"""simple docstring"""

								return self.pipea(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)



						@torch.no_grad()
						def 	__a					(			self	:   List[str]					,							snake_case__	:   Union[str, List[str]]					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 50					,							snake_case__	:   float = 7.5					,							snake_case__	:   Optional[Union[str, List[str]]] = None					,							snake_case__	:   Optional[int] = 1					,							snake_case__	:   float = 0.0					,							snake_case__	:   Optional[torch.Generator] = None					,							snake_case__	:   Optional[torch.FloatTensor] = None					,							snake_case__	:   Optional[str] = "pil"					,							snake_case__	:   bool = True					,							snake_case__	:   Optional[Callable[[int, int, torch.FloatTensor], None]] = None					,							snake_case__	:   int = 1					,							**snake_case__	:   str					,							):

								"""simple docstring"""

								return self.pipea(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)



						@torch.no_grad()
						def 	__a					(			self	:   str					,							snake_case__	:   Union[str, List[str]]					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 50					,							snake_case__	:   float = 7.5					,							snake_case__	:   Optional[Union[str, List[str]]] = None					,							snake_case__	:   Optional[int] = 1					,							snake_case__	:   float = 0.0					,							snake_case__	:   Optional[torch.Generator] = None					,							snake_case__	:   Optional[torch.FloatTensor] = None					,							snake_case__	:   Optional[str] = "pil"					,							snake_case__	:   bool = True					,							snake_case__	:   Optional[Callable[[int, int, torch.FloatTensor], None]] = None					,							snake_case__	:   int = 1					,							**snake_case__	:   List[str]					,							):

								"""simple docstring"""

								return self.pipea(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)






						@torch.no_grad()
						def 	__a					(			self	:   Tuple					,							snake_case__	:   Union[str, List[str]]					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 5_12					,							snake_case__	:   int = 50					,							snake_case__	:   float = 7.5					,							snake_case__	:   Optional[Union[str, List[str]]] = None					,							snake_case__	:   Optional[int] = 1					,							snake_case__	:   float = 0.0					,							snake_case__	:   Optional[torch.Generator] = None					,							snake_case__	:   Optional[torch.FloatTensor] = None					,							snake_case__	:   Optional[str] = "pil"					,							snake_case__	:   bool = True					,							snake_case__	:   Optional[Callable[[int, int, torch.FloatTensor], None]] = None					,							snake_case__	:   int = 1					,							**snake_case__	:   str					,							):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							'cuda' if torch.cuda.is_available() else 'cpu'
								self.to(snake_case__  )

								# Checks if the height and width are divisible by 8 or not
								if height % 8 != 0 or width % 8 != 0:
										raise ValueError(f'''`height` and `width` must be divisible by 8 but are {height} and {width}.'''  )

								# Get first result from Stable Diffusion Checkpoint v1.1
								SCREAMING_SNAKE_CASE_					      =							self.textaimg_sda_a(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)

								# Get first result from Stable Diffusion Checkpoint v1.2
								SCREAMING_SNAKE_CASE_					      =							self.textaimg_sda_a(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)

								# Get first result from Stable Diffusion Checkpoint v1.3
								SCREAMING_SNAKE_CASE_					      =							self.textaimg_sda_a(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)

								# Get first result from Stable Diffusion Checkpoint v1.4
								SCREAMING_SNAKE_CASE_					      =							self.textaimg_sda_a(
								    prompt=snake_case__					,							height=snake_case__					,							width=snake_case__					,							num_inference_steps=snake_case__					,							guidance_scale=snake_case__					,							negative_prompt=snake_case__					,							num_images_per_prompt=snake_case__					,							eta=snake_case__					,							generator=snake_case__					,							latents=snake_case__					,							output_type=snake_case__					,							return_dict=snake_case__					,							callback=snake_case__					,							callback_steps=snake_case__					,							**snake_case__					,							)

								# Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
								return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]  )





SCREAMING_SNAKE_CASE:     dict[tuple[int, int, int], int]									= {}


def 					_a							(					lowerCAmelCase    ,						lowerCAmelCase    ,						lowerCAmelCase )->	int:

		# if we are absent twice, or late 3 consecutive days,
		# no further prize strings are possible
		if late == 3 or absent == 2:
				return 0

		# if we have no days left, and have not failed any other rules,
		# we have a prize string
		if days == 0:
				return 1

		# No easy solution, so now we need to do the recursive calculation

		# First, check if the combination is already in the cache, and
		# if yes, return the stored value from there since we already
		# know the number of possible prize strings from this point on
		SCREAMING_SNAKE_CASE_					      =							(days, absent, late)
		if key in cache:
				return cache[key]

		# now we calculate the three possible ways that can unfold from
		# this point on, depending on our attendance today

		# 1) if we are late (but not absent), the "absent" counter stays as
		# it is, but the "late" counter increases by one
		SCREAMING_SNAKE_CASE_					      =							_calculate(days - 1    ,						lowerCAmelCase    ,						late + 1 )

		# 2) if we are absent, the "absent" counter increases by 1, and the
		# "late" counter resets to 0
		SCREAMING_SNAKE_CASE_					      =							_calculate(days - 1    ,						absent + 1    ,						0 )

		# 3) if we are on time, this resets the "late" counter and keeps the
		# absent counter
		SCREAMING_SNAKE_CASE_					      =							_calculate(days - 1    ,						lowerCAmelCase    ,						0 )

		SCREAMING_SNAKE_CASE_					      =							state_late + state_absent + state_ontime

		SCREAMING_SNAKE_CASE_					      =							prizestrings
		return prizestrings


def 					_a							(					lowerCAmelCase = 30 )->	int:
		return _calculate(lowerCAmelCase    ,						absent=0    ,						late=0 )


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