



'''simple docstring'''




import os
import time

import numpy as np
import onnxruntime as ort


a   :			List[Any]					  =    """1"""
a   :			Dict					  =    """0"""
a   :			List[str]					  =    """1"""

a   :			Optional[int]					  =    ort.SessionOptions()
a   :			Optional[Any]					  =    ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print("""Create inference session...""")
a   :			Union[str, Any]					  =    ["""TensorrtExecutionProvider""", """CUDAExecutionProvider"""]
a   :			List[str]					  =    ort.InferenceSession("""model.onnx""", sess_options=sess_opt, providers=execution_provider)
a   :			Optional[Any]					  =    ort.RunOptions()

a   :			Tuple					  =    1_2_8
a   :			List[Any]					  =    1
a   :			Union[str, Any]					  =    np.ones((batch, sequence), dtype=np.intaa)
a   :			Any					  =    np.ones((batch, sequence), dtype=np.intaa)
a   :			List[Any]					  =    np.ones((batch, sequence), dtype=np.intaa)

print("""Warm up phase...""")
sess.run(
    None,
    {
        sess.get_inputs()[0].name: input_ids,
        sess.get_inputs()[1].name: attention_mask,
        sess.get_inputs()[2].name: token_type_ids,
    },
    run_options=run_opt,
)

print("""Start inference...""")
a   :			str					  =    time.time()
a   :			int					  =    2_0_0_0
a   :			Union[str, Any]					  =    {}
for iter in range(max_iters):
							a   :			int					  =    sess.run(
							    None,
							    {
							        sess.get_inputs()[0].name: input_ids,
							        sess.get_inputs()[1].name: attention_mask,
							        sess.get_inputs()[2].name: token_type_ids,
							    },
							    run_options=run_opt,
							)
print("""Average Inference Time = {:.3f} ms""".format((time.time() - start_time) * 1_0_0_0 / max_iters))






'''simple docstring'''




def       __lowerCamelCase  (					_lowercase	,				_lowercase		)      ->			int:
							if b == 0:
														return 1
							if (b % 2) == 0:
														return actual_power(_lowercase	,				int(b / 2		)		) * actual_power(_lowercase	,				int(b / 2		)		)
							else:
														return a * actual_power(_lowercase	,				int(b / 2		)		) * actual_power(_lowercase	,				int(b / 2		)		)



def       __lowerCamelCase  (					_lowercase	,				_lowercase		)      ->			float:
							if b < 0:
														return 1 / actual_power(_lowercase	,				_lowercase		)
							return actual_power(_lowercase	,				_lowercase		)


if __name__ == "__main__":
							print(power(-2, -3))

