






from __future__ import annotations

from collections.abc import Callable
from typing import Any, Generic, TypeVar

__UpperCAmelCase							:   List[str]							=  TypeVar("T")


class 					_snake_case						(			Generic[T] ):






	def __init__(		self					,UpperCamelCase					,UpperCamelCase       )						->    None:
					snake_case__      :Any | T         =   None

					snake_case__      :int         =   len(UpperCamelCase       )
					snake_case__      :list[T]         =   [any_type for _ in range(self.N       )] + arr
					snake_case__      :Optional[Any]         =   fnc
					self.build()






	def    lowerCAmelCase_							(		self       )						->    None:
					for p in range(self.N - 1					,0					,-1       ):
									snake_case__      :Optional[Any]         =   self.fn(self.st[p * 2]					,self.st[p * 2 + 1]       )






	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase       )						->    None:
					p += self.N
					snake_case__      :Optional[Any]         =   v
					while p > 1:
									snake_case__      :List[str]         =   p // 2
									snake_case__      :List[Any]         =   self.fn(self.st[p * 2]					,self.st[p * 2 + 1]       )






	def    lowerCAmelCase_							(		self					,UpperCamelCase					,UpperCamelCase       )						->    T | None:  # noqa: E741
					snake_case__      :List[str]         =   l + self.N, r + self.N

					snake_case__      :T | None         =   None
					while l <= r:
									if l % 2 == 1:
													snake_case__      :List[str]         =   self.st[l] if res is None else self.fn(UpperCamelCase					,self.st[l]       )
									if r % 2 == 0:
													snake_case__      :Union[str, Any]         =   self.st[r] if res is None else self.fn(UpperCamelCase					,self.st[r]       )
									snake_case__      :List[str]         =   (l + 1) // 2, (r - 1) // 2
					return res


if __name__ == "__main__":
	from functools import reduce

	__UpperCAmelCase							:   Optional[Any]							=  [1, 1_0, -2, 9, -3, 8, 4, -7, 5, 6, 1_1, -1_2]

	__UpperCAmelCase							:   Dict							=  {
	    0: 7,
	    1: 2,
	    2: 6,
	    3: -1_4,
	    4: 5,
	    5: 4,
	    6: 7,
	    7: -1_0,
	    8: 9,
	    9: 1_0,
	    1_0: 1_2,
	    1_1: 1,
	}

	__UpperCAmelCase							:   Optional[int]							=  SegmentTree(test_array, min)
	__UpperCAmelCase							:   Dict							=  SegmentTree(test_array, max)
	__UpperCAmelCase							:   Dict							=  SegmentTree(test_array, lambda a, b: a + b)





	def 					lowercase_ (    )     -> None:





					'''simple docstring'''


					for i in range(len(__snake_case      )      ):
									for j in range(__snake_case	,	len(__snake_case      )      ):
													snake_case__      :Optional[Any]         =   reduce(__snake_case	,	test_array[i : j + 1]      )
													snake_case__      :str         =   reduce(__snake_case	,	test_array[i : j + 1]      )
													snake_case__      :List[str]         =   reduce(lambda __snake_case	,	__snake_case      : a + b	,	test_array[i : j + 1]      )
													assert min_range == min_segment_tree.query(__snake_case	,	__snake_case      )
													assert max_range == max_segment_tree.query(__snake_case	,	__snake_case      )
													assert sum_range == sum_segment_tree.query(__snake_case	,	__snake_case      )

	test_all_segments()

	for index, value in test_updates.items():
		__UpperCAmelCase							:   Optional[Any]							=  value
		min_segment_tree.update(index, value)
		max_segment_tree.update(index, value)
		sum_segment_tree.update(index, value)
		test_all_segments()







def 					lowercase_ (    __snake_case     :							Tuple	,	__snake_case     :							Optional[int]      )     -> List[Any]:





				'''simple docstring'''


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





def 					lowercase_ (    __snake_case     :							List[str]      )     -> int:





				'''simple docstring'''


				return data[1:] + data[0]





def 					lowercase_ (    __snake_case     :							int	,	__snake_case     :							Union[str, Any]      )     -> Union[str, Any]:





				'''simple docstring'''


				snake_case__      :Union[str, Any]         =   ""
				for i in range(len(__snake_case      )      ):
								if a[i] == b[i]:
												res += "0"
								else:
												res += "1"
				return res





def 					lowercase_ (    __snake_case     :							Optional[int]	,	__snake_case     :							Dict      )     -> Union[str, Any]:





				'''simple docstring'''


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





def 					lowercase_ (    __snake_case     :							Dict	,	__snake_case     :							Optional[Any]	,	__snake_case     :							Dict	,	__snake_case     :							List[Any]	,	__snake_case     :							Optional[int]      )     -> List[str]:





				'''simple docstring'''


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


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

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

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

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

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