
import sys

lowercase__		:Union[str, Any]   =    (
    "73167176531330624919225119674426574742355349194934"
    "96983520312774506326239578318016984801869478851843"
    "85861560789112949495459501737958331952853208805511"
    "12540698747158523863050715693290963295227443043557"
    "66896648950445244523161731856403098711121722383113"
    "62229893423380308135336276614282806444486645238749"
    "30358907296290491560440772390713810515859307960866"
    "70172427121883998797908792274921901699720888093776"
    "65727333001053367881220235421809751254540594752243"
    "52584907711670556013604839586446706324415722155397"
    "53697817977846174064955149290862569321978468622482"
    "83972241375657056057490261407972968652414535100474"
    "82166370484403199890008895243450658541227588666881"
    "16427171479924442928230863465674813919123162824586"
    "17866458359124566529476545682848912883142607690042"
    "24219022671055626321111109370544217506941658960408"
    "07198403850962455444362981230987879927244284909188"
    "84580156166097919133875499200524063689912560717606"
    "05886116467109405077541002256983155200055935729725"
    "71636269561882670428252483600823257530420752963450"
)



def        UpperCamelCase    (							lowerCAmelCase__ = N		):
					'''simple docstring'''
					lowercase							=						-sys.maxsize - 1
					for i in range(len(lowerCAmelCase__		) - 12		):
										lowercase							=						1
										for j in range(13		):
															product *= int(n[i + j]		)
										if product > largest_product:
															lowercase							=						product
					return largest_product


if __name__ == "__main__":
							print(F'{solution() = }')






import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







class 				lowercase		(					SCREAMING_SNAKE_CASE__       ,  unittest.TestCase		):
							lowercase_       :       Any       					=KandinskyVaaPriorPipeline
							lowercase_       :       str       					=['''prompt''']
							lowercase_       :       Union[str, Any]       					=['''prompt''', '''negative_prompt''']
							lowercase_       :       Dict       					=[
							    '''num_images_per_prompt''',
							    '''generator''',
							    '''num_inference_steps''',
							    '''latents''',
							    '''negative_prompt''',
							    '''guidance_scale''',
							    '''output_type''',
							    '''return_dict''',
							]
							lowercase_       :       List[str]       					=False




							@property
							def  A__      (				self):
												return 3_2




							@property
							def  A__      (				self):
												return 3_2




							@property
							def  A__      (				self):
												return self.time_input_dim




							@property
							def  A__      (				self):
												return self.time_input_dim * 4




							@property
							def  A__      (				self):
												return 1_0_0




							@property
							def  A__      (				self):
												lowercase							=						CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')
												return tokenizer




							@property
							def  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						CLIPTextConfig(
												    bos_token_id=0   ,eos_token_id=2   ,hidden_size=self.text_embedder_hidden_size   ,projection_dim=self.text_embedder_hidden_size   ,intermediate_size=3_7   ,layer_norm_eps=1E-05   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=1_0_0_0   ,)
												return CLIPTextModelWithProjection(A__)




							@property
							def  A__      (				self):
												torch.manual_seed(0)

												lowercase							=						{
												    '''num_attention_heads''': 2,
												    '''attention_head_dim''': 1_2,
												    '''embedding_dim''': self.text_embedder_hidden_size,
												    '''num_layers''': 1,
												}

												lowercase							=						PriorTransformer(**A__)
												# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
												lowercase							=						nn.Parameter(torch.ones(model.clip_std.shape))
												return model




							@property
							def  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						CLIPVisionConfig(
												    hidden_size=self.text_embedder_hidden_size   ,image_size=2_2_4   ,projection_dim=self.text_embedder_hidden_size   ,intermediate_size=3_7   ,num_attention_heads=4   ,num_channels=3   ,num_hidden_layers=5   ,patch_size=1_4   ,)

												lowercase							=						CLIPVisionModelWithProjection(A__)
												return model




							@property
							def  A__      (				self):
												lowercase							=						CLIPImageProcessor(
												    crop_size=2_2_4   ,do_center_crop=A__   ,do_normalize=A__   ,do_resize=A__   ,image_mean=[0.48145466, 0.4578275, 0.40821073]   ,image_std=[0.26862954, 0.26130258, 0.27577711]   ,resample=3   ,size=2_2_4   ,)

												return image_processor




							def  A__      (				self):
												lowercase							=						self.dummy_prior
												lowercase							=						self.dummy_image_encoder
												lowercase							=						self.dummy_text_encoder
												lowercase							=						self.dummy_tokenizer
												lowercase							=						self.dummy_image_processor

												lowercase							=						UnCLIPScheduler(
												    variance_type='''fixed_small_log'''   ,prediction_type='''sample'''   ,num_train_timesteps=1_0_0_0   ,clip_sample=A__   ,clip_sample_range=10.0   ,)

												lowercase							=						{
												    '''prior''': prior,
												    '''image_encoder''': image_encoder,
												    '''text_encoder''': text_encoder,
												    '''tokenizer''': tokenizer,
												    '''scheduler''': scheduler,
												    '''image_processor''': image_processor,
												}

												return components




							def  A__      (				self   ,A__   ,A__=0):
												if str(A__).startswith('''mps'''):
																	lowercase							=						torch.manual_seed(A__)
												else:
																	lowercase							=						torch.Generator(device=A__).manual_seed(A__)
												lowercase							=						{
												    '''prompt''': '''horse''',
												    '''generator''': generator,
												    '''guidance_scale''': 4.0,
												    '''num_inference_steps''': 2,
												    '''output_type''': '''np''',
												}
												return inputs




							def  A__      (				self):
												lowercase							=						'''cpu'''

												lowercase							=						self.get_dummy_components()

												lowercase							=						self.pipeline_class(**A__)
												lowercase							=						pipe.to(A__)

												pipe.set_progress_bar_config(disable=A__)

												lowercase							=						pipe(**self.get_dummy_inputs(A__))
												lowercase							=						output.image_embeds

												lowercase							=						pipe(
												    **self.get_dummy_inputs(A__)   ,return_dict=A__   ,)[0]

												lowercase							=						image[0, -1_0:]
												lowercase							=						image_from_tuple[0, -1_0:]

												assert image.shape == (1, 3_2)

												lowercase							=						np.array(
												    [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156])

												assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
												assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2




							@skip_mps
							def  A__      (				self):
												lowercase							=						torch_device == '''cpu'''
												lowercase							=						True
												lowercase							=						False

												self._test_inference_batch_single_identical(
												    test_max_difference=A__   ,relax_max_difference=A__   ,test_mean_pixel_difference=A__   ,)





							@skip_mps
							def  A__      (				self):
												lowercase							=						torch_device == '''cpu'''
												lowercase							=						False

												self._test_attention_slicing_forward_pass(
												    test_max_difference=A__   ,test_mean_pixel_difference=A__   ,)




