





import random







class       __A							:




      """simple docstring"""







      @staticmethod
      def 					__snake_case      (		a__):



             """simple docstring"""





             _lowerCamelCase				:  str						=		[ord(a__) for i in text]
             _lowerCamelCase				:  List[Any]						=		[]
             _lowerCamelCase				:  str						=		[]
             for i in plain:
                    _lowerCamelCase				:  Union[str, Any]						=		random.randint(1   ,				300)
                    _lowerCamelCase				:  Optional[int]						=		(i + k) * k
                    cipher.append(a__)
                    key.append(a__)
             return cipher, key



      @staticmethod
      def 					__snake_case      (		a__   ,				a__):



             """simple docstring"""





             _lowerCamelCase				:  int						=		[]
             for i in range(len(a__)):
                    _lowerCamelCase				:  Optional[Any]						=		int((cipher[i] - (key[i]) ** 2) / key[i])
                    plain.append(chr(a__))
             return "".join(a__)


if __name__ == "__main__":
       _lowerCamelCase							,						_lowerCamelCase      							=   Onepad().encrypt('Hello')
       print(c, k)
       print(Onepad().decrypt(c, k))








def  __UpperCAmelCase(   lowercase_			,     lowercase_   ):
       # "extended trapezoidal rule"
       # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
       _lowerCamelCase				:  int						=		(boundary[1] - boundary[0]) / steps
       _lowerCamelCase				:  Any						=		boundary[0]
       _lowerCamelCase				:  Tuple						=		boundary[1]
       _lowerCamelCase				:  Optional[Any]						=		make_points(lowercase_			,     lowercase_			,     lowercase_   )
       _lowerCamelCase				:  Dict						=		0.0
       y += (h / 2.0) * f(lowercase_   )
       for i in x_i:
              # print(i)
              y += h * f(lowercase_   )
       y += (h / 2.0) * f(lowercase_   )
       return y




def  __UpperCAmelCase(   lowercase_			,     lowercase_			,     lowercase_   ):
       _lowerCamelCase				:  Dict						=		a + h
       while x < (b - h):
              yield x
              _lowerCamelCase				:  Dict						=		x + h




def  __UpperCAmelCase(   lowercase_   ):  # enter your function here
       _lowerCamelCase				:  List[str]						=		(x - 0) * (x - 0)
       return y




def  __UpperCAmelCase(   ):
       _lowerCamelCase				:  List[Any]						=		0.0  # Lower bound of integration
       _lowerCamelCase				:  Union[str, Any]						=		1.0  # Upper bound of integration
       _lowerCamelCase				:  Dict						=		1_0.0  # define number of steps or resolution
       _lowerCamelCase				:  Optional[int]						=		[a, b]  # define boundary of integration
       _lowerCamelCase				:  str						=		method_a(lowercase_			,     lowercase_   )
       print(F"""y = {y}"""   )


if __name__ == "__main__":
       main()

