




'''simple docstring'''



import sys

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







def       _UpperCamelCase			(_lowerCamelCase				:  str						)-> int:




     '''simple docstring'''





     __snake_case            =	1
     for digit in s:
          product *= int(_lowerCamelCase						)
     return product







def       _UpperCamelCase			(_lowerCamelCase				:  str = N						)-> int:




     '''simple docstring'''





     __snake_case            =	-sys.maxsize - 1
     __snake_case            =	n[:13]
     __snake_case            =	13
     while cur_index < len(_lowerCamelCase						) - 13:
          if int(n[cur_index]						) >= int(substr[0]						):
               __snake_case            =	substr[1:] + n[cur_index]
               cur_index += 1
          else:
               __snake_case            =	max(_lowerCamelCase ,						str_eval(_lowerCamelCase						)						)
               __snake_case            =	n[cur_index : cur_index + 13]
               cur_index += 13
     return largest_product


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












'''simple docstring'''



import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
     import torch

if is_vision_available():
     from PIL import Image

     from transformers import MobileViTImageProcessor





class      lowerCAmelCase (			unittest.TestCase):


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=7     ,	__SCREAMING_SNAKE_CASE=3     ,	__SCREAMING_SNAKE_CASE=18     ,	__SCREAMING_SNAKE_CASE=30     ,	__SCREAMING_SNAKE_CASE=400     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=None     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=None     ,	__SCREAMING_SNAKE_CASE=True     ,	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	size if size is not None else {'''shortest_edge''': 20}
            __snake_case            =	crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
            __snake_case            =	parent
            __snake_case            =	batch_size
            __snake_case            =	num_channels
            __snake_case            =	image_size
            __snake_case            =	min_resolution
            __snake_case            =	max_resolution
            __snake_case            =	do_resize
            __snake_case            =	size
            __snake_case            =	do_center_crop
            __snake_case            =	crop_size
            __snake_case            =	do_flip_channel_order




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



            '''simple docstring'''




            return {
                "do_resize": self.do_resize,
                "size": self.size,
                "do_center_crop": self.do_center_crop,
                "crop_size": self.crop_size,
                "do_flip_channel_order": self.do_flip_channel_order,
            }





@require_torch
@require_vision
class      lowerCAmelCase (			__lowerCAmelCase					, unittest.TestCase):
       __lowercase	:   Union[str, Any]										=      MobileViTImageProcessor if is_vision_available() else None


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	MobileViTImageProcessingTester(self	)


       @property
       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            return self.image_processor_tester.prepare_image_processor_dict()


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



            '''simple docstring'''




            __snake_case            =	self.image_processing_class(**self.image_processor_dict	)
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE     ,	'''do_resize'''	)	)
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE     ,	'''size'''	)	)
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE     ,	'''do_center_crop'''	)	)
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE     ,	'''center_crop'''	)	)
            self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE     ,	'''do_flip_channel_order'''	)	)


       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	self.image_processing_class.from_dict(self.image_processor_dict	)
            self.assertEqual(image_processor.size     ,	{'''shortest_edge''': 20}	)
            self.assertEqual(image_processor.crop_size     ,	{'''height''': 18, '''width''': 18}	)

            __snake_case            =	self.image_processing_class.from_dict(self.image_processor_dict     ,	size=42     ,	crop_size=84	)
            self.assertEqual(image_processor.size     ,	{'''shortest_edge''': 42}	)
            self.assertEqual(image_processor.crop_size     ,	{'''height''': 84, '''width''': 84}	)


       def    lowerCAmelCase   ( self	)   ->	Optional[Any]:



            '''simple docstring'''




            pass


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	self.image_processing_class(**self.image_processor_dict	)
            # create random PIL images
            __snake_case            =	prepare_image_inputs(self.image_processor_tester     ,	equal_resolution=__SCREAMING_SNAKE_CASE	)
            for image in image_inputs:
                 self.assertIsInstance(__SCREAMING_SNAKE_CASE     ,	Image.Image	)

            # Test not batched input
            __snake_case            =	image_processing(image_inputs[0]     ,	return_tensors='''pt'''	).pixel_values
            self.assertEqual(
                encoded_images.shape     ,	(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['''height'''],
                    self.image_processor_tester.crop_size['''width'''],
                )     ,	)

            # Test batched
            __snake_case            =	image_processing(__SCREAMING_SNAKE_CASE     ,	return_tensors='''pt'''	).pixel_values
            self.assertEqual(
                encoded_images.shape     ,	(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['''height'''],
                    self.image_processor_tester.crop_size['''width'''],
                )     ,	)


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	self.image_processing_class(**self.image_processor_dict	)
            # create random numpy tensors
            __snake_case            =	prepare_image_inputs(self.image_processor_tester     ,	equal_resolution=__SCREAMING_SNAKE_CASE     ,	numpify=__SCREAMING_SNAKE_CASE	)
            for image in image_inputs:
                 self.assertIsInstance(__SCREAMING_SNAKE_CASE     ,	np.ndarray	)

            # Test not batched input
            __snake_case            =	image_processing(image_inputs[0]     ,	return_tensors='''pt'''	).pixel_values
            self.assertEqual(
                encoded_images.shape     ,	(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['''height'''],
                    self.image_processor_tester.crop_size['''width'''],
                )     ,	)

            # Test batched
            __snake_case            =	image_processing(__SCREAMING_SNAKE_CASE     ,	return_tensors='''pt'''	).pixel_values
            self.assertEqual(
                encoded_images.shape     ,	(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['''height'''],
                    self.image_processor_tester.crop_size['''width'''],
                )     ,	)




       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	self.image_processing_class(**self.image_processor_dict	)
            # create random PyTorch tensors
            __snake_case            =	prepare_image_inputs(self.image_processor_tester     ,	equal_resolution=__SCREAMING_SNAKE_CASE     ,	torchify=__SCREAMING_SNAKE_CASE	)
            for image in image_inputs:
                 self.assertIsInstance(__SCREAMING_SNAKE_CASE     ,	torch.Tensor	)

            # Test not batched input
            __snake_case            =	image_processing(image_inputs[0]     ,	return_tensors='''pt'''	).pixel_values
            self.assertEqual(
                encoded_images.shape     ,	(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['''height'''],
                    self.image_processor_tester.crop_size['''width'''],
                )     ,	)

            # Test batched
            __snake_case            =	image_processing(__SCREAMING_SNAKE_CASE     ,	return_tensors='''pt'''	).pixel_values
            self.assertEqual(
                encoded_images.shape     ,	(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['''height'''],
                    self.image_processor_tester.crop_size['''width'''],
                )     ,	)






