


"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase				=						logging.get_logger(__name__)

UpperCAmelCase				=						{
    """funnel-transformer/small""": """https://huggingface.co/funnel-transformer/small/resolve/main/config.json""",
    """funnel-transformer/small-base""": """https://huggingface.co/funnel-transformer/small-base/resolve/main/config.json""",
    """funnel-transformer/medium""": """https://huggingface.co/funnel-transformer/medium/resolve/main/config.json""",
    """funnel-transformer/medium-base""": """https://huggingface.co/funnel-transformer/medium-base/resolve/main/config.json""",
    """funnel-transformer/intermediate""": (
        """https://huggingface.co/funnel-transformer/intermediate/resolve/main/config.json"""
    ),
    """funnel-transformer/intermediate-base""": (
        """https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/config.json"""
    ),
    """funnel-transformer/large""": """https://huggingface.co/funnel-transformer/large/resolve/main/config.json""",
    """funnel-transformer/large-base""": """https://huggingface.co/funnel-transformer/large-base/resolve/main/config.json""",
    """funnel-transformer/xlarge""": """https://huggingface.co/funnel-transformer/xlarge/resolve/main/config.json""",
    """funnel-transformer/xlarge-base""": """https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/config.json""",
}




class 	lowercase__				(					A_				):
   __UpperCAmelCase							       =					'''funnel'''
   __UpperCAmelCase							       =					{
       '''hidden_size''': '''d_model''',
       '''num_attention_heads''': '''n_head''',
   }





   def __init__(							self      ,   SCREAMING_SNAKE_CASE=3_0522      ,   SCREAMING_SNAKE_CASE=[4, 4, 4]      ,   SCREAMING_SNAKE_CASE=None      ,   SCREAMING_SNAKE_CASE=2      ,   SCREAMING_SNAKE_CASE=768      ,   SCREAMING_SNAKE_CASE=12      ,   SCREAMING_SNAKE_CASE=64      ,   SCREAMING_SNAKE_CASE=3072      ,   SCREAMING_SNAKE_CASE="gelu_new"      ,   SCREAMING_SNAKE_CASE=0.1      ,   SCREAMING_SNAKE_CASE=0.1      ,   SCREAMING_SNAKE_CASE=0.0      ,   SCREAMING_SNAKE_CASE=0.1      ,   SCREAMING_SNAKE_CASE=None      ,   SCREAMING_SNAKE_CASE=1e-9      ,   SCREAMING_SNAKE_CASE="mean"      ,   SCREAMING_SNAKE_CASE="relative_shift"      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   **SCREAMING_SNAKE_CASE      ,   )  ->  Optional[Any]:
      _lowerCamelCase	:					Optional[int]   =		vocab_size
      _lowerCamelCase	:					Any   =		block_sizes
      _lowerCamelCase	:					int   =		[1] * len(SCREAMING_SNAKE_CASE) if block_repeats is None else block_repeats
      assert len(SCREAMING_SNAKE_CASE) == len(
          self.block_repeats), "`block_sizes` and `block_repeats` should have the same length."
      _lowerCamelCase	:					Tuple   =		num_decoder_layers
      _lowerCamelCase	:					Dict   =		d_model
      _lowerCamelCase	:					List[Any]   =		n_head
      _lowerCamelCase	:					Dict   =		d_head
      _lowerCamelCase	:					List[str]   =		d_inner
      _lowerCamelCase	:					Dict   =		hidden_act
      _lowerCamelCase	:					int   =		hidden_dropout
      _lowerCamelCase	:					Any   =		attention_dropout
      _lowerCamelCase	:					int   =		activation_dropout
      _lowerCamelCase	:					Optional[int]   =		initializer_range
      _lowerCamelCase	:					str   =		initializer_std
      _lowerCamelCase	:					Any   =		layer_norm_eps
      assert pooling_type in [
          "mean",
          "max",
      ], F'Got {pooling_type} for `pooling_type` but only \'mean\' and \'max\' are supported.'
      _lowerCamelCase	:					List[str]   =		pooling_type
      assert attention_type in [
          "relative_shift",
          "factorized",
      ], F'Got {attention_type} for `attention_type` but only \'relative_shift\' and \'factorized\' are supported.'
      _lowerCamelCase	:					int   =		attention_type
      _lowerCamelCase	:					List[str]   =		separate_cls
      _lowerCamelCase	:					Tuple   =		truncate_seq
      _lowerCamelCase	:					List[Any]   =		pool_q_only

      super().__init__(**SCREAMING_SNAKE_CASE)





   @property
   def 		UpperCamelCase_  (							self)  ->  Union[str, Any]:
      return sum(self.block_sizes)





   @num_hidden_layers.setter
   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  List[str]:
      raise NotImplementedError(
          """This model does not support the setting of `num_hidden_layers`. Please set `block_sizes`.""")





   @property
   def 		UpperCamelCase_  (							self)  ->  List[Any]:
      return len(self.block_sizes)





   @num_blocks.setter
   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE)  ->  Optional[Any]:
      raise NotImplementedError("""This model does not support the setting of `num_blocks`. Please set `block_sizes`.""")









'''simple docstring'''

def 				snake_case       (  a_				:			list						)							->					list:





      """simple docstring"""

      UpperCamelCase_					: List[str]            =				False
      while is_sorted is False:  # Until all the indices are traversed keep looping
            UpperCamelCase_					: Tuple            =				True
            for i in range(0     , len(a_						) - 1     , 2						):  # iterating over all even indices
                  if input_list[i] > input_list[i + 1]:
                        UpperCamelCase_     ,      UpperCamelCase_					: Optional[Any]            =				input_list[i + 1], input_list[i]
                        # swapping if elements not in order
                        UpperCamelCase_					: Any            =				False

            for i in range(1     , len(a_						) - 1     , 2						):  # iterating over all odd indices
                  if input_list[i] > input_list[i + 1]:
                        UpperCamelCase_     ,      UpperCamelCase_					: List[str]            =				input_list[i + 1], input_list[i]
                        # swapping if elements not in order
                        UpperCamelCase_					: Dict            =				False
      return input_list


if __name__ == "__main__":
      print("Enter list to be sorted")
      UpperCamelCase      					=[int(x) for x in input().split()]
      # inputing elements of the list in one line
      UpperCamelCase      					=odd_even_sort(input_list)
      print("The sorted list is")
      print(sorted_list)






