


__lowerCAmelCase		       =							range(2, 20 + 1)
__lowerCAmelCase		       =							[10**k for k in range(ks[-1] + 1)]
__lowerCAmelCase		       =							{}




def    snake_case_     (  snake_case			,							snake_case			,							snake_case			,							snake_case     )  ->				Optional[int]:
       lowercase__:   str  			=   sum(a_i[j] for j in range(snake_case			,							len(snake_case     )     )     )
       lowercase__:   Optional[int]  			=   sum(a_i[j] * base[j] for j in range(min(len(snake_case     )			,							snake_case     )     )     )

       lowercase__			,						lowercase__:   str  			=   0, 0
       lowercase__:   Tuple  			=   n - i

       lowercase__:   Dict  			=   memo.get(snake_case     )

       if sub_memo is not None:
              lowercase__:   Optional[Any]  			=   sub_memo.get(snake_case     )

              if jumps is not None and len(snake_case     ) > 0:
                     # find and make the largest jump without going over
                     lowercase__:   int  			=   -1
                     for _k in range(len(snake_case     ) - 1			,							-1			,							-1     ):
                            if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
                                   lowercase__:   Union[str, Any]  			=   _k
                                   break

                     if max_jump >= 0:
                            lowercase__			,						lowercase__			,						lowercase__:   Any  			=   jumps[max_jump]
                            # since the difference between jumps is cached, add c
                            lowercase__:   str  			=   diff + c
                            for j in range(min(snake_case			,							len(snake_case     )     )     ):
                                   lowercase__			,						lowercase__:   Dict  			=   divmod(snake_case			,							10     )
                            if new_c > 0:
                                   add(snake_case			,							snake_case			,							snake_case     )

              else:
                     lowercase__:   List[Any]  			=   []
       else:
              lowercase__:   Optional[Any]  			=   {c: []}
              lowercase__:   Union[str, Any]  			=   sub_memo

       if dn >= max_dn or c + diff >= base[k]:
              return diff, dn

       if k > ks[0]:
              while True:
                     # keep doing smaller jumps
                     lowercase__			,						lowercase__:   Union[str, Any]  			=   next_term(snake_case			,							k - 1			,							i + dn			,							snake_case     )
                     diff += _diff
                     dn += terms_jumped

                     if dn >= max_dn or c + diff >= base[k]:
                            break
       else:
              # would be too small a jump, just compute sequential terms instead
              lowercase__			,						lowercase__:   Dict  			=   compute(snake_case			,							snake_case			,							i + dn			,							snake_case     )
              diff += _diff
              dn += terms_jumped

       lowercase__:   Any  			=   sub_memo[c]

       # keep jumps sorted by # of terms skipped
       lowercase__:   str  			=   0
       while j < len(snake_case     ):
              if jumps[j][1] > dn:
                     break
              j += 1

       # cache the jump for this value digitsum(b) and c
       sub_memo[c].insert(snake_case			,							(diff, dn, k)     )
       return (diff, dn)




def    snake_case_     (  snake_case			,							snake_case			,							snake_case			,							snake_case     )  ->				str:
       if i >= n:
              return 0, i
       if k > len(snake_case     ):
              a_i.extend([0 for _ in range(k - len(snake_case     )     )]     )

       # note: a_i -> b * 10^k + c
       # ds_b -> digitsum(b)
       # ds_c -> digitsum(c)
       lowercase__:   List[Any]  			=   i
       lowercase__			,						lowercase__			,						lowercase__:   Any  			=   0, 0, 0
       for j in range(len(snake_case     )     ):
              if j >= k:
                     ds_b += a_i[j]
              else:
                     ds_c += a_i[j]

       while i < n:
              i += 1
              lowercase__:   str  			=   ds_c + ds_b
              diff += addend
              lowercase__:   List[str]  			=   0
              for j in range(snake_case     ):
                     lowercase__:   Any  			=   a_i[j] + addend
                     lowercase__			,						lowercase__:   List[Any]  			=   divmod(snake_case			,							10     )

                     ds_c += a_i[j]

              if addend > 0:
                     break

       if addend > 0:
              add(snake_case			,							snake_case			,							snake_case     )
       return diff, i - start_i




def    snake_case_     (  snake_case			,							snake_case			,							snake_case     )  ->				int:
       for j in range(snake_case			,							len(snake_case     )     ):
              lowercase__:   str  			=   digits[j] + addend
              if s >= 10:
                     lowercase__			,						lowercase__:   Any  			=   divmod(snake_case			,							10     )
                     lowercase__:   Any  			=   addend // 10 + quotient
              else:
                     lowercase__:   Union[str, Any]  			=   s
                     lowercase__:   Union[str, Any]  			=   addend // 10

              if addend == 0:
                     break

       while addend > 0:
              lowercase__			,						lowercase__:   Union[str, Any]  			=   divmod(snake_case			,							10     )
              digits.append(snake_case     )




def    snake_case_     (  snake_case = 10**15     )  ->				int:
       lowercase__:   Optional[Any]  			=   [1]
       lowercase__:   int  			=   1
       lowercase__:   Tuple  			=   0
       while True:
              lowercase__			,						lowercase__:   str  			=   next_term(snake_case			,							20			,							i + dn			,							snake_case     )
              dn += terms_jumped
              if dn == n - i:
                     break

       lowercase__:   Dict  			=   0
       for j in range(len(snake_case     )     ):
              a_n += digits[j] * 10**j
       return a_n


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






import math

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


__lowerCAmelCase		       =							logging.get_logger(__name__)

__lowerCAmelCase		       =							{
    '''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      ):
 __lowercase :							Optional[int]        = 'data2vec-audio'
 def __init__(   self				, lowerCAmelCase__=32				, lowerCAmelCase__=768				, lowerCAmelCase__=12				, lowerCAmelCase__=12				, lowerCAmelCase__=3_072				, lowerCAmelCase__="gelu"				, lowerCAmelCase__=0.1				, lowerCAmelCase__=0.1				, lowerCAmelCase__=0.1				, lowerCAmelCase__=0.0				, lowerCAmelCase__=0.1				, lowerCAmelCase__=0.1				, lowerCAmelCase__=0.0_2				, lowerCAmelCase__=1E-5				, lowerCAmelCase__="gelu"				, lowerCAmelCase__=(512, 512, 512, 512, 512, 512, 512)				, lowerCAmelCase__=(5, 2, 2, 2, 2, 2, 2)				, lowerCAmelCase__=(10, 3, 3, 3, 3, 2, 2)				, lowerCAmelCase__=False				, lowerCAmelCase__=16				, lowerCAmelCase__=19				, lowerCAmelCase__=5				, lowerCAmelCase__=0.0_5				, lowerCAmelCase__=10				, lowerCAmelCase__=2				, lowerCAmelCase__=0.0				, lowerCAmelCase__=10				, lowerCAmelCase__=0				, lowerCAmelCase__="sum"				, lowerCAmelCase__=False				, lowerCAmelCase__=False				, lowerCAmelCase__=256				, lowerCAmelCase__=(512, 512, 512, 512, 1_500)				, lowerCAmelCase__=(5, 3, 3, 1, 1)				, lowerCAmelCase__=(1, 2, 3, 1, 1)				, lowerCAmelCase__=512				, lowerCAmelCase__=0				, lowerCAmelCase__=1				, lowerCAmelCase__=2				, lowerCAmelCase__=False				, lowerCAmelCase__=3				, lowerCAmelCase__=2				, lowerCAmelCase__=3				, lowerCAmelCase__=None				, **lowerCAmelCase__				, )					->				Optional[int]:




        '''simple docstring'''
        super().__init__(**lowerCAmelCase__				, pad_token_id=lowerCAmelCase__				, bos_token_id=lowerCAmelCase__				, eos_token_id=lowerCAmelCase__ )
        lowercase__:   int  			=   hidden_size
        lowercase__:   str  			=   feat_extract_activation
        lowercase__:   List[Any]  			=   list(lowerCAmelCase__ )
        lowercase__:   Optional[int]  			=   list(lowerCAmelCase__ )
        lowercase__:   int  			=   list(lowerCAmelCase__ )
        lowercase__:   Union[str, Any]  			=   conv_bias
        lowercase__:   int  			=   num_conv_pos_embeddings
        lowercase__:   List[str]  			=   num_conv_pos_embedding_groups
        lowercase__:   List[Any]  			=   conv_pos_kernel_size
        lowercase__:   Optional[Any]  			=   len(self.conv_dim )
        lowercase__:   List[str]  			=   num_hidden_layers
        lowercase__:   List[str]  			=   intermediate_size
        lowercase__:   Tuple  			=   hidden_act
        lowercase__:   Any  			=   num_attention_heads
        lowercase__:   Optional[int]  			=   hidden_dropout
        lowercase__:   List[str]  			=   attention_dropout
        lowercase__:   int  			=   activation_dropout
        lowercase__:   Dict  			=   feat_proj_dropout
        lowercase__:   str  			=   final_dropout
        lowercase__:   List[str]  			=   layerdrop
        lowercase__:   str  			=   layer_norm_eps
        lowercase__:   Union[str, Any]  			=   initializer_range
        lowercase__:   Union[str, Any]  			=   vocab_size
        lowercase__:   Any  			=   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
        lowercase__:   List[str]  			=   mask_time_prob
        lowercase__:   Tuple  			=   mask_time_length
        lowercase__:   List[Any]  			=   mask_time_min_masks
        lowercase__:   Optional[int]  			=   mask_feature_prob
        lowercase__:   Union[str, Any]  			=   mask_feature_length
        lowercase__:   List[str]  			=   mask_feature_min_masks

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

        # adapter
        lowercase__:   str  			=   add_adapter
        lowercase__:   List[Any]  			=   adapter_kernel_size
        lowercase__:   Tuple  			=   adapter_stride
        lowercase__:   Dict  			=   num_adapter_layers
        lowercase__:   Optional[Any]  			=   output_hidden_size or hidden_size

        # SequenceClassification-specific parameter. Feel free to ignore for other classes.
        lowercase__:   List[Any]  			=   classifier_proj_size

        # XVector-specific parameters. Feel free to ignore for other classes.
        lowercase__:   int  			=   list(lowerCAmelCase__ )
        lowercase__:   Dict  			=   list(lowerCAmelCase__ )
        lowercase__:   int  			=   list(lowerCAmelCase__ )
        lowercase__:   str  			=   xvector_output_dim
 @property
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[int]:




        '''simple docstring'''
        return math.prod(self.conv_stride )


