


from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


_snake_case	:						List[str]         =							logging.get_logger(__name__)







def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							if isinstance(__lowerCamelCase				,      np.ndarray      ):
														return list(tensor.shape      )

							__snake_case						:     Optional[Any]									=  tf.shape(__lowerCamelCase      )

							if tensor.shape == tf.TensorShape(__lowerCamelCase      ):
														return dynamic

							__snake_case						:     Optional[int]									=  tensor.shape.as_list()

							return [dynamic[i] if s is None else s for i, s in enumerate(__lowerCamelCase      )]







def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase = None				,      __lowerCamelCase = None      ):
							return tf.nn.softmax(logits=logits + 1e-9				,      axis=__lowerCamelCase				,      name=__lowerCamelCase      )







def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase=1e-5				,      __lowerCamelCase=-1      ):
							# This is a very simplified functional layernorm, designed to duplicate
							# the functionality of PyTorch nn.functional.layer_norm when this is needed to port
							# models in Transformers.

							if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(__lowerCamelCase				,      __lowerCamelCase      ):
														raise NotImplementedError("Only 1D weight and bias tensors are supported for now, with only a single axis."      )

							# Get mean and variance on the axis to be normalized
							__snake_case					,     __snake_case						:     int									=  tf.nn.moments(__lowerCamelCase				,      axes=[axis]				,      keepdims=__lowerCamelCase      )

							if axis != -1:
														# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
														# on every dimension except axis
														__snake_case						:     Optional[int]									=  [1] * inputs.shape.rank
														__snake_case						:     Union[str, Any]									=  shape_list(__lowerCamelCase      )[axis]
														__snake_case						:     Any									=  tf.reshape(__lowerCamelCase				,      __lowerCamelCase      )
														__snake_case						:     Any									=  tf.reshape(__lowerCamelCase				,      __lowerCamelCase      )

							# Compute layer normalization using the batch_normalization
							# function.
							__snake_case						:     Dict									=  tf.nn.batch_normalization(
							    __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase				,      offset=__lowerCamelCase				,      scale=__lowerCamelCase				,      variance_epsilon=__lowerCamelCase				,      )
							return outputs







def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase=0				,      __lowerCamelCase=-1      ):
							# Replicates the behavior of torch.flatten in TF

							# If end_dim or start_dim is negative, count them from the end
							if end_dim < 0:
														end_dim += input.shape.rank
							if start_dim < 0:
														start_dim += input.shape.rank

							if start_dim == end_dim:
														return input

							__snake_case						:     Any									=  tf.shape(__lowerCamelCase      )
							__snake_case						:     Any									=  tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]      )
							__snake_case						:     Union[str, Any]									=  tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]				,      axis=0      )
							return tf.reshape(__lowerCamelCase				,      __lowerCamelCase      )







def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							if not isinstance(__lowerCamelCase				,      tf.Tensor      ):
														__snake_case						:     Dict									=  tf.convert_to_tensor(__lowerCamelCase      )  # Catches stray NumPy inputs
							if encoder_attention_mask.shape.rank == 3:
														__snake_case						:     List[str]									=  encoder_attention_mask[:, None, :, :]
							if encoder_attention_mask.shape.rank == 2:
														__snake_case						:     Any									=  encoder_attention_mask[:, None, None, :]
							# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
							# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
							# /transformer/transformer_layers.py#L270
							# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
							# encoder_extended_attention_mask.transpose(-1, -2))
							__snake_case						:     Dict									=  (
							    tf.cast(1				,      encoder_attention_mask.dtype      ) - encoder_extended_attention_mask
							) * encoder_extended_attention_mask.dtype.min

							return encoder_extended_attention_mask







def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase = "input_ids"      ):
							tf.debugging.assert_less(
							    __lowerCamelCase				,      tf.cast(__lowerCamelCase				,      dtype=tensor.dtype      )				,      message=(
							        F'The maximum value of {tensor_name} ({tf.math.reduce_max(__lowerCamelCase      )}) must be smaller than the embedding '
							        F'layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.'
							    )				,      )







def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     int									=  6_4_5_1_2
							# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
							# because in that case even chunking the array would not make the saving
							# possible.
							__snake_case						:     Dict									=  [x for x in data if len(__lowerCamelCase      ) > HDF5_OBJECT_HEADER_LIMIT]

							# Expecting this to never be true.
							if bad_attributes:
														raise RuntimeError(
														    "The following attributes cannot be saved to HDF5 file because "
														    F'they are larger than {HDF5_OBJECT_HEADER_LIMIT} '
														    F'bytes: {bad_attributes}'      )

							__snake_case						:     Optional[int]									=  np.asarray(__lowerCamelCase      )

							__snake_case						:     Any									=  1
							__snake_case						:     List[Any]									=  np.array_split(__lowerCamelCase				,      __lowerCamelCase      )

							# This will never loop forever thanks to the test above.
							while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data      ):
														num_chunks += 1
														__snake_case						:     str									=  np.array_split(__lowerCamelCase				,      __lowerCamelCase      )

							if num_chunks > 1:
														for chunk_id, chunk_data in enumerate(__lowerCamelCase      ):
																					__snake_case						:     Any									=  chunk_data
							else:
														__snake_case						:     Optional[Any]									=  data







def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							if name in group.attrs:
														__snake_case						:     Optional[int]									=  [n.decode("utf8"      ) if hasattr(__lowerCamelCase				,      "decode"      ) else n for n in group.attrs[name]]
							else:
														__snake_case						:     int									=  []
														__snake_case						:     Union[str, Any]									=  0
														while "%s%d" % (name, chunk_id) in group.attrs:
																					data.extend(
																					    [n.decode("utf8"      ) if hasattr(__lowerCamelCase				,      "decode"      ) else n for n in group.attrs["%s%d" % (name, chunk_id)]]      )
																					chunk_id += 1
							return data







def 							lowerCAmelCase_	(   __lowerCamelCase      ):

							def _expand_single_ad_tensor(__lowerCamelCase      ):
														if isinstance(__lowerCamelCase				,      tf.Tensor      ) and t.shape.rank == 1:
																					return tf.expand_dims(__lowerCamelCase				,      axis=-1      )
														return t

							return tf.nest.map_structure(_expand_single_ad_tensor				,      __lowerCamelCase      )





'''simple docstring'''



from collections import defaultdict
from math import gcd



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int = 1_50_00_00				)	->						int:
     __lowerCamelCase  :      defaultdict														=						defaultdict(UpperCAmelCase_				)
     __lowerCamelCase  :      Any														=						2
     while 2 * euclid_m * (euclid_m + 1) <= limit:
          for euclid_n in range((euclid_m % 2) + 1 ,       UpperCAmelCase_ ,       2				):
               if gcd(UpperCAmelCase_ ,       UpperCAmelCase_				) > 1:
                    continue
               __lowerCamelCase  :      Any														=						2 * euclid_m * (euclid_m + euclid_n)
               for perimeter in range(UpperCAmelCase_ ,       limit + 1 ,       UpperCAmelCase_				):
                    frequencies[perimeter] += 1
          euclid_m += 1
     return sum(1 for frequency in frequencies.values() if frequency == 1				)


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






