






def 							lowerCamelCase__ (       __lowerCamelCase     :	Dict    ,						__lowerCamelCase     :	Tuple						):
  __UpperCAmelCase				:      Optional[Any]	 =    """"""
  for i in table:
    res += inp[i - 1]
  return res






def 							lowerCamelCase__ (       __lowerCamelCase     :	Tuple						):
  return data[1:] + data[0]






def 							lowerCamelCase__ (       __lowerCamelCase     :	Optional[Any]    ,						__lowerCamelCase     :	str						):
  __UpperCAmelCase				:      str	 =    """"""
  for i in range(len(__lowerCamelCase						)						):
    if a[i] == b[i]:
      res += "0"
    else:
      res += "1"
  return res






def 							lowerCamelCase__ (       __lowerCamelCase     :	Union[str, Any]    ,						__lowerCamelCase     :	int						):
  __UpperCAmelCase				:      Optional[Any]	 =    int("""0b""" + data[0] + data[-1]    ,						2						)
  __UpperCAmelCase				:      str	 =    int("""0b""" + data[1:3]    ,						2						)
  return bin(s[row][col]						)[2:]






def 							lowerCamelCase__ (       __lowerCamelCase     :	Union[str, Any]    ,						__lowerCamelCase     :	str    ,						__lowerCamelCase     :	Optional[Any]    ,						__lowerCamelCase     :	Optional[int]    ,						__lowerCamelCase     :	Optional[Any]						):
  __UpperCAmelCase				:      List[str]	 =    message[:4]
  __UpperCAmelCase				:      Optional[int]	 =    message[4:]
  __UpperCAmelCase				:      List[Any]	 =    apply_table(__lowerCamelCase    ,						__lowerCamelCase						)
  __UpperCAmelCase				:      Optional[int]	 =    xor(__lowerCamelCase    ,						__lowerCamelCase						)
  __UpperCAmelCase				:      Union[str, Any]	 =    apply_sbox(__lowerCamelCase    ,						temp[:4]						)  # noqa: E741
  __UpperCAmelCase				:      str	 =    apply_sbox(__lowerCamelCase    ,						temp[4:]						)
  __UpperCAmelCase				:      Optional[Any]	 =    """0""" * (2 - len(__lowerCamelCase						)) + l  # noqa: E741
  __UpperCAmelCase				:      Optional[Any]	 =    """0""" * (2 - len(__lowerCamelCase						)) + r
  __UpperCAmelCase				:      Tuple	 =    apply_table(l + r    ,						__lowerCamelCase						)
  __UpperCAmelCase				:      Optional[Any]	 =    xor(__lowerCamelCase    ,						__lowerCamelCase						)
  return temp + right


if __name__ == "__main__":
       a						:			Dict     	=					input("Enter 10 bit key: ")
       a						:			Tuple     	=					input("Enter 8 bit message: ")

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

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

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

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





# this script reports modified .py files under the desired list of top-level sub-dirs passed as a list of arguments, e.g.:
#   python ./utils/get_modified_files.py utils src tests examples
#
# it uses git to find the forking point and which files were modified - i.e. files not under git won't be considered
# since the output of this script is fed into Makefile commands it doesn't print a newline after the results

import re
import subprocess
import sys


__lowercase				      =						subprocess.check_output("""git merge-base main HEAD""".split()).decode("""utf-8""")
__lowercase				      =						(
    subprocess.check_output(f'git diff --diff-filter=d --name-only {fork_point_sha}'.split()).decode("""utf-8""").split()
)

__lowercase				      =						"""|""".join(sys.argv[1:])
__lowercase				      =						re.compile(rf'^({joined_dirs}).*?\.py$')

__lowercase				      =						[x for x in modified_files if regex.match(x)]
print(""" """.join(relevant_modified_files), end="""""")





