






"""simple docstring"""



import numpy as np
from cva import destroyAllWindows, imread, imshow, waitKey

class        a     :







    def __init__(			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
      if dst_width < 0 or dst_height < 0:
        raise ValueError('Destination width/height should be > 0'       )

      lowercase							    =       img
      lowercase							    =       img.shape[1]
      lowercase							    =       img.shape[0]
      lowercase							    =       dst_width
      lowercase							    =       dst_height

      lowercase							    =       self.src_w / self.dst_w
      lowercase							    =       self.src_h / self.dst_h

      lowercase							    =       lowercase							    =       (
          np.ones((self.dst_h, self.dst_w, 3)							,		np.uinta       ) * 2_5_5
      )







    def 			UpperCamelCase_      (			self       ):
      for i in range(self.dst_h       ):
        for j in range(self.dst_w       ):
          lowercase							    =       self.img[self.get_y(_lowerCamelCase       )][self.get_x(_lowerCamelCase       )]







    def 			UpperCamelCase_      (			self							,		_lowerCamelCase       ):
      return int(self.ratio_x * x       )







    def 			UpperCamelCase_      (			self							,		_lowerCamelCase       ):
      return int(self.ratio_y * y       )


if __name__ == "__main__":
    _UpperCamelCase,		_UpperCamelCase		:  Tuple						=		8_0_0, 6_0_0
    _UpperCamelCase		:  Optional[int]						=		imread('image_data/lena.jpg', 1)
    _UpperCamelCase		:  Dict						=		NearestNeighbour(im, dst_w, dst_h)
    n.process()

    imshow(
        F'''Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}''', n.output
    )
    waitKey(0)
    destroyAllWindows()










"""simple docstring"""



def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  List[str]		,					__snake_case			:  List[str]    ):





  '''simple docstring'''





  lowercase							    =       ''
  for i in table:
    res += inp[i - 1]
  return res
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  str    ):





  '''simple docstring'''





  return data[1:] + data[0]
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  List[str]		,					__snake_case			:  Optional[int]    ):





  '''simple docstring'''





  lowercase							    =       ''
  for i in range(len(__snake_case    )    ):
    if a[i] == b[i]:
      res += "0"
    else:
      res += "1"
  return res
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Dict		,					__snake_case			:  Optional[Any]    ):





  '''simple docstring'''





  lowercase							    =       int('0b' + data[0] + data[-1]		,					2    )
  lowercase							    =       int('0b' + data[1:3]		,					2    )
  return bin(s[row][col]    )[2:]
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Union[str, Any]		,					__snake_case			:  Union[str, Any]		,					__snake_case			:  Dict		,					__snake_case			:  Union[str, Any]		,					__snake_case			:  Optional[int]    ):





  '''simple docstring'''





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


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

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

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

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

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


