

"""simple docstring"""




import sys

A_							:			Tuple											= (
    "73167176531330624919225119674426574742355349194934"
    "96983520312774506326239578318016984801869478851843"
    "85861560789112949495459501737958331952853208805511"
    "12540698747158523863050715693290963295227443043557"
    "66896648950445244523161731856403098711121722383113"
    "62229893423380308135336276614282806444486645238749"
    "30358907296290491560440772390713810515859307960866"
    "70172427121883998797908792274921901699720888093776"
    "65727333001053367881220235421809751254540594752243"
    "52584907711670556013604839586446706324415722155397"
    "53697817977846174064955149290862569321978468622482"
    "83972241375657056057490261407972968652414535100474"
    "82166370484403199890008895243450658541227588666881"
    "16427171479924442928230863465674813919123162824586"
    "17866458359124566529476545682848912883142607690042"
    "24219022671055626321111109370544217506941658960408"
    "07198403850962455444362981230987879927244284909188"
    "84580156166097919133875499200524063689912560717606"
    "05886116467109405077541002256983155200055935729725"
    "71636269561882670428252483600823257530420752963450"
)

def 	A       (     snake_case__ = N    ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      -sys.maxsize - 1
			for i in range(len(snake_case__    ) - 12    ):
						SCREAMING_SNAKE_CASE__								=      1
						for j in range(13    ):
									product *= int(n[i + j]    )
						if product > largest_product:
									SCREAMING_SNAKE_CASE__								=      product
			return largest_product


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





"""simple docstring"""




import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation, MobileNetVaModel
						from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import MobileNetVaImageProcessor





class    lowerCamelCase						(A__			):

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[str]       )   ->    Any:
						SCREAMING_SNAKE_CASE__								=      self.config_class(**self.inputs_dict       )
						self.parent.assertTrue(hasattr(__UpperCAmelCase    ,				"""tf_padding"""       )       )
						self.parent.assertTrue(hasattr(__UpperCAmelCase    ,				"""depth_multiplier"""       )       )





class    lowerCamelCase						:

			def __init__(					self				:						Any    ,				__UpperCAmelCase				:						Any    ,				__UpperCAmelCase				:						Any=1_3    ,				__UpperCAmelCase				:						Any=3    ,				__UpperCAmelCase				:						int=3_2    ,				__UpperCAmelCase				:						Tuple=0.25    ,				__UpperCAmelCase				:						Optional[int]=8    ,				__UpperCAmelCase				:						Any=8    ,				__UpperCAmelCase				:						str=6    ,				__UpperCAmelCase				:						Optional[int]=3_2    ,				__UpperCAmelCase				:						str=True    ,				__UpperCAmelCase				:						List[str]=True    ,				__UpperCAmelCase				:						Tuple=True    ,				__UpperCAmelCase				:						Any="relu6"    ,				__UpperCAmelCase				:						str=1_2_8_0    ,				__UpperCAmelCase				:						List[str]=0.1    ,				__UpperCAmelCase				:						Any=0.02    ,				__UpperCAmelCase				:						Any=True    ,				__UpperCAmelCase				:						Optional[int]=True    ,				__UpperCAmelCase				:						Dict=1_0    ,				__UpperCAmelCase				:						Optional[int]=None    ,				)   ->    Optional[Any]:
						SCREAMING_SNAKE_CASE__								=      parent
						SCREAMING_SNAKE_CASE__								=      batch_size
						SCREAMING_SNAKE_CASE__								=      num_channels
						SCREAMING_SNAKE_CASE__								=      image_size
						SCREAMING_SNAKE_CASE__								=      depth_multiplier
						SCREAMING_SNAKE_CASE__								=      depth_divisible_by
						SCREAMING_SNAKE_CASE__								=      min_depth
						SCREAMING_SNAKE_CASE__								=      expand_ratio
						SCREAMING_SNAKE_CASE__								=      tf_padding
						SCREAMING_SNAKE_CASE__								=      output_stride
						SCREAMING_SNAKE_CASE__								=      first_layer_is_expansion
						SCREAMING_SNAKE_CASE__								=      finegrained_output
						SCREAMING_SNAKE_CASE__								=      hidden_act
						SCREAMING_SNAKE_CASE__								=      last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier       )
						SCREAMING_SNAKE_CASE__								=      classifier_dropout_prob
						SCREAMING_SNAKE_CASE__								=      use_labels
						SCREAMING_SNAKE_CASE__								=      is_training
						SCREAMING_SNAKE_CASE__								=      num_labels
						SCREAMING_SNAKE_CASE__								=      initializer_range
						SCREAMING_SNAKE_CASE__								=      scope

			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

						SCREAMING_SNAKE_CASE__								=      None
						SCREAMING_SNAKE_CASE__								=      None
						if self.use_labels:
									SCREAMING_SNAKE_CASE__								=      ids_tensor([self.batch_size]    ,				self.num_labels       )
									SCREAMING_SNAKE_CASE__								=      ids_tensor([self.batch_size, self.image_size, self.image_size]    ,				self.num_labels       )

						SCREAMING_SNAKE_CASE__								=      self.get_config()

						return config, pixel_values, labels, pixel_labels

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    List[str]:
						return MobileNetVaConfig(
						    num_channels=self.num_channels    ,				image_size=self.image_size    ,				depth_multiplier=self.depth_multiplier    ,				depth_divisible_by=self.depth_divisible_by    ,				min_depth=self.min_depth    ,				expand_ratio=self.expand_ratio    ,				output_stride=self.output_stride    ,				first_layer_is_expansion=self.first_layer_is_expansion    ,				finegrained_output=self.finegrained_output    ,				hidden_act=self.hidden_act    ,				tf_padding=self.tf_padding    ,				classifier_dropout_prob=self.classifier_dropout_prob    ,				initializer_range=self.initializer_range    ,				)

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						List[Any]    ,				__UpperCAmelCase				:						Any    ,				__UpperCAmelCase				:						Tuple    ,				__UpperCAmelCase				:						Any       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaModel(config=__UpperCAmelCase       )
						model.to(__UpperCAmelCase       )
						model.eval()
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase       )
						self.parent.assertEqual(
						    result.last_hidden_state.shape    ,				(
						        self.batch_size,
						        self.last_hidden_size,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )    ,				)
						self.parent.assertEqual(
						    result.pooler_output.shape    ,				(self.batch_size, self.last_hidden_size)    ,				)

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]    ,				__UpperCAmelCase				:						Union[str, Any]    ,				__UpperCAmelCase				:						Union[str, Any]    ,				__UpperCAmelCase				:						Union[str, Any]    ,				__UpperCAmelCase				:						str       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      self.num_labels
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForImageClassification(__UpperCAmelCase       )
						model.to(__UpperCAmelCase       )
						model.eval()
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase    ,				labels=__UpperCAmelCase       )
						self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_labels)       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple    ,				__UpperCAmelCase				:						str    ,				__UpperCAmelCase				:						Optional[Any]    ,				__UpperCAmelCase				:						int    ,				__UpperCAmelCase				:						Optional[int]       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      self.num_labels
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForSemanticSegmentation(__UpperCAmelCase       )
						model.to(__UpperCAmelCase       )
						model.eval()
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase       )
						self.parent.assertEqual(
						    result.logits.shape    ,				(
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )    ,				)
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase    ,				labels=__UpperCAmelCase       )
						self.parent.assertEqual(
						    result.logits.shape    ,				(
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )    ,				)





			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      self.prepare_config_and_inputs()
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      config_and_inputs
						SCREAMING_SNAKE_CASE__								=      {"""pixel_values""": pixel_values}
						return config, inputs_dict





@require_torch
class    lowerCamelCase						(A__			,A__			,unittest.TestCase			):
			lowerCamelCase__   :		str							=							(
			    (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation)
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase__   :		str							=							(
			    {
			        'feature-extraction': MobileNetVaModel,
			        'image-classification': MobileNetVaForImageClassification,
			        'image-segmentation': MobileNetVaForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			lowerCamelCase__   :		Optional[int]							=							False
			lowerCamelCase__   :		Dict							=							False
			lowerCamelCase__   :		List[Any]							=							False
			lowerCamelCase__   :		Union[str, Any]							=							False

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    List[str]:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaModelTester(self       )
						SCREAMING_SNAKE_CASE__								=      MobileNetVaConfigTester(self    ,				config_class=__UpperCAmelCase    ,				has_text_modality=__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    int:
						self.config_tester.run_common_tests()

			@unittest.skip(reason="""MobileNetV2 does not use inputs_embeds"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Union[str, Any]:
						pass

			@unittest.skip(reason="""MobileNetV2 does not support input and output embeddings"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    List[str]:
						pass

			@unittest.skip(reason="""MobileNetV2 does not output attentions"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Optional[int]:
						pass

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[str]       )   ->    str:
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )
									SCREAMING_SNAKE_CASE__								=      inspect.signature(model.forward       )
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									SCREAMING_SNAKE_CASE__								=      [*signature.parameters.keys()]

									SCREAMING_SNAKE_CASE__								=      ["""pixel_values"""]
									self.assertListEqual(arg_names[:1]    ,				__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    Union[str, Any]:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]       )   ->    List[str]:
						def check_hidden_states_output(__UpperCAmelCase				:						Tuple    ,				__UpperCAmelCase				:						Optional[int]    ,				__UpperCAmelCase				:						Optional[int]       ):
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )
									model.to(__UpperCAmelCase       )
									model.eval()

									with torch.no_grad():
												SCREAMING_SNAKE_CASE__								=      model(**self._prepare_for_class(__UpperCAmelCase    ,				__UpperCAmelCase       )       )

									SCREAMING_SNAKE_CASE__								=      outputs.hidden_states

									SCREAMING_SNAKE_CASE__								=      1_6
									self.assertEqual(len(__UpperCAmelCase       )    ,				__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE__								=      True
									check_hidden_states_output(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase       )

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									SCREAMING_SNAKE_CASE__								=      True

									check_hidden_states_output(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple       )   ->    Optional[int]:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCAmelCase       )





			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]       )   ->    Dict:
						for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE__								=      MobileNetVaModel.from_pretrained(__UpperCAmelCase       )
									self.assertIsNotNone(__UpperCAmelCase       )

def 	A       (     ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
			return image





@require_torch
@require_vision
class    lowerCamelCase						(unittest.TestCase			):

			@cached_property
			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    str:
						return (
						    MobileNetVaImageProcessor.from_pretrained("""google/mobilenet_v2_1.0_224"""       ) if is_vision_available() else None
						)

			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForImageClassification.from_pretrained("""google/mobilenet_v2_1.0_224"""       ).to(__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      self.default_image_processor
						SCREAMING_SNAKE_CASE__								=      prepare_img()
						SCREAMING_SNAKE_CASE__								=      image_processor(images=__UpperCAmelCase    ,				return_tensors="""pt"""       ).to(__UpperCAmelCase       )

						# forward pass
						with torch.no_grad():
									SCREAMING_SNAKE_CASE__								=      model(**__UpperCAmelCase       )

						# verify the logits
						SCREAMING_SNAKE_CASE__								=      torch.Size((1, 1_0_0_1)       )
						self.assertEqual(outputs.logits.shape    ,				__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      torch.tensor([0.2_445, -1.1_993, 0.1_905]       ).to(__UpperCAmelCase       )

						self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,				__UpperCAmelCase    ,				atol=1e-4       )       )





			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      MobileNetVaForSemanticSegmentation.from_pretrained("""google/deeplabv3_mobilenet_v2_1.0_513"""       )
						SCREAMING_SNAKE_CASE__								=      model.to(__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      MobileNetVaImageProcessor.from_pretrained("""google/deeplabv3_mobilenet_v2_1.0_513"""       )

						SCREAMING_SNAKE_CASE__								=      prepare_img()
						SCREAMING_SNAKE_CASE__								=      image_processor(images=__UpperCAmelCase    ,				return_tensors="""pt"""       ).to(__UpperCAmelCase       )

						# forward pass
						with torch.no_grad():
									SCREAMING_SNAKE_CASE__								=      model(**__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      outputs.logits

						# verify the logits
						SCREAMING_SNAKE_CASE__								=      torch.Size((1, 2_1, 6_5, 6_5)       )
						self.assertEqual(logits.shape    ,				__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      torch.tensor(
						    [
						        [[17.5_790, 17.7_581, 18.3_355], [18.3_257, 18.4_230, 18.8_973], [18.6_169, 18.8_650, 19.2_187]],
						        [[-2.1_595, -2.0_977, -2.3_741], [-2.4_226, -2.3_028, -2.6_835], [-2.7_819, -2.5_991, -2.7_706]],
						        [[4.2_058, 4.8_317, 4.7_638], [4.4_136, 5.0_361, 4.9_383], [4.5_028, 4.9_644, 4.8_734]],
						    ]    ,				device=__UpperCAmelCase    ,				)

						self.assertTrue(torch.allclose(logits[0, :3, :3, :3]    ,				__UpperCAmelCase    ,				atol=1e-4       )       )


