

'''simple docstring'''
def        _lowerCAmelCase					(						_UpperCamelCase						:     Tuple							, _UpperCamelCase						:     int				)      ->			Optional[Any]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =''
     for i in table:
          res += inp[i - 1]
     return res


def        _lowerCAmelCase					(						_UpperCamelCase						:     Dict				)      ->			List[Any]:
     """simple docstring"""




     return data[1:] + data[0]


def        _lowerCAmelCase					(						_UpperCamelCase						:     Any							, _UpperCamelCase						:     List[Any]				)      ->			str:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =''
     for i in range(len(_UpperCamelCase				)				):
          if a[i] == b[i]:
               res += "0"
          else:
               res += "1"
     return res


def        _lowerCAmelCase					(						_UpperCamelCase						:     Optional[Any]							, _UpperCamelCase						:     Dict				)      ->			List[str]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =int('0b' + data[0] + data[-1]							, 2				)
     _SCREAMING_SNAKE_CASE							    =int('0b' + data[1:3]							, 2				)
     return bin(s[row][col]				)[2:]


def        _lowerCAmelCase					(						_UpperCamelCase						:     Tuple							, _UpperCamelCase						:     List[Any]							, _UpperCamelCase						:     Union[str, Any]							, _UpperCamelCase						:     List[str]							, _UpperCamelCase						:     Union[str, Any]				)      ->			int:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =message[:4]
     _SCREAMING_SNAKE_CASE							    =message[4:]
     _SCREAMING_SNAKE_CASE							    =apply_table(_UpperCamelCase							, _UpperCamelCase				)
     _SCREAMING_SNAKE_CASE							    =xor(_UpperCamelCase							, _UpperCamelCase				)
     _SCREAMING_SNAKE_CASE							    =apply_sbox(_UpperCamelCase							, temp[:4]				)  # noqa: E741
     _SCREAMING_SNAKE_CASE							    =apply_sbox(_UpperCamelCase							, temp[4:]				)
     _SCREAMING_SNAKE_CASE							    ='0' * (2 - len(_UpperCamelCase				)) + l  # noqa: E741
     _SCREAMING_SNAKE_CASE							    ='0' * (2 - len(_UpperCamelCase				)) + r
     _SCREAMING_SNAKE_CASE							    =apply_table(l + r							, _UpperCamelCase				)
     _SCREAMING_SNAKE_CASE							    =xor(_UpperCamelCase							, _UpperCamelCase				)
     return temp + right


if __name__ == "__main__":
     lowerCamelCase :      List[Any]					 =     input("Enter 10 bit key: ")
     lowerCamelCase :      Any					 =     input("Enter 8 bit message: ")

     lowerCamelCase :      Union[str, Any]					 =     [6, 3, 7, 4, 8, 5, 1_0, 9]
     lowerCamelCase :      Optional[Any]					 =     [3, 5, 2, 7, 4, 1_0, 1, 9, 8, 6]
     lowerCamelCase :      Dict					 =     [2, 4, 3, 1]
     lowerCamelCase :      Union[str, Any]					 =     [2, 6, 3, 1, 4, 8, 5, 7]
     lowerCamelCase :      str					 =     [4, 1, 3, 5, 7, 2, 8, 6]
     lowerCamelCase :      Union[str, Any]					 =     [4, 1, 2, 3, 2, 3, 4, 1]
     lowerCamelCase :      Any					 =     [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
     lowerCamelCase :      Any					 =     [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

     # key generation
     lowerCamelCase :      Optional[Any]					 =     apply_table(key, paa_table)
     lowerCamelCase :      str					 =     temp[:5]
     lowerCamelCase :      Optional[int]					 =     temp[5:]
     lowerCamelCase :      Dict					 =     left_shift(left)
     lowerCamelCase :      Dict					 =     left_shift(right)
     lowerCamelCase :      Optional[int]					 =     apply_table(left + right, pa_table)
     lowerCamelCase :      int					 =     left_shift(left)
     lowerCamelCase :      Any					 =     left_shift(right)
     lowerCamelCase :      Union[str, Any]					 =     left_shift(left)
     lowerCamelCase :      Optional[int]					 =     left_shift(right)
     lowerCamelCase :      str					 =     apply_table(left + right, pa_table)

     # encryption
     lowerCamelCase :      Optional[int]					 =     apply_table(message, IP)
     lowerCamelCase :      Tuple					 =     function(expansion, sa, sa, keya, temp)
     lowerCamelCase :      Any					 =     temp[4:] + temp[:4]
     lowerCamelCase :      Optional[Any]					 =     function(expansion, sa, sa, keya, temp)
     lowerCamelCase :      List[str]					 =     apply_table(temp, IP_inv)
     print("Cipher text is:", CT)

     # decryption
     lowerCamelCase :      List[str]					 =     apply_table(CT, IP)
     lowerCamelCase :      int					 =     function(expansion, sa, sa, keya, temp)
     lowerCamelCase :      Optional[int]					 =     temp[4:] + temp[:4]
     lowerCamelCase :      Any					 =     function(expansion, sa, sa, keya, temp)
     lowerCamelCase :      List[Any]					 =     apply_table(temp, IP_inv)
     print("Plain text after decypting is:", PT)



'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


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

lowerCamelCase :      List[Any]					 =     {
    "facebook/convnextv2-tiny-1k-224": "https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json",
}







class 							A__    (       A__     ,   A__  ):
  A__		 =				'convnextv2'





  def __init__(		self      :	Tuple							,					_a      :	Optional[int]=3							,					_a      :	Any=4							,					_a      :	int=4							,					_a      :	Union[str, Any]=None							,					_a      :	List[str]=None							,					_a      :	Optional[Any]="gelu"							,					_a      :	Any=0.02							,					_a      :	Any=1e-12							,					_a      :	Tuple=0.0							,					_a      :	int=224							,					_a      :	Any=None							,					_a      :	Optional[int]=None							,					**_a      :	List[str]							,					)	->    Optional[Any]:





       '''simple docstring'''






       super().__init__(**_a )

       _SCREAMING_SNAKE_CASE							    =num_channels
       _SCREAMING_SNAKE_CASE							    =patch_size
       _SCREAMING_SNAKE_CASE							    =num_stages
       _SCREAMING_SNAKE_CASE							    =[96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
       _SCREAMING_SNAKE_CASE							    =[3, 3, 9, 3] if depths is None else depths
       _SCREAMING_SNAKE_CASE							    =hidden_act
       _SCREAMING_SNAKE_CASE							    =initializer_range
       _SCREAMING_SNAKE_CASE							    =layer_norm_eps
       _SCREAMING_SNAKE_CASE							    =drop_path_rate
       _SCREAMING_SNAKE_CASE							    =image_size
       _SCREAMING_SNAKE_CASE							    =['stem'] + [f"stage{idx}" for idx in range(1							,					len(self.depths ) + 1 )]
       _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =get_aligned_output_features_output_indices(
           out_features=_a							,					out_indices=_a							,					stage_names=self.stage_names )
