






def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     str:
     return "".join([hex(__lowerCAmelCase      )[2:].zfill(2      ).upper() for byte in list(__lowerCAmelCase      )]      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     bytes:
     # Check data validity, following RFC3548
     # https://www.ietf.org/rfc/rfc3548.txt
     if (len(__lowerCAmelCase      ) % 2) != 0:
          raise ValueError(
              "Base16 encoded data is invalid:\nData does not have an even number of hex digits."      )
     # Check the character set - the standard base16 alphabet
     # is uppercase according to RFC3548 section 6
     if not set(__lowerCAmelCase      ) <= set("0123456789ABCDEF"      ):
          raise ValueError(
              "Base16 encoded data is invalid:\nData is not uppercase hex or it contains invalid characters."      )
     # For every two hexadecimal digits (= a byte), turn it into an integer.
     # Then, string the result together into bytes, and return it.
     return bytes(int(data[i] + data[i + 1] ,   16      ) for i in range(0 ,   len(__lowerCAmelCase      ) ,   2      )      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()







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







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )			->     List[str]:
     UpperCamelCase__      :       Optional[int]	    =  a + h
     while x < (b - h):
          yield x
          UpperCamelCase__      :       Union[str, Any]	    =  x + h







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Any:  # enter your function here
     UpperCamelCase__      :       Dict	    =  (x - 0) * (x - 0)
     return y







def 		SCREAMING_SNAKE_CASE							( )			->     Dict:
     UpperCamelCase__      :       List[Any]	    =  0.0  # Lower bound of integration
     UpperCamelCase__      :       Tuple	    =  1.0  # Upper bound of integration
     UpperCamelCase__      :       Any	    =  1_0.0  # define number of steps or resolution
     UpperCamelCase__      :       List[str]	    =  [a, b]  # define boundary of integration
     UpperCamelCase__      :       Any	    =  method_a(__lowerCAmelCase ,   __lowerCAmelCase      )
     print(f'y = {y}'      )


if __name__ == "__main__":
 main()