


import argparse
import struct
import unittest







class       lowerCamelCase__   :





     def __init__(self		,     UpperCAmelCase       )     ->   None:
      _lowercase							      =data

      # Initialize hash values
      _lowercase							      =[
          0X6_a_0_9_e_6_6_7,
          0Xb_b_6_7_a_e_8_5,
          0X3_c_6_e_f_3_7_2,
          0Xa_5_4_f_f_5_3_a,
          0X5_1_0_e_5_2_7_f,
          0X9_b_0_5_6_8_8_c,
          0X1_f_8_3_d_9_a_b,
          0X5_b_e_0_c_d_1_9,
      ]

      # Initialize round constants
      _lowercase							      =[
          0X4_2_8_a_2_f_9_8,
          0X7_1_3_7_4_4_9_1,
          0Xb_5_c_0_f_b_c_f,
          0Xe_9_b_5_d_b_a_5,
          0X3_9_5_6_c_2_5_b,
          0X5_9_f_1_1_1_f_1,
          0X9_2_3_f_8_2_a_4,
          0Xa_b_1_c_5_e_d_5,
          0Xd_8_0_7_a_a_9_8,
          0X1_2_8_3_5_b_0_1,
          0X2_4_3_1_8_5_b_e,
          0X5_5_0_c_7_d_c_3,
          0X7_2_b_e_5_d_7_4,
          0X8_0_d_e_b_1_f_e,
          0X9_b_d_c_0_6_a_7,
          0Xc_1_9_b_f_1_7_4,
          0Xe_4_9_b_6_9_c_1,
          0Xe_f_b_e_4_7_8_6,
          0X0_f_c_1_9_d_c_6,
          0X2_4_0_c_a_1_c_c,
          0X2_d_e_9_2_c_6_f,
          0X4_a_7_4_8_4_a_a,
          0X5_c_b_0_a_9_d_c,
          0X7_6_f_9_8_8_d_a,
          0X9_8_3_e_5_1_5_2,
          0Xa_8_3_1_c_6_6_d,
          0Xb_0_0_3_2_7_c_8,
          0Xb_f_5_9_7_f_c_7,
          0Xc_6_e_0_0_b_f_3,
          0Xd_5_a_7_9_1_4_7,
          0X0_6_c_a_6_3_5_1,
          0X1_4_2_9_2_9_6_7,
          0X2_7_b_7_0_a_8_5,
          0X2_e_1_b_2_1_3_8,
          0X4_d_2_c_6_d_f_c,
          0X5_3_3_8_0_d_1_3,
          0X6_5_0_a_7_3_5_4,
          0X7_6_6_a_0_a_b_b,
          0X8_1_c_2_c_9_2_e,
          0X9_2_7_2_2_c_8_5,
          0Xa_2_b_f_e_8_a_1,
          0Xa_8_1_a_6_6_4_b,
          0Xc_2_4_b_8_b_7_0,
          0Xc_7_6_c_5_1_a_3,
          0Xd_1_9_2_e_8_1_9,
          0Xd_6_9_9_0_6_2_4,
          0Xf_4_0_e_3_5_8_5,
          0X1_0_6_a_a_0_7_0,
          0X1_9_a_4_c_1_1_6,
          0X1_e_3_7_6_c_0_8,
          0X2_7_4_8_7_7_4_c,
          0X3_4_b_0_b_c_b_5,
          0X3_9_1_c_0_c_b_3,
          0X4_e_d_8_a_a_4_a,
          0X5_b_9_c_c_a_4_f,
          0X6_8_2_e_6_f_f_3,
          0X7_4_8_f_8_2_e_e,
          0X7_8_a_5_6_3_6_f,
          0X8_4_c_8_7_8_1_4,
          0X8_c_c_7_0_2_0_8,
          0X9_0_b_e_f_f_f_a,
          0Xa_4_5_0_6_c_e_b,
          0Xb_e_f_9_a_3_f_7,
          0Xc_6_7_1_7_8_f_2,
      ]

      _lowercase							      =self.preprocessing(self.data       )
      self.final_hash()





     @staticmethod
     def      __A					(UpperCAmelCase       )     ->   bytes:
      _lowercase							      =B'''\x80''' + (B'''\x00''' * (6_3 - (len(UpperCAmelCase       ) + 8) % 6_4))
      _lowercase							      =struct.pack('''>Q'''		,     (len(UpperCAmelCase       ) * 8)       )
      return data + padding + big_endian_integer





     def      __A					(self       )     ->   None:
      # Convert into blocks of 64 bytes
      _lowercase							      =[
          self.preprocessed_data[x : x + 6_4]
          for x in range(0		,     len(self.preprocessed_data       )		,     6_4       )
      ]

      for block in self.blocks:
       # Convert the given block into a list of 4 byte integers
       _lowercase							      =list(struct.unpack('''>16L'''		,     UpperCAmelCase       )       )
       # add 48 0-ed integers
       words += [0] * 4_8

       _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase							      =self.hashes

       for index in range(0		,     6_4       ):
        if index > 1_5:
         # modify the zero-ed indexes at the end of the array
         _lowercase							      =(
             self.ror(words[index - 1_5]		,     7       )
             ^ self.ror(words[index - 1_5]		,     1_8       )
             ^ (words[index - 1_5] >> 3)
         )
         _lowercase							      =(
             self.ror(words[index - 2]		,     1_7       )
             ^ self.ror(words[index - 2]		,     1_9       )
             ^ (words[index - 2] >> 1_0)
         )

         _lowercase							      =(
             words[index - 1_6] + sa + words[index - 7] + sa
         ) % 0X1_0_0_0_0_0_0_0_0

        # Compression
        _lowercase							      =self.ror(UpperCAmelCase		,     6       ) ^ self.ror(UpperCAmelCase		,     1_1       ) ^ self.ror(UpperCAmelCase		,     2_5       )
        _lowercase							      =(e & f) ^ ((~e & 0Xf_f_f_f_f_f_f_f) & g)
        _lowercase							      =(
            h + sa + ch + self.round_constants[index] + words[index]
        ) % 0X1_0_0_0_0_0_0_0_0
        _lowercase							      =self.ror(UpperCAmelCase		,     2       ) ^ self.ror(UpperCAmelCase		,     1_3       ) ^ self.ror(UpperCAmelCase		,     2_2       )
        _lowercase							      =(a & b) ^ (a & c) ^ (b & c)
        _lowercase							      =(sa + maj) % 0X1_0_0_0_0_0_0_0_0

        _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase      ,    _lowercase							      =(
            g,
            f,
            e,
            ((d + tempa) % 0X1_0_0_0_0_0_0_0_0),
            c,
            b,
            a,
            ((tempa + tempa) % 0X1_0_0_0_0_0_0_0_0),
        )

       _lowercase							      =[a, b, c, d, e, f, g, h]

       # Modify final values
       _lowercase							      =[
           ((element + mutated_hash_values[index]) % 0X1_0_0_0_0_0_0_0_0)
           for index, element in enumerate(self.hashes       )
       ]

      _lowercase							      =''''''.join([hex(UpperCAmelCase       )[2:].zfill(8       ) for value in self.hashes]       )





     def      __A					(self		,     UpperCAmelCase		,     UpperCAmelCase       )     ->   int:
      return 0Xf_f_f_f_f_f_f_f & (value << (3_2 - rotations)) | (value >> rotations)







class       lowerCamelCase__   (       unittest.TestCase):





     def      __A					(self       )     ->   None:
      import hashlib

      _lowercase							      =bytes('''Test String'''		,     '''utf-8'''       )
      self.assertEqual(SHAaaa(UpperCAmelCase       ).hash		,     hashlib.shaaaa(UpperCAmelCase       ).hexdigest()       )



def 				UpperCAmelCase_					(							)     ->			None:







 """simple docstring"""


 import doctest

 doctest.testmod()

 _lowercase							      =argparse.ArgumentParser()
 parser.add_argument(
     '''-s'''     ,						'''--string'''     ,						dest='''input_string'''     ,						default='''Hello World!! Welcome to Cryptography'''     ,						help='''Hash the string'''     ,						)
 parser.add_argument(
     '''-f'''     ,						'''--file'''     ,						dest='''input_file'''     ,						help='''Hash contents of a file'''						)

 _lowercase							      =parser.parse_args()

 _lowercase							      =args.input_string

 # hash input should be a bytestring
 if args.input_file:
  with open(args.input_file     ,						'''rb'''						) as f:
   _lowercase							      =f.read()
 else:
  _lowercase							      =bytes(__snake_case     ,						'''utf-8'''						)

 print(SHAaaa(__snake_case						).hash						)


if __name__ == "__main__":
  main()





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase__   	=							{
    '''configuration_xlm''': ['''XLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XLMConfig''', '''XLMOnnxConfig'''],
    '''tokenization_xlm''': ['''XLMTokenizer'''],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__   	=							[
      '''XLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''XLMForMultipleChoice''',
      '''XLMForQuestionAnswering''',
      '''XLMForQuestionAnsweringSimple''',
      '''XLMForSequenceClassification''',
      '''XLMForTokenClassification''',
      '''XLMModel''',
      '''XLMPreTrainedModel''',
      '''XLMWithLMHeadModel''',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__   	=							[
      '''TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''TFXLMForMultipleChoice''',
      '''TFXLMForQuestionAnsweringSimple''',
      '''TFXLMForSequenceClassification''',
      '''TFXLMForTokenClassification''',
      '''TFXLMMainLayer''',
      '''TFXLMModel''',
      '''TFXLMPreTrainedModel''',
      '''TFXLMWithLMHeadModel''',
  ]


if TYPE_CHECKING:
  from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
  from .tokenization_xlm import XLMTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_xlm import (
        XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        XLMForMultipleChoice,
        XLMForQuestionAnswering,
        XLMForQuestionAnsweringSimple,
        XLMForSequenceClassification,
        XLMForTokenClassification,
        XLMModel,
        XLMPreTrainedModel,
        XLMWithLMHeadModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_xlm import (
        TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFXLMForMultipleChoice,
        TFXLMForQuestionAnsweringSimple,
        TFXLMForSequenceClassification,
        TFXLMForTokenClassification,
        TFXLMMainLayer,
        TFXLMModel,
        TFXLMPreTrainedModel,
        TFXLMWithLMHeadModel,
    )

else:
  import sys

  UpperCAmelCase__   	=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

