






'''simple docstring'''







# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.logging import get_logger
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
		import jax
		import jaxlib

__lowerCAmelCase       		=      get_logger()

__lowerCAmelCase       		=      None





class 	SCREAMING_SNAKE_CASE					(					TensorFormatter[Mapping, "jax.Array", Mapping]       ):






			def __init__( self      :			str  ,						__SCREAMING_SNAKE_CASE      :			Union[str, Any]=None  ,						__SCREAMING_SNAKE_CASE      :			Tuple=None  ,						**__SCREAMING_SNAKE_CASE      :			Optional[int]					)			->			Optional[int]:
							super().__init__(features=__SCREAMING_SNAKE_CASE					)
							import jax
							from jaxlib.xla_client import Device

							if isinstance(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					):
											raise ValueError(
											    f'Expected {device} to be a `str` not {type(__SCREAMING_SNAKE_CASE					)}, as `jaxlib.xla_extension.Device` '
											    '''is not serializable neither with `pickle` nor with `dill`. Instead you can surround '''
											    '''the device with `str()` to get its string identifier that will be internally mapped '''
											    '''to the actual `jaxlib.xla_extension.Device`.'''					)
							a_		:  Union[str, Any]											=      device if isinstance(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					) else str(jax.devices()[0]					)
							# using global variable since `jaxlib.xla_extension.Device` is not serializable neither
							# with `pickle` nor with `dill`, so we need to use a global variable instead
							global DEVICE_MAPPING
							if DEVICE_MAPPING is None:
											a_		:  Optional[int]											=      self._map_devices_to_str()
							if self.device not in list(DEVICE_MAPPING.keys()					):
											logger.warning(
											    f'Device with string identifier {self.device} not listed among the available '
											    f'devices: {list(DEVICE_MAPPING.keys()					)}, so falling back to the default '
											    f'device: {str(jax.devices()[0]					)}.'					)
											a_		:  Any											=      str(jax.devices()[0]					)
							a_		:  Tuple											=      jnp_array_kwargs






			@staticmethod
			def 			SCREAMING_SNAKE_CASE      ( )			->			Dict[str, "jaxlib.xla_extension.Device"]:
							import jax

							return {str(__SCREAMING_SNAKE_CASE					): device for device in jax.devices()}






			def 			SCREAMING_SNAKE_CASE      ( self      :			str  ,						__SCREAMING_SNAKE_CASE      :			Union[str, Any]					)			->			Dict:
							import jax
							import jax.numpy as jnp

							if isinstance(__SCREAMING_SNAKE_CASE  ,						__SCREAMING_SNAKE_CASE					) and column:
											if all(
											    isinstance(__SCREAMING_SNAKE_CASE  ,						jax.Array					) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column					):
															return jnp.stack(__SCREAMING_SNAKE_CASE  ,						axis=0					)
							return column






			def 			SCREAMING_SNAKE_CASE      ( self      :			List[str]  ,						__SCREAMING_SNAKE_CASE      :			int					)			->			Tuple:
							import jax
							import jax.numpy as jnp

							if isinstance(__SCREAMING_SNAKE_CASE  ,						(str, bytes, type(__SCREAMING_SNAKE_CASE					))					):
											return value
							elif isinstance(__SCREAMING_SNAKE_CASE  ,						(np.character, np.ndarray)					) and np.issubdtype(value.dtype  ,						np.character					):
											return value.tolist()

							a_		:  List[Any]											=      {}

							if isinstance(__SCREAMING_SNAKE_CASE  ,						(np.number, np.ndarray)					) and np.issubdtype(value.dtype  ,						np.integer					):
											# the default int precision depends on the jax config
											# see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
											if jax.config.jax_enable_xaa:
															a_		:  str											=      {'''dtype''': jnp.intaa}
											else:
															a_		:  Union[str, Any]											=      {'''dtype''': jnp.intaa}
							elif isinstance(__SCREAMING_SNAKE_CASE  ,						(np.number, np.ndarray)					) and np.issubdtype(value.dtype  ,						np.floating					):
											a_		:  Tuple											=      {'''dtype''': jnp.floataa}
							elif config.PIL_AVAILABLE and "PIL" in sys.modules:
											import PIL.Image

											if isinstance(__SCREAMING_SNAKE_CASE  ,						PIL.Image.Image					):
															a_		:  Union[str, Any]											=      np.asarray(__SCREAMING_SNAKE_CASE					)

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
							global DEVICE_MAPPING
							if DEVICE_MAPPING is None:
											a_		:  List[str]											=      self._map_devices_to_str()

							with jax.default_device(DEVICE_MAPPING[self.device]					):
											# calling jnp.array on a np.ndarray does copy the data
											# see https://github.com/google/jax/issues/4486
											return jnp.array(__SCREAMING_SNAKE_CASE  ,						**{**default_dtype, **self.jnp_array_kwargs}					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			List[Any]  ,						__SCREAMING_SNAKE_CASE      :			List[str]					)			->			Dict:
							import jax

							# support for torch, tf, jax etc.
							if config.TORCH_AVAILABLE and "torch" in sys.modules:
											import torch

											if isinstance(__SCREAMING_SNAKE_CASE  ,						torch.Tensor					):
															return self._tensorize(data_struct.detach().cpu().numpy()[()]					)
							if hasattr(__SCREAMING_SNAKE_CASE  ,						'''__array__'''					) and not isinstance(__SCREAMING_SNAKE_CASE  ,						jax.Array					):
											a_		:  str											=      data_struct.__array__()
							# support for nested types like struct of list of struct
							if isinstance(__SCREAMING_SNAKE_CASE  ,						np.ndarray					):
											if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
															return self._consolidate([self.recursive_tensorize(__SCREAMING_SNAKE_CASE					) for substruct in data_struct]					)
							elif isinstance(__SCREAMING_SNAKE_CASE  ,						(list, tuple)					):
											return self._consolidate([self.recursive_tensorize(__SCREAMING_SNAKE_CASE					) for substruct in data_struct]					)
							return self._tensorize(__SCREAMING_SNAKE_CASE					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Union[str, Any]  ,						__SCREAMING_SNAKE_CASE      :			dict					)			->			int:
							return map_nested(self._recursive_tensorize  ,						__SCREAMING_SNAKE_CASE  ,						map_list=__SCREAMING_SNAKE_CASE					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			int  ,						__SCREAMING_SNAKE_CASE      :			pa.Table					)			->			Mapping:
							a_		:  Dict											=      self.numpy_arrow_extractor().extract_row(__SCREAMING_SNAKE_CASE					)
							a_		:  str											=      self.python_features_decoder.decode_row(__SCREAMING_SNAKE_CASE					)
							return self.recursive_tensorize(__SCREAMING_SNAKE_CASE					)






			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]  ,						__SCREAMING_SNAKE_CASE      :			pa.Table					)			->			"jax.Array":
							a_		:  Optional[Any]											=      self.numpy_arrow_extractor().extract_column(__SCREAMING_SNAKE_CASE					)
							a_		:  Optional[int]											=      self.python_features_decoder.decode_column(__SCREAMING_SNAKE_CASE  ,						pa_table.column_names[0]					)
							a_		:  Any											=      self.recursive_tensorize(__SCREAMING_SNAKE_CASE					)
							a_		:  Optional[Any]											=      self._consolidate(__SCREAMING_SNAKE_CASE					)
							return column







			def 			SCREAMING_SNAKE_CASE      ( self      :			int  ,						__SCREAMING_SNAKE_CASE      :			pa.Table					)			->			Mapping:
							a_		:  Optional[Any]											=      self.numpy_arrow_extractor().extract_batch(__SCREAMING_SNAKE_CASE					)
							a_		:  Dict											=      self.python_features_decoder.decode_batch(__SCREAMING_SNAKE_CASE					)
							a_		:  str											=      self.recursive_tensorize(__SCREAMING_SNAKE_CASE					)
							for column_name in batch:
											a_		:  Optional[Any]											=      self._consolidate(batch[column_name]					)
							return batch












'''simple docstring'''







import sys

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





def 		_UpperCAmelCase   (							__A							:   str      ):
				a_		:  Tuple											=      1
				for digit in s:
								product *= int(__A      )
				return product





def 		_UpperCAmelCase   (							__A							:   str = N      ):
				a_		:  Dict											=      -sys.maxsize - 1
				a_		:  Optional[int]											=      n[:13]
				a_		:  str											=      13
				while cur_index < len(__A      ) - 13:
								if int(n[cur_index]      ) >= int(substr[0]      ):
												a_		:  Tuple											=      substr[1:] + n[cur_index]
												cur_index += 1
								else:
												a_		:  Dict											=      max(__A						,		str_eval(__A      )      )
												a_		:  List[str]											=      n[cur_index : cur_index + 13]
												cur_index += 13
				return largest_product


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




