

import argparse
import struct
import unittest


class 			A						:







    """simple docstring"""





    def __init__(				self			:	Any,lowercase_			:	bytes		)->   None:





        '''simple docstring'''







        A__   				=       data

        # Initialize hash values
        A__   				=       [
            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
        A__   				=       [
            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,
        ]

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


    @staticmethod
    def 						snake_case__					(				lowercase_			:	bytes		)->   bytes:





        '''simple docstring'''







        A__   				=       B'\x80' + (B'\x00' * (6_3 - (len(lowercase_		) + 8) % 6_4))
        A__   				=       struct.pack('>Q',(len(lowercase_		) * 8)		)
        return data + padding + big_endian_integer


    def 						snake_case__					(				self			:	Optional[int]		)->   None:





        '''simple docstring'''







        A__   				=       [
            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
            A__   				=       list(struct.unpack('>16L',lowercase_		)		)
            # add 48 0-ed integers
            words += [0] * 4_8

            A__				,						A__				,						A__				,						A__				,						A__				,						A__				,						A__				,						A__   				=       self.hashes

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

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

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

                A__				,						A__				,						A__				,						A__				,						A__				,						A__				,						A__				,						A__   				=       (
                    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),
                )

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

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

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


    def 						snake_case__					(				self			:	Union[str, Any],lowercase_			:	int,lowercase_			:	int		)->   int:





        '''simple docstring'''







        return 0Xf_f_f_f_f_f_f_f & (value << (3_2 - rotations)) | (value >> rotations)




class 			A						(							unittest.TestCase			):







    """simple docstring"""





    def 						snake_case__					(				self			:	List[str]		)->   None:





        '''simple docstring'''







        import hashlib

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




def 						_snake_case(   )							->				None:





    '''simple docstring'''






    import doctest

    doctest.testmod()

    A__   				=       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'				)

    A__   				=       parser.parse_args()

    A__   				=       args.input_string

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

    print(SHAaaa(SCREAMING_SNAKE_CASE__				).hash				)


if __name__ == "__main__":
     main()




from collections.abc import Sequence
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     Sequence[int] | None = None				)							->				int:





    '''simple docstring'''






    if nums is None or not nums:
        raise ValueError('Input sequence should not be empty'				)

    A__   				=       nums[0]
    for i in range(1   ,      len(SCREAMING_SNAKE_CASE__				)				):
        A__   				=       nums[i]
        A__   				=       max(SCREAMING_SNAKE_CASE__   ,      ans + num   ,      SCREAMING_SNAKE_CASE__				)

    return ans


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # Try on a sample input from the user
     lowercase_			=  int(input("Enter number of elements : ").strip())
     lowercase_			=  list(map(int, input("\nEnter the numbers : ").strip().split()))[:n]
     print(max_subsequence_sum(array))

