






"""simple docstring"""



from __future__ import annotations




def       snake_case__		(   _SCREAMING_SNAKE_CASE			)    ->List[Any]:
 global graph, reversed_graph, scc, component, visit, stack
 if visit[u]:
  return
 UpperCAmelCase__ 						=				True
 for v in graph[u]:
  dfs(lowerCAmelCase_			)
 stack.append(lowerCAmelCase_			)




def       snake_case__		(   _SCREAMING_SNAKE_CASE			)    ->Optional[Any]:
 global graph, reversed_graph, scc, component, visit, stack
 if visit[u]:
  return
 UpperCAmelCase__ 						=				True
 component.append(lowerCAmelCase_			)
 for v in reversed_graph[u]:
  dfsa(lowerCAmelCase_			)




def       snake_case__		(   )    ->List[Any]:
 global graph, reversed_graph, scc, component, visit, stack
 for i in range(lowerCAmelCase_			):
  dfs(lowerCAmelCase_			)
 UpperCAmelCase__ 						=				[False] * n
 for i in stack[::-1]:
  if visit[i]:
   continue
  UpperCAmelCase__ 						=				[]
  dfsa(lowerCAmelCase_			)
  scc.append(lowerCAmelCase_			)
 return scc


if __name__ == "__main__":
 # n - no of nodes, m - no of edges
 a       ,				a  :						Dict					       =							list(map(int, input().strip().split()))

 a  :						Dict					       =							[[] for _ in range(n)]  # graph
 a  :						Union[str, Any]					       =							[[] for i in range(n)]  # reversed graph
 # input graph data (edges)
 for _ in range(m):
  a       ,				a  :						str					       =							list(map(int, input().strip().split()))
  graph[u].append(v)
  reversed_graph[v].append(u)

 a  :						Tuple					       =							[]
 a  :						str					       =							[False] * n
 a  :						Any					       =							[]
 a  :						List[str]					       =							[]
 print(kosaraju())






def      snake_case__							(  lowerCAmelCase_,       lowerCAmelCase_     ):





     """simple docstring"""







     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('plaintext must be a string'     )
     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('key must be a string'     )

     if not plaintext:
          raise ValueError('plaintext is empty'     )
     if not key:
          raise ValueError('key is empty'     )

     key += plaintext
     SCREAMING_SNAKE_CASE 		=plaintext.lower()
     SCREAMING_SNAKE_CASE 		=key.lower()
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=''
     while plaintext_iterator < len(lowerCAmelCase_     ):
          if (
              ord(plaintext[plaintext_iterator]     ) < 97
              or ord(plaintext[plaintext_iterator]     ) > 122
          ):
               ciphertext += plaintext[plaintext_iterator]
               plaintext_iterator += 1
          elif ord(key[key_iterator]     ) < 97 or ord(key[key_iterator]     ) > 122:
               key_iterator += 1
          else:
               ciphertext += chr(
                   (
                       (ord(plaintext[plaintext_iterator]     ) - 97 + ord(key[key_iterator]     ))
                       - 97
                   )
                   % 26
                   + 97     )
               key_iterator += 1
               plaintext_iterator += 1
     return ciphertext







def      snake_case__							(  lowerCAmelCase_,       lowerCAmelCase_     ):





     """simple docstring"""







     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('ciphertext must be a string'     )
     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('key must be a string'     )

     if not ciphertext:
          raise ValueError('ciphertext is empty'     )
     if not key:
          raise ValueError('key is empty'     )

     SCREAMING_SNAKE_CASE 		=key.lower()
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=''
     while ciphertext_iterator < len(lowerCAmelCase_     ):
          if (
              ord(ciphertext[ciphertext_iterator]     ) < 97
              or ord(ciphertext[ciphertext_iterator]     ) > 122
          ):
               plaintext += ciphertext[ciphertext_iterator]
          else:
               plaintext += chr(
                   (ord(ciphertext[ciphertext_iterator]     ) - ord(key[key_iterator]     )) % 26
                   + 97     )
               key += chr(
                   (ord(ciphertext[ciphertext_iterator]     ) - ord(key[key_iterator]     )) % 26
                   + 97     )
               key_iterator += 1
          ciphertext_iterator += 1
     return plaintext


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 _lowerCamelCase							=int(input("Type 1 to encrypt or 2 to decrypt:"))
 if operation == 1:
  _lowerCamelCase							=input("Typeplaintext to be encrypted:\n")
  _lowerCamelCase							=input("Type the key:\n")
  print(encrypt(plaintext, key))
 elif operation == 2:
  _lowerCamelCase							=input("Type the ciphertext to be decrypted:\n")
  _lowerCamelCase							=input("Type the key:\n")
  print(decrypt(ciphertext, key))
 decrypt("jsqqs avvwo", "coffee")

