






"""simple docstring"""





import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase_						:					Optional[int]      				=			logging.get_logger(__name__)

UpperCamelCase_						:					str      				=			{
    """facebook/hubert-base-ls960""": """https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json""",
    # See all Hubert models at https://huggingface.co/models?filter=hubert
}


class   _lowercase			(  lowerCAmelCase    ):
      _a :  Any										= '''hubert'''


      def __init__(     self					:						List[Any]				, a					:						List[str]=3_2				, a					:						Tuple=7_6_8				, a					:						Dict=1_2				, a					:						str=1_2				, a					:						Optional[int]=3_0_7_2				, a					:						int="gelu"				, a					:						Optional[int]=0.1				, a					:						Union[str, Any]=0.1				, a					:						Dict=0.1				, a					:						Optional[Any]=True				, a					:						List[str]=0.0				, a					:						Union[str, Any]=0.1				, a					:						str=0.1				, a					:						Optional[int]=0.0_2				, a					:						Optional[Any]=1e-5				, a					:						List[str]="group"				, a					:						List[Any]="gelu"				, a					:						Any=(5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2, 5_1_2)				, a					:						Optional[int]=(5, 2, 2, 2, 2, 2, 2)				, a					:						Any=(1_0, 3, 3, 3, 3, 2, 2)				, a					:						Tuple=False				, a					:						List[Any]=1_2_8				, a					:						str=1_6				, a					:						int=False				, a					:						List[str]=True				, a					:						List[str]=0.0_5				, a					:						Optional[int]=1_0				, a					:						List[Any]=2				, a					:						Optional[int]=0.0				, a					:						str=1_0				, a					:						Dict=0				, a					:						Any="sum"				, a					:						Dict=False				, a					:						List[str]=False				, a					:						Union[str, Any]=2_5_6				, a					:						Optional[Any]=0				, a					:						Dict=1				, a					:						Tuple=2				, **a					:						int				, ):





            """simple docstring"""







            super().__init__(**a				, pad_token_id=a				, bos_token_id=a				, eos_token_id=a    )
            __snake_case   :     Union[str, Any]	      =hidden_size
            __snake_case   :     Tuple	      =feat_extract_norm
            __snake_case   :     Optional[int]	      =feat_extract_activation
            __snake_case   :     Optional[int]	      =list(a    )
            __snake_case   :     Optional[int]	      =list(a    )
            __snake_case   :     List[Any]	      =list(a    )
            __snake_case   :     Dict	      =conv_bias
            __snake_case   :     Union[str, Any]	      =num_conv_pos_embeddings
            __snake_case   :     Any	      =num_conv_pos_embedding_groups
            __snake_case   :     Optional[int]	      =len(self.conv_dim    )
            __snake_case   :     List[Any]	      =num_hidden_layers
            __snake_case   :     List[str]	      =intermediate_size
            __snake_case   :     Union[str, Any]	      =hidden_act
            __snake_case   :     Optional[int]	      =num_attention_heads
            __snake_case   :     str	      =hidden_dropout
            __snake_case   :     str	      =attention_dropout
            __snake_case   :     str	      =activation_dropout
            __snake_case   :     Tuple	      =feat_proj_layer_norm
            __snake_case   :     Any	      =feat_proj_dropout
            __snake_case   :     List[str]	      =final_dropout
            __snake_case   :     str	      =layerdrop
            __snake_case   :     Any	      =layer_norm_eps
            __snake_case   :     Optional[int]	      =initializer_range
            __snake_case   :     int	      =vocab_size
            __snake_case   :     Tuple	      =do_stable_layer_norm
            __snake_case   :     Any	      =use_weighted_layer_sum
            __snake_case   :     Optional[Any]	      =classifier_proj_size

            if (
                (len(self.conv_stride    ) != self.num_feat_extract_layers)
                or (len(self.conv_kernel    ) != self.num_feat_extract_layers)
                or (len(self.conv_dim    ) != self.num_feat_extract_layers)
            ):
                  raise ValueError(
                      '''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
                      ''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
                      f''' {len(self.conv_dim    )}`, `len(config.conv_stride) = {len(self.conv_stride    )}`,'''
                      f''' `len(config.conv_kernel) = {len(self.conv_kernel    )}`.'''    )

            # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
            __snake_case   :     Optional[Any]	      =apply_spec_augment
            __snake_case   :     Optional[int]	      =mask_time_prob
            __snake_case   :     Dict	      =mask_time_length
            __snake_case   :     List[Any]	      =mask_time_min_masks
            __snake_case   :     int	      =mask_feature_prob
            __snake_case   :     str	      =mask_feature_length
            __snake_case   :     Dict	      =mask_feature_min_masks

            # ctc loss
            __snake_case   :     Union[str, Any]	      =ctc_loss_reduction
            __snake_case   :     str	      =ctc_zero_infinity







      @property
      def _UpperCamelCase    (     self					:						List[Any]    ):





            """simple docstring"""







            return functools.reduce(operator.mul				, self.conv_stride				, 1    )










"""simple docstring"""





from itertools import combinations, product



def      __lowercase       (     a			:					int							,		a			:					int							,		a			:					int							,		a			:					int			)       ->       bool:
      if xa == ya == 0 or xa == ya == 0:
            return False
      __snake_case   :     Any	      =xa * xa + ya * ya
      __snake_case   :     Tuple	      =xa * xa + ya * ya
      __snake_case   :     List[Any]	      =(xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
      return (
          a_square + b_square == c_square
          or a_square + c_square == b_square
          or b_square + c_square == a_square
      )



def      __lowercase       (     a			:					int = 50			)       ->       int:
      return sum(
          1
          for pta, pta in combinations(product(range(limit + 1			)							,		repeat=2			)							,		2			)
          if is_right(*a							,		*a			)			)


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


