
"""simple docstring"""

import string

import numpy






def 							A		(       snake_case   :int       ,      snake_case   :int	)   ->			int:
 return b if a == 0 else greatest_common_divisor(b % a       ,      snake_case	)

class __lowerCAmelCase	:
     lowercase		     =		string.ascii_uppercase + string.digits
     # This cipher takes alphanumerics into account
     # i.e. a total of 36 characters

     # take x and return x % len(key_string)
     lowercase		     =		numpy.vectorize(lambda __SCREAMING_SNAKE_CASE    : x % 36    )

     lowercase		     =		numpy.vectorize(__SCREAMING_SNAKE_CASE    )





     def __init__(			self			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.modulus(__UpperCAmelCase   )  # mod36 calc's on the encrypt key
      self.check_determinant()  # validate the determinant of the encryption key
      __UpperCamelCase       						= encrypt_key.shape[0]





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase   ):

      '''simple docstring'''




      return self.key_string.index(__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase   ):

      '''simple docstring'''




      return self.key_string[round(__UpperCAmelCase   )]





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= round(numpy.linalg.det(self.encrypt_key   )   )

      if det < 0:
       __UpperCamelCase       						= det % len(self.key_string   )

      __UpperCamelCase       						= len(self.key_string   )
      if greatest_common_divisor(__UpperCAmelCase			,  len(self.key_string   )   ) != 1:
       __UpperCamelCase       						= (
           F'determinant modular {req_l} of encryption key({det}) '
           F'is not co prime w.r.t {req_l}.\nTry another key.'
       )
       raise ValueError(__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= [char for char in text.upper() if char in self.key_string]

      __UpperCamelCase       						= chars[-1]
      while len(__UpperCAmelCase   ) % self.break_key != 0:
       chars.append(__UpperCAmelCase   )

      return "".join(__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.process_text(text.upper()   )
      __UpperCamelCase       						= ''

      for i in range(0			,  len(__UpperCAmelCase   ) - self.break_key + 1			,  self.break_key   ):
       __UpperCamelCase       						= text[i : i + self.break_key]
       __UpperCamelCase       						= [self.replace_letters(__UpperCAmelCase   ) for char in batch]
       __UpperCamelCase       						= numpy.array([vec]   ).T
       __UpperCamelCase       						= self.modulus(self.encrypt_key.dot(__UpperCAmelCase   )   ).T.tolist()[
           0
       ]
       __UpperCamelCase       						= ''.join(
           self.replace_digits(__UpperCAmelCase   ) for num in batch_encrypted   )
       encrypted += encrypted_batch

      return encrypted





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= round(numpy.linalg.det(self.encrypt_key   )   )

      if det < 0:
       __UpperCamelCase       						= det % len(self.key_string   )
      __UpperCamelCase       						= None
      for i in range(len(self.key_string   )   ):
       if (det * i) % len(self.key_string   ) == 1:
        __UpperCamelCase       						= i
        break

      __UpperCamelCase       						= (
          det_inv
          * numpy.linalg.det(self.encrypt_key   )
          * numpy.linalg.inv(self.encrypt_key   )
      )

      return self.to_int(self.modulus(__UpperCAmelCase   )   )







     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.make_decrypt_key()
      __UpperCamelCase       						= self.process_text(text.upper()   )
      __UpperCamelCase       						= ''

      for i in range(0			,  len(__UpperCAmelCase   ) - self.break_key + 1			,  self.break_key   ):
       __UpperCamelCase       						= text[i : i + self.break_key]
       __UpperCamelCase       						= [self.replace_letters(__UpperCAmelCase   ) for char in batch]
       __UpperCamelCase       						= numpy.array([vec]   ).T
       __UpperCamelCase       						= self.modulus(decrypt_key.dot(__UpperCAmelCase   )   ).T.tolist()[0]
       __UpperCamelCase       						= ''.join(
           self.replace_digits(__UpperCAmelCase   ) for num in batch_decrypted   )
       decrypted += decrypted_batch

      return decrypted






def 							A		(       )   ->			None:
 __UpperCamelCase       						= int(input('Enter the order of the encryption key: '	)	)
 __UpperCamelCase       						= []

 print('Enter each row of the encryption key with space separated integers'	)
 for _ in range(snake_case	):
  __UpperCamelCase       						= [int(snake_case	) for x in input().split()]
  hill_matrix.append(snake_case	)

 __UpperCamelCase       						= HillCipher(numpy.array(snake_case	)	)

 print('Would you like to encrypt or decrypt some text? (1 or 2)'	)
 __UpperCamelCase       						= input('\n1. Encrypt\n2. Decrypt\n'	)
 if option == "1":
  __UpperCamelCase       						= input('What text would you like to encrypt?: '	)
  print('Your encrypted text is:'	)
  print(hc.encrypt(snake_case	)	)
 elif option == "2":
  __UpperCamelCase       						= input('What text would you like to decrypt?: '	)
  print('Your decrypted text is:'	)
  print(hc.decrypt(snake_case	)	)


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      main()





"""simple docstring"""

from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


UpperCamelCase			:       Optional[int]									=				logging.get_logger(__name__)

UpperCamelCase			:       int									=				{
    "EleutherAI/gpt-j-6B": "https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json",
    # See all GPT-J models at https://huggingface.co/models?filter=gpt_j
}

class __lowerCAmelCase	(   __SCREAMING_SNAKE_CASE    ):
     lowercase		     =		"gptj"
     lowercase		     =		{
         "max_position_embeddings": "n_positions",
         "hidden_size": "n_embd",
         "num_attention_heads": "n_head",
         "num_hidden_layers": "n_layer",
     }





     def __init__(			self			,  __UpperCAmelCase=5_0400			,  __UpperCAmelCase=2048			,  __UpperCAmelCase=4096			,  __UpperCAmelCase=28			,  __UpperCAmelCase=16			,  __UpperCAmelCase=64			,  __UpperCAmelCase=None			,  __UpperCAmelCase="gelu_new"			,  __UpperCAmelCase=0.0			,  __UpperCAmelCase=0.0			,  __UpperCAmelCase=0.0			,  __UpperCAmelCase=1E-5			,  __UpperCAmelCase=0.0_2			,  __UpperCAmelCase=True			,  __UpperCAmelCase=5_0256			,  __UpperCAmelCase=5_0256			,  __UpperCAmelCase=False			,  **__UpperCAmelCase			,  ):

      '''simple docstring'''




      __UpperCamelCase       						= vocab_size
      __UpperCamelCase       						= n_positions
      __UpperCamelCase       						= n_embd
      __UpperCamelCase       						= n_layer
      __UpperCamelCase       						= n_head
      __UpperCamelCase       						= n_inner
      __UpperCamelCase       						= rotary_dim
      __UpperCamelCase       						= activation_function
      __UpperCamelCase       						= resid_pdrop
      __UpperCamelCase       						= embd_pdrop
      __UpperCamelCase       						= attn_pdrop
      __UpperCamelCase       						= layer_norm_epsilon
      __UpperCamelCase       						= initializer_range
      __UpperCamelCase       						= use_cache

      __UpperCamelCase       						= bos_token_id
      __UpperCamelCase       						= eos_token_id

      super().__init__(
          bos_token_id=__UpperCAmelCase			,  eos_token_id=__UpperCAmelCase			,  tie_word_embeddings=__UpperCAmelCase			,  **__UpperCAmelCase   )


class __lowerCAmelCase	(   __SCREAMING_SNAKE_CASE    ):





     def __init__(			self			,  __UpperCAmelCase			,  __UpperCAmelCase = "default"			,  __UpperCAmelCase = None			,  __UpperCAmelCase = False			,  ):

      '''simple docstring'''




      super().__init__(__UpperCAmelCase			,  task=__UpperCAmelCase			,  patching_specs=__UpperCAmelCase			,  use_past=__UpperCAmelCase   )
      if not getattr(self._config			,  'pad_token_id'			,  __UpperCAmelCase   ):
       # TODO: how to do that better?
       __UpperCamelCase       						= 0





     @property
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= OrderedDict({'input_ids': {0: 'batch', 1: 'sequence'}}   )
      if self.use_past:
       self.fill_with_past_key_values_(__UpperCAmelCase			,  direction='inputs'   )
       __UpperCamelCase       						= {0: 'batch', 1: 'past_sequence + sequence'}
      else:
       __UpperCamelCase       						= {0: 'batch', 1: 'sequence'}

      return common_inputs





     @property
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      return self._config.n_layer





     @property
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      return self._config.n_head





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase = -1			,  __UpperCAmelCase = -1			,  __UpperCAmelCase = False			,  __UpperCAmelCase = None			,  ):

      '''simple docstring'''




      __UpperCamelCase       						= super(__UpperCAmelCase			,  self   ).generate_dummy_inputs(
          __UpperCAmelCase			,  batch_size=__UpperCAmelCase			,  seq_length=__UpperCAmelCase			,  is_pair=__UpperCAmelCase			,  framework=__UpperCAmelCase   )

      # We need to order the input in the way they appears in the forward()
      __UpperCamelCase       						= OrderedDict({'input_ids': common_inputs['input_ids']}   )

      # Need to add the past_keys
      if self.use_past:
       if not is_torch_available():
        raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'   )
       else:
        import torch

        __UpperCamelCase						,			__UpperCamelCase       						= common_inputs['input_ids'].shape
        # Not using the same length for past_key_values
        __UpperCamelCase       						= seqlen + 2
        __UpperCamelCase       						= (
            batch,
            self.num_attention_heads,
            past_key_values_length,
            self._config.hidden_size // self.num_attention_heads,
        )
        __UpperCamelCase       						= [
            (torch.zeros(__UpperCAmelCase   ), torch.zeros(__UpperCAmelCase   )) for _ in range(self.num_layers   )
        ]

      __UpperCamelCase       						= common_inputs['attention_mask']
      if self.use_past:
       __UpperCamelCase       						= ordered_inputs['attention_mask'].dtype
       __UpperCamelCase       						= torch.cat(
           [ordered_inputs['attention_mask'], torch.ones(__UpperCAmelCase			,  __UpperCAmelCase			,  dtype=__UpperCAmelCase   )]			,  dim=1   )

      return ordered_inputs







     @property
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      return 13



