




"""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  snake_case     (							TensorFormatter[Mapping, '''jax.Array''', Mapping]   ):

							def __init__(self       ,       SCREAMING_SNAKE_CASE_=None       ,       SCREAMING_SNAKE_CASE_=None       ,       **SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									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`.'''    )
									SCREAMING_SNAKE_CASE_						 = 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:
											SCREAMING_SNAKE_CASE_						 = 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]    )}.'    )
											SCREAMING_SNAKE_CASE_						 = str(jax.devices()[0]    )
									SCREAMING_SNAKE_CASE_						 = jnp_array_kwargs

							@staticmethod
							def _lowercase					():

									"""simple docstring"""







									import jax

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

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									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 _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									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()

									SCREAMING_SNAKE_CASE_						 = {}

									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:
													SCREAMING_SNAKE_CASE_						 = {'''dtype''': jnp.intaa}
											else:
													SCREAMING_SNAKE_CASE_						 = {'''dtype''': jnp.intaa}
									elif isinstance(__SCREAMING_SNAKE_CASE       ,       (np.number, np.ndarray)    ) and np.issubdtype(value.dtype       ,       np.floating    ):
											SCREAMING_SNAKE_CASE_						 = {'''dtype''': jnp.floataa}
									elif config.PIL_AVAILABLE and "PIL" in sys.modules:
											import PIL.Image

											if isinstance(__SCREAMING_SNAKE_CASE       ,       PIL.Image.Image    ):
													SCREAMING_SNAKE_CASE_						 = 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:
											SCREAMING_SNAKE_CASE_						 = 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 _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									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    ):
											SCREAMING_SNAKE_CASE_						 = 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 _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									return map_nested(self._recursive_tensorize       ,       __SCREAMING_SNAKE_CASE       ,       map_list=__SCREAMING_SNAKE_CASE    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.numpy_arrow_extractor().extract_row(__SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE_						 = self.python_features_decoder.decode_row(__SCREAMING_SNAKE_CASE    )
									return self.recursive_tensorize(__SCREAMING_SNAKE_CASE    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.numpy_arrow_extractor().extract_column(__SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE_						 = self.python_features_decoder.decode_column(__SCREAMING_SNAKE_CASE       ,       pa_table.column_names[0]    )
									SCREAMING_SNAKE_CASE_						 = self.recursive_tensorize(__SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE_						 = self._consolidate(__SCREAMING_SNAKE_CASE    )
									return column







							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.numpy_arrow_extractor().extract_batch(__SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE_						 = self.python_features_decoder.decode_batch(__SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE_						 = self.recursive_tensorize(__SCREAMING_SNAKE_CASE    )
									for column_name in batch:
											SCREAMING_SNAKE_CASE_						 = self._consolidate(batch[column_name]    )
									return batch

"""simple docstring"""




from __future__ import annotations

import typing
from collections import Counter



def        _lowerCamelCase ( __a    ):
		SCREAMING_SNAKE_CASE_						 = Counter()
		for base in range(1,							max_perimeter + 1    ):
				for perpendicular in range(__a,							max_perimeter + 1    ):
						SCREAMING_SNAKE_CASE_						 = (base * base + perpendicular * perpendicular) ** 0.5
						if hypotenuse == int(__a    ):
								SCREAMING_SNAKE_CASE_						 = int(base + perpendicular + hypotenuse    )
								if perimeter > max_perimeter:
										continue
								triplets[perimeter] += 1
		return triplets



def        _lowerCamelCase ( __a = 1_000    ):
		SCREAMING_SNAKE_CASE_						 = pythagorean_triple(__a    )
		return triplets.most_common(1    )[0][0]


if __name__ == "__main__":
						print(f'''Perimeter {solution()} has maximum solutions''')