






def      snake_case		(							UpperCAmelCase	:       Optional[int],						UpperCAmelCase	:       Union[str, Any]   ):
				A	 =      ''
				for i in table:
								res += inp[i - 1]
				return res







def      snake_case		(							UpperCAmelCase	:       Union[str, Any]   ):
				return data[1:] + data[0]







def      snake_case		(							UpperCAmelCase	:       Union[str, Any],						UpperCAmelCase	:       Dict   ):
				A	 =      ''
				for i in range(len(UpperCAmelCase   )   ):
								if a[i] == b[i]:
												res += "0"
								else:
												res += "1"
				return res







def      snake_case		(							UpperCAmelCase	:       int,						UpperCAmelCase	:       Optional[Any]   ):
				A	 =      int('0b' + data[0] + data[-1],						2   )
				A	 =      int('0b' + data[1:3],						2   )
				return bin(s[row][col]   )[2:]







def      snake_case		(							UpperCAmelCase	:       Optional[Any],						UpperCAmelCase	:       Any,						UpperCAmelCase	:       Union[str, Any],						UpperCAmelCase	:       Optional[Any],						UpperCAmelCase	:       Optional[int]   ):
				A	 =      message[:4]
				A	 =      message[4:]
				A	 =      apply_table(UpperCAmelCase,						UpperCAmelCase   )
				A	 =      xor(UpperCAmelCase,						UpperCAmelCase   )
				A	 =      apply_sbox(UpperCAmelCase,						temp[:4]   )  # noqa: E741
				A	 =      apply_sbox(UpperCAmelCase,						temp[4:]   )
				A	 =      '0' * (2 - len(UpperCAmelCase   )) + l  # noqa: E741
				A	 =      '0' * (2 - len(UpperCAmelCase   )) + r
				A	 =      apply_table(l + r,						UpperCAmelCase   )
				A	 =      xor(UpperCAmelCase,						UpperCAmelCase   )
				return temp + right


if __name__ == "__main__":
					lowerCAmelCase_           = input('Enter 10 bit key: ')
					lowerCAmelCase_           = input('Enter 8 bit message: ')

					lowerCAmelCase_           = [6, 3, 7, 4, 8, 5, 10, 9]
					lowerCAmelCase_           = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
					lowerCAmelCase_           = [2, 4, 3, 1]
					lowerCAmelCase_           = [2, 6, 3, 1, 4, 8, 5, 7]
					lowerCAmelCase_           = [4, 1, 3, 5, 7, 2, 8, 6]
					lowerCAmelCase_           = [4, 1, 2, 3, 2, 3, 4, 1]
					lowerCAmelCase_           = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
					lowerCAmelCase_           = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

					# key generation
					lowerCAmelCase_           = apply_table(key, paa_table)
					lowerCAmelCase_           = temp[:5]
					lowerCAmelCase_           = temp[5:]
					lowerCAmelCase_           = left_shift(left)
					lowerCAmelCase_           = left_shift(right)
					lowerCAmelCase_           = apply_table(left + right, pa_table)
					lowerCAmelCase_           = left_shift(left)
					lowerCAmelCase_           = left_shift(right)
					lowerCAmelCase_           = left_shift(left)
					lowerCAmelCase_           = left_shift(right)
					lowerCAmelCase_           = apply_table(left + right, pa_table)

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

					# decryption
					lowerCAmelCase_           = apply_table(CT, IP)
					lowerCAmelCase_           = function(expansion, sa, sa, keya, temp)
					lowerCAmelCase_           = temp[4:] + temp[:4]
					lowerCAmelCase_           = function(expansion, sa, sa, keya, temp)
					lowerCAmelCase_           = apply_table(temp, IP_inv)
					print('Plain text after decypting is:', PT)













import copy
import re
class      UpperCamelCase :







		"""simple docstring"""



		snake_case    =   "hp"
		snake_case    =   {}
		snake_case    =   None
		@classmethod
		def       A(  cls		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   int:


						'''simple docstring'''
						A	 =      prefix
						A	 =      defaults
						cls.build_naming_info()
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   Optional[Any]:


						'''simple docstring'''
						if len(_SCREAMING_SNAKE_CASE		) == 0:
										return ""
						A	 =      None
						if any(char.isdigit() for char in word		):
										raise Exception(f'Parameters should not contain numbers: \'{word}\' contains a number'		)
						if word in info["short_word"]:
										return info["short_word"][word]
						for prefix_len in range(1						,len(_SCREAMING_SNAKE_CASE		) + 1		):
										A	 =      word[:prefix_len]
										if prefix in info["reverse_short_word"]:
														continue
										else:
														A	 =      prefix
														break

						if short_word is None:
										# Paranoid fallback
										def int_to_alphabetic(_SCREAMING_SNAKE_CASE		:       Optional[int]		):
														A	 =      ''
														while integer != 0:
																		A	 =      chr(ord('A'		) + integer % 1_0		) + s
																		integer //= 1_0
														return s

										A	 =      0
										while True:
														A	 =      word + '#' + int_to_alphabetic(_SCREAMING_SNAKE_CASE		)
														if sword in info["reverse_short_word"]:
																		continue
														else:
																		A	 =      sword
																		break

						A	 =      short_word
						A	 =      word
						return short_word
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   int:


						'''simple docstring'''
						A	 =      param_name.split('_'		)

						A	 =      [TrialShortNamer.shortname_for_word(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		) for word in words]

						# We try to create a separatorless short name, but if there is a collision we have to fallback
						# to a separated short name
						A	 =      ['', '_']

						for separator in separators:
										A	 =      separator.join(_SCREAMING_SNAKE_CASE		)
										if shortname not in info["reverse_short_param"]:
														A	 =      shortname
														A	 =      param_name
														return shortname

						return param_name
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   List[str]:


						'''simple docstring'''
						A	 =      TrialShortNamer.shortname_for_key(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)
						A	 =      short_name
						A	 =      param_name
		@classmethod
		def       A(  cls		:       Optional[int]		)    ->   str:


						'''simple docstring'''
						if cls.NAMING_INFO is not None:
										return

						A	 =      {
						    'short_word': {},
						    'reverse_short_word': {},
						    'short_param': {},
						    'reverse_short_param': {},
						}

						A	 =      list(cls.DEFAULTS.keys()		)

						for k in field_keys:
										cls.add_new_param_name(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)

						A	 =      info
		@classmethod
		def       A(  cls		:       List[str]						,_SCREAMING_SNAKE_CASE		:       str		)    ->   List[Any]:


						'''simple docstring'''
						cls.build_naming_info()
						assert cls.PREFIX is not None
						A	 =      [copy.copy(cls.PREFIX		)]

						for k, v in params.items():
										if k not in cls.DEFAULTS:
														raise Exception(f'You should provide a default value for the param name {k} with value {v}'		)
										if v == cls.DEFAULTS[k]:
														# The default value is not added to the name
														continue

										A	 =      cls.NAMING_INFO['short_param'][k]

										if isinstance(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		):
														A	 =      1 if v else 0

										A	 =      '' if isinstance(_SCREAMING_SNAKE_CASE						,(int, float)		) else '-'
										A	 =      f'{key}{sep}{v}'
										name.append(_SCREAMING_SNAKE_CASE		)

						return "_".join(_SCREAMING_SNAKE_CASE		)







		@classmethod
		def       A(  cls		:       int						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   str:


						'''simple docstring'''
						A	 =      repr[len(cls.PREFIX		) + 1 :]
						if repr == "":
										A	 =      []
						else:
										A	 =      repr.split('_'		)

						A	 =      {}

						for value in values:
										if "-" in value:
														A ,		A	 =      value.split('-'		)
										else:
														A	 =      re.sub('[0-9.]'						,''						,_SCREAMING_SNAKE_CASE		)
														A	 =      float(re.sub('[^0-9.]'						,''						,_SCREAMING_SNAKE_CASE		)		)

										A	 =      cls.NAMING_INFO['reverse_short_param'][p_k]

										A	 =      p_v

						for k in cls.DEFAULTS:
										if k not in parameters:
														A	 =      cls.DEFAULTS[k]

						return parameters





