




import itertools
import string
from collections.abc import Generator, Iterable



def 				_A  (		lowerCAmelCase_	:   Iterable[str]  ,							lowerCAmelCase_	:   int     ):
     """simple docstring"""

     lowerCAmelCase__            =					iter(lowerCAmelCase_     )
     while True:
          lowerCAmelCase__            =					tuple(itertools.islice(lowerCAmelCase_  ,							lowerCAmelCase_     )     )
          if not chunk:
               return
          yield chunk



def 				_A  (		lowerCAmelCase_	:   str     ):
     """simple docstring"""

     lowerCAmelCase__            =					"".join([c.upper() for c in dirty if c in string.ascii_letters]     )
     lowerCAmelCase__            =					""

     if len(lowerCAmelCase_     ) < 2:
          return dirty

     for i in range(len(lowerCAmelCase_     ) - 1     ):
          clean += dirty[i]

          if dirty[i] == dirty[i + 1]:
               clean += "X"

     clean += dirty[-1]

     if len(lowerCAmelCase_     ) & 1:
          clean += "X"

     return clean



def 				_A  (		lowerCAmelCase_	:   str     ):
     """simple docstring"""

     lowerCAmelCase__            =					"ABCDEFGHIKLMNOPQRSTUVWXYZ"
     # we're using a list instead of a '2d' array because it makes the math
     # for setting up the table and doing the actual encoding/decoding simpler
     lowerCAmelCase__            =					[]

     # copy key chars into the table if they are in `alphabet` ignoring duplicates
     for char in key.upper():
          if char not in table and char in alphabet:
               table.append(lowerCAmelCase_     )

    # fill the rest of the table in with the remaining alphabet chars
     for char in alphabet:
          if char not in table:
               table.append(lowerCAmelCase_     )

     return table



def 				_A  (		lowerCAmelCase_	:   str  ,							lowerCAmelCase_	:   str     ):
     """simple docstring"""

     lowerCAmelCase__            =					generate_table(lowerCAmelCase_     )
     lowerCAmelCase__            =					prepare_input(lowerCAmelCase_     )
     lowerCAmelCase__            =					""

     # https://en.wikipedia.org/wiki/Playfair_cipher#Description
     for chara, chara in chunker(lowerCAmelCase_  ,							2     ):
          lowerCAmelCase__      ,						lowerCAmelCase__            =					divmod(table.index(lowerCAmelCase_     )  ,							5     )
          lowerCAmelCase__      ,						lowerCAmelCase__            =					divmod(table.index(lowerCAmelCase_     )  ,							5     )

          if rowa == rowa:
               ciphertext += table[rowa * 5 + (cola + 1) % 5]
               ciphertext += table[rowa * 5 + (cola + 1) % 5]
          elif cola == cola:
               ciphertext += table[((rowa + 1) % 5) * 5 + cola]
               ciphertext += table[((rowa + 1) % 5) * 5 + cola]
          else:  # rectangle
               ciphertext += table[rowa * 5 + cola]
               ciphertext += table[rowa * 5 + cola]

     return ciphertext






def 				_A  (		lowerCAmelCase_	:   str  ,							lowerCAmelCase_	:   str     ):
     """simple docstring"""

     lowerCAmelCase__            =					generate_table(lowerCAmelCase_     )
     lowerCAmelCase__            =					""

     # https://en.wikipedia.org/wiki/Playfair_cipher#Description
     for chara, chara in chunker(lowerCAmelCase_  ,							2     ):
          lowerCAmelCase__      ,						lowerCAmelCase__            =					divmod(table.index(lowerCAmelCase_     )  ,							5     )
          lowerCAmelCase__      ,						lowerCAmelCase__            =					divmod(table.index(lowerCAmelCase_     )  ,							5     )

          if rowa == rowa:
               plaintext += table[rowa * 5 + (cola - 1) % 5]
               plaintext += table[rowa * 5 + (cola - 1) % 5]
          elif cola == cola:
               plaintext += table[((rowa - 1) % 5) * 5 + cola]
               plaintext += table[((rowa - 1) % 5) * 5 + cola]
          else:  # rectangle
               plaintext += table[rowa * 5 + cola]
               plaintext += table[rowa * 5 + cola]

     return plaintext


"""simple docstring"""




import doctest
from collections import deque

import numpy as np





class 			snake_case  :

							def __init__(self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			[2, 1, 2, -1]
									SCREAMING_SNAKE_CASE_    			=			[1, 2, 3, 4]







							def _lowercase       (self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			len(self.first_signal     )
									SCREAMING_SNAKE_CASE_    			=			len(self.second_signal     )

									SCREAMING_SNAKE_CASE_    			=			max(SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     )

									# create a zero matrix of max_length x max_length
									SCREAMING_SNAKE_CASE_    			=			[[0] * max_length for i in range(SCREAMING_SNAKE_CASE_     )]

									# fills the smaller signal with zeros to make both signals of same length
									if length_first_signal < length_second_signal:
											self.first_signal += [0] * (max_length - length_first_signal)
									elif length_first_signal > length_second_signal:
											self.second_signal += [0] * (max_length - length_second_signal)
									for i in range(SCREAMING_SNAKE_CASE_     ):
											SCREAMING_SNAKE_CASE_    			=			deque(self.second_signal     )
											rotated_signal.rotate(SCREAMING_SNAKE_CASE_     )
											for j, item in enumerate(SCREAMING_SNAKE_CASE_     ):
													matrix[i][j] += item

        # multiply the matrix with the first signal
									SCREAMING_SNAKE_CASE_    			=			np.matmul(np.transpose(SCREAMING_SNAKE_CASE_     )							,							np.transpose(self.first_signal     )     )

									# rounding-off to two decimal places
									return [round(SCREAMING_SNAKE_CASE_							,							2     ) for i in final_signal]


if __name__ == "__main__":
						doctest.testmod()