'''simple docstring'''




import math

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


__UpperCAmelCase     							=logging.get_logger(__name__)

__UpperCAmelCase     							={
    "facebook/data2vec-base-960h": "https://huggingface.co/facebook/data2vec-audio-base-960h/resolve/main/config.json",
    # See all Data2VecAudio models at https://huggingface.co/models?filter=data2vec-audio
}




class     a__      (   UpperCAmelCase__ ):
     lowerCamelCase  :     Optional[int]							="data2vec-audio"






     def __init__( self		:		Optional[Any]  ,				a		:		int=32  ,				a		:		int=7_68  ,				a		:		Optional[Any]=12  ,				a		:		Any=12  ,				a		:		str=30_72  ,				a		:		Tuple="gelu"  ,				a		:		List[Any]=0.1  ,				a		:		int=0.1  ,				a		:		List[str]=0.1  ,				a		:		List[Any]=0.0  ,				a		:		Dict=0.1  ,				a		:		Optional[int]=0.1  ,				a		:		int=0.02  ,				a		:		List[Any]=1e-5  ,				a		:		List[str]="gelu"  ,				a		:		List[str]=(5_12, 5_12, 5_12, 5_12, 5_12, 5_12, 5_12)  ,				a		:		Optional[Any]=(5, 2, 2, 2, 2, 2, 2)  ,				a		:		Any=(10, 3, 3, 3, 3, 2, 2)  ,				a		:		Optional[int]=False  ,				a		:		List[Any]=16  ,				a		:		Optional[Any]=19  ,				a		:		Optional[int]=5  ,				a		:		str=0.05  ,				a		:		Union[str, Any]=10  ,				a		:		Tuple=2  ,				a		:		int=0.0  ,				a		:		List[str]=10  ,				a		:		Union[str, Any]=0  ,				a		:		List[Any]="sum"  ,				a		:		Dict=False  ,				a		:		List[Any]=False  ,				a		:		Dict=2_56  ,				a		:		Tuple=(5_12, 5_12, 5_12, 5_12, 15_00)  ,				a		:		Any=(5, 3, 3, 1, 1)  ,				a		:		Optional[Any]=(1, 2, 3, 1, 1)  ,				a		:		Optional[int]=5_12  ,				a		:		str=0  ,				a		:		Dict=1  ,				a		:		Optional[int]=2  ,				a		:		Optional[int]=False  ,				a		:		List[Any]=3  ,				a		:		int=2  ,				a		:		Any=3  ,				a		:		Optional[int]=None  ,				**a		:		str  ,				):





         """simple docstring"""



         super().__init__(**a  ,				pad_token_id=a  ,				bos_token_id=a  ,				eos_token_id=a    )
         __lowerCamelCase		=  hidden_size
         __lowerCamelCase		=  feat_extract_activation
         __lowerCamelCase		=  list(a    )
         __lowerCamelCase		=  list(a    )
         __lowerCamelCase		=  list(a    )
         __lowerCamelCase		=  conv_bias
         __lowerCamelCase		=  num_conv_pos_embeddings
         __lowerCamelCase		=  num_conv_pos_embedding_groups
         __lowerCamelCase		=  conv_pos_kernel_size
         __lowerCamelCase		=  len(self.conv_dim    )
         __lowerCamelCase		=  num_hidden_layers
         __lowerCamelCase		=  intermediate_size
         __lowerCamelCase		=  hidden_act
         __lowerCamelCase		=  num_attention_heads
         __lowerCamelCase		=  hidden_dropout
         __lowerCamelCase		=  attention_dropout
         __lowerCamelCase		=  activation_dropout
         __lowerCamelCase		=  feat_proj_dropout
         __lowerCamelCase		=  final_dropout
         __lowerCamelCase		=  layerdrop
         __lowerCamelCase		=  layer_norm_eps
         __lowerCamelCase		=  initializer_range
         __lowerCamelCase		=  vocab_size
         __lowerCamelCase		=  use_weighted_layer_sum

         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
         __lowerCamelCase		=  mask_time_prob
         __lowerCamelCase		=  mask_time_length
         __lowerCamelCase		=  mask_time_min_masks
         __lowerCamelCase		=  mask_feature_prob
         __lowerCamelCase		=  mask_feature_length
         __lowerCamelCase		=  mask_feature_min_masks

         # ctc loss
         __lowerCamelCase		=  ctc_loss_reduction
         __lowerCamelCase		=  ctc_zero_infinity

         # adapter
         __lowerCamelCase		=  add_adapter
         __lowerCamelCase		=  adapter_kernel_size
         __lowerCamelCase		=  adapter_stride
         __lowerCamelCase		=  num_adapter_layers
         __lowerCamelCase		=  output_hidden_size or hidden_size

         # SequenceClassification-specific parameter. Feel free to ignore for other classes.
         __lowerCamelCase		=  classifier_proj_size

         # XVector-specific parameters. Feel free to ignore for other classes.
         __lowerCamelCase		=  list(a    )
         __lowerCamelCase		=  list(a    )
         __lowerCamelCase		=  list(a    )
         __lowerCamelCase		=  xvector_output_dim






     @property
     def    SCREAMING_SNAKE_CASE__   ( self		:		int    ):





         """simple docstring"""



         return math.prod(self.conv_stride    )




'''simple docstring'''
from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt


def 			a      (			__a   )  ->	bool:



					'''simple docstring'''






					UpperCamelCase__   :int												= int(number**0.5   )
					return number == sq * sq


def 			a      (			__a ,					__a ,					__a ,					__a ,					__a ,					__a   )  ->	tuple[int, int]:



					'''simple docstring'''






					UpperCamelCase__   :int												= x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
					UpperCamelCase__   :int												= x_den * y_den * z_den
					UpperCamelCase__   :int												= gcd(__a ,					__a   )
					top //= hcf
					bottom //= hcf
					return top, bottom


def 			a      (			__a = 35   )  ->	int:



					'''simple docstring'''






					UpperCamelCase__   :set												= set()
					UpperCamelCase__   :int
					UpperCamelCase__   :Fraction												= Fraction(0   )
					UpperCamelCase__   :tuple[int, int]

					for x_num in range(1 ,					order + 1   ):
										for x_den in range(x_num + 1 ,					order + 1   ):
															for y_num in range(1 ,					order + 1   ):
																				for y_den in range(y_num + 1 ,					order + 1   ):
																									# n=1
																									UpperCamelCase__   :int												= x_num * y_den + x_den * y_num
																									UpperCamelCase__   :Any												= x_den * y_den
																									UpperCamelCase__   :Tuple												= gcd(__a ,					__a   )
																									z_num //= hcf
																									z_den //= hcf
																									if 0 < z_num < z_den <= order:
																														UpperCamelCase__   :Tuple												= add_three(
																														    __a ,					__a ,					__a ,					__a ,					__a ,					__a   )
																														unique_s.add(__a   )

																									# n=2
																									UpperCamelCase__   :List[str]												= (
																									    x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
																									)
																									UpperCamelCase__   :Dict												= x_den * x_den * y_den * y_den
																									if is_sq(__a   ) and is_sq(__a   ):
																														UpperCamelCase__   :Any												= int(sqrt(__a   )   )
																														UpperCamelCase__   :Optional[int]												= int(sqrt(__a   )   )
																														UpperCamelCase__   :int												= gcd(__a ,					__a   )
																														z_num //= hcf
																														z_den //= hcf
																														if 0 < z_num < z_den <= order:
																																			UpperCamelCase__   :Tuple												= add_three(
																																			    __a ,					__a ,					__a ,					__a ,					__a ,					__a   )
																																			unique_s.add(__a   )

                    # n=-1
																									UpperCamelCase__   :Tuple												= x_num * y_num
																									UpperCamelCase__   :Union[str, Any]												= x_den * y_num + x_num * y_den
																									UpperCamelCase__   :List[str]												= gcd(__a ,					__a   )
																									z_num //= hcf
																									z_den //= hcf
																									if 0 < z_num < z_den <= order:
																														UpperCamelCase__   :Union[str, Any]												= add_three(
																														    __a ,					__a ,					__a ,					__a ,					__a ,					__a   )
																														unique_s.add(__a   )

																									# n=2
																									UpperCamelCase__   :Optional[Any]												= x_num * x_num * y_num * y_num
																									UpperCamelCase__   :Tuple												= (
																									    x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
																									)
																									if is_sq(__a   ) and is_sq(__a   ):
																														UpperCamelCase__   :str												= int(sqrt(__a   )   )
																														UpperCamelCase__   :Any												= int(sqrt(__a   )   )
																														UpperCamelCase__   :Dict												= gcd(__a ,					__a   )
																														z_num //= hcf
																														z_den //= hcf
																														if 0 < z_num < z_den <= order:
																																			UpperCamelCase__   :int												= add_three(
																																			    __a ,					__a ,					__a ,					__a ,					__a ,					__a   )
																																			unique_s.add(__a   )

					for num, den in unique_s:
										total += Fraction(__a ,					__a   )

					return total.denominator + total.numerator


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