


def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE = 100_0000      )->						Dict:




						"""simple docstring"""

						snake_case_ =   limit + 1
						snake_case_ =   [0] * limit
						for first_term in range(1      ,      _lowerCamelCase      ):
												for n in range(_lowerCamelCase      ,      _lowerCamelCase      ,      _lowerCamelCase      ):
																		snake_case_ =   first_term + n / first_term
																		if common_difference % 4:  # d must be divisble by 4
																								continue
																		else:
																								common_difference /= 4
																								if (
																								    first_term > common_difference
																								    and first_term < 4 * common_difference
																								):  # since x,y,z are positive integers
																														frequency[n] += 1  # so z>0 and a>d ,also 4d<a

						snake_case_ =   sum(1 for x in frequency[1:limit] if x == 10      )

						return count


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



# 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

UpperCAmelCase    =					get_logger()

UpperCAmelCase    =					None







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

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase=None	,   _UpperCAmelCase=None	,   **_UpperCAmelCase      ):
       super().__init__(features=_UpperCAmelCase      )
       import jax
       from jaxlib.xla_client import Device

       if isinstance(_UpperCAmelCase	,   _UpperCAmelCase      ):
             raise ValueError(
                 F'''Expected {device} to be a `str` not {type(_UpperCAmelCase      )}, 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`.'''      )
       snake_case_ =   device if isinstance(_UpperCAmelCase	,   _UpperCAmelCase      ) 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:
             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]      )}.'''      )
             snake_case_ =   str(jax.devices()[0]      )
       snake_case_ =   jnp_array_kwargs



 @staticmethod
 def 		UpperCamelCase__  (			):
       import jax

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



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       import jax
       import jax.numpy as jnp

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



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       import jax
       import jax.numpy as jnp

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

       snake_case_ =   {}

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

             if isinstance(_UpperCAmelCase	,   PIL.Image.Image      ):
                   snake_case_ =   np.asarray(_UpperCAmelCase      )

        # 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:
             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(_UpperCAmelCase	,   **{**default_dtype, **self.jnp_array_kwargs}      )



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       import jax

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

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



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       return map_nested(self._recursive_tensorize	,   _UpperCAmelCase	,   map_list=_UpperCAmelCase      )



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       snake_case_ =   self.numpy_arrow_extractor().extract_row(_UpperCAmelCase      )
       snake_case_ =   self.python_features_decoder.decode_row(_UpperCAmelCase      )
       return self.recursive_tensorize(_UpperCAmelCase      )



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       snake_case_ =   self.numpy_arrow_extractor().extract_column(_UpperCAmelCase      )
       snake_case_ =   self.python_features_decoder.decode_column(_UpperCAmelCase	,   pa_table.column_names[0]      )
       snake_case_ =   self.recursive_tensorize(_UpperCAmelCase      )
       snake_case_ =   self._consolidate(_UpperCAmelCase      )
       return column





 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       snake_case_ =   self.numpy_arrow_extractor().extract_batch(_UpperCAmelCase      )
       snake_case_ =   self.python_features_decoder.decode_batch(_UpperCAmelCase      )
       snake_case_ =   self.recursive_tensorize(_UpperCAmelCase      )
       for column_name in batch:
             snake_case_ =   self._consolidate(batch[column_name]      )
       return batch