def 	__SCREAMING_SNAKE_CASE  (					__UpperCamelCase    :       Tuple ,     __UpperCamelCase    :       Tuple	)							->					Any:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__										=      """"""
  for i in table:
    res += inp[i - 1]
  return res



def 	__SCREAMING_SNAKE_CASE  (					__UpperCamelCase    :       Optional[int]	)							->					Dict:







  """simple docstring"""





  return data[1:] + data[0]



def 	__SCREAMING_SNAKE_CASE  (					__UpperCamelCase    :       Dict ,     __UpperCamelCase    :       Union[str, Any]	)							->					Dict:







  """simple docstring"""





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



def 	__SCREAMING_SNAKE_CASE  (					__UpperCamelCase    :       Tuple ,     __UpperCamelCase    :       Tuple	)							->					Optional[int]:







  """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 	__SCREAMING_SNAKE_CASE  (					__UpperCamelCase    :       Any ,     __UpperCamelCase    :       List[Any] ,     __UpperCamelCase    :       List[Any] ,     __UpperCamelCase    :       Dict ,     __UpperCamelCase    :       Dict	)							->					List[str]:







  """simple docstring"""





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


if __name__ == "__main__":
   __lowerCamelCase			: Optional[Any]							   =		input('''Enter 10 bit key: ''')
   __lowerCamelCase			: Optional[Any]							   =		input('''Enter 8 bit message: ''')

   __lowerCamelCase			: Tuple							   =		[6, 3, 7, 4, 8, 5, 10, 9]
   __lowerCamelCase			: Union[str, Any]							   =		[3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
   __lowerCamelCase			: Optional[int]							   =		[2, 4, 3, 1]
   __lowerCamelCase			: Optional[int]							   =		[2, 6, 3, 1, 4, 8, 5, 7]
   __lowerCamelCase			: Tuple							   =		[4, 1, 3, 5, 7, 2, 8, 6]
   __lowerCamelCase			: List[str]							   =		[4, 1, 2, 3, 2, 3, 4, 1]
   __lowerCamelCase			: List[str]							   =		[[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
   __lowerCamelCase			: Dict							   =		[[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

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

   # encryption
   __lowerCamelCase			: Any							   =		apply_table(message, IP)
   __lowerCamelCase			: List[str]							   =		function(expansion, sa, sa, keya, temp)
   __lowerCamelCase			: Dict							   =		temp[4:] + temp[:4]
   __lowerCamelCase			: List[str]							   =		function(expansion, sa, sa, keya, temp)
   __lowerCamelCase			: str							   =		apply_table(temp, IP_inv)
   print('''Cipher text is:''', CT)

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

'''simple docstring'''

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


_A			:      int					      =				logging.get_logger(__name__)

_A			:      Any					      =				{'''ctrl''': '''https://huggingface.co/ctrl/resolve/main/config.json'''}







class 				_lowercase     (				UpperCAmelCase__			):


 '''simple docstring'''






 _SCREAMING_SNAKE_CASE     :       Any      	=					"""ctrl"""
 _SCREAMING_SNAKE_CASE     :       Optional[Any]      	=					["""past_key_values"""]
 _SCREAMING_SNAKE_CASE     :       Union[str, Any]      	=					{
     """max_position_embeddings""": """n_positions""",
     """hidden_size""": """n_embd""",
     """num_attention_heads""": """n_head""",
     """num_hidden_layers""": """n_layer""",
 }
 def __init__(      self   :	Any      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=24_65_34      ,       SCREAMING_SNAKE_CASE__   :	Optional[int]=2_56      ,       SCREAMING_SNAKE_CASE__   :	Optional[Any]=12_80      ,       SCREAMING_SNAKE_CASE__   :	str=81_92      ,       SCREAMING_SNAKE_CASE__   :	List[str]=48      ,       SCREAMING_SNAKE_CASE__   :	Tuple=16      ,       SCREAMING_SNAKE_CASE__   :	str=0.1      ,       SCREAMING_SNAKE_CASE__   :	Dict=0.1      ,       SCREAMING_SNAKE_CASE__   :	Dict=1e-6      ,       SCREAMING_SNAKE_CASE__   :	Any=0.0_2      ,       SCREAMING_SNAKE_CASE__   :	Tuple=True      ,       **SCREAMING_SNAKE_CASE__   :	Optional[int]      ,       )  ->    Tuple:
  __lowerCAmelCase											=						vocab_size
  __lowerCAmelCase											=						n_positions
  __lowerCAmelCase											=						n_embd
  __lowerCAmelCase											=						n_layer
  __lowerCAmelCase											=						n_head
  __lowerCAmelCase											=						dff
  __lowerCAmelCase											=						resid_pdrop
  __lowerCAmelCase											=						embd_pdrop
  __lowerCAmelCase											=						layer_norm_epsilon
  __lowerCAmelCase											=						initializer_range

  __lowerCAmelCase											=						use_cache

  super().__init__(**SCREAMING_SNAKE_CASE__							)






