


class       lowercase_					:





				def __init__(				self       ,  lowercase_       ,  lowercase_=None       ,  lowercase_=None)  -> Tuple:
											a__      =data
											a__      =previous
											a__      =next_node





				def __str__(				self)  -> str:
											return F"""{self.data}"""





				def 						__UpperCamelCase    (				self)  -> int:
											return self.data





				def 						__UpperCamelCase    (				self)  -> Any:
											return self.next





				def 						__UpperCamelCase    (				self)  -> int:
											return self.previous







class       lowercase_					:





				def __init__(				self       ,  lowercase_)  -> str:
											a__      =head





				def __iter__(				self)  -> Union[str, Any]:
											return self





				def 						__UpperCamelCase    (				self)  -> str:
											if not self.current:
																		raise StopIteration
											else:
																		a__      =self.current.get_data()
																		a__      =self.current.get_next()
																		return value







class       lowercase_					:





				def __init__(				self)  -> Union[str, Any]:
											a__      =None  # First node in list
											a__      =None  # Last node in list





				def __str__(				self)  -> Dict:
											a__      =self.head
											a__      =[]
											while current is not None:
																		nodes.append(current.get_data())
																		a__      =current.get_next()
											return " ".join(str(lowercase_) for node in nodes)





				def __contains__(				self       ,  lowercase_)  -> Any:
											a__      =self.head
											while current:
																		if current.get_data() == value:
																									return True
																		a__      =current.get_next()
											return False





				def __iter__(				self)  -> Any:
											return LinkedListIterator(self.head)





				def 						__UpperCamelCase    (				self)  -> List[str]:
											if self.head:
																		return self.head.get_data()
											return None





				def 						__UpperCamelCase    (				self)  -> Optional[int]:
											if self.tail:
																		return self.tail.get_data()
											return None





				def 						__UpperCamelCase    (				self       ,  lowercase_)  -> None:
											if self.head is None:
																		a__      =node
																		a__      =node
											else:
																		self.insert_before_node(self.head       ,  lowercase_)





				def 						__UpperCamelCase    (				self       ,  lowercase_)  -> None:
											if self.head is None:
																		self.set_head(lowercase_)
											else:
																		self.insert_after_node(self.tail       ,  lowercase_)





				def 						__UpperCamelCase    (				self       ,  lowercase_)  -> None:
											a__      =Node(lowercase_)
											if self.head is None:
																		self.set_head(lowercase_)
											else:
																		self.set_tail(lowercase_)





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_)  -> None:
											a__      =node
											a__      =node.previous

											if node.get_previous() is None:
																		a__      =node_to_insert
											else:
																		a__      =node_to_insert

											a__      =node_to_insert





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_)  -> None:
											a__      =node
											a__      =node.next

											if node.get_next() is None:
																		a__      =node_to_insert
											else:
																		a__      =node_to_insert

											a__      =node_to_insert





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_)  -> None:
											a__      =1
											a__      =Node(lowercase_)
											a__      =self.head
											while node:
																		if current_position == position:
																									self.insert_before_node(lowercase_       ,  lowercase_)
																									return
																		current_position += 1
																		a__      =node.next
											self.insert_after_node(self.tail       ,  lowercase_)





				def 						__UpperCamelCase    (				self       ,  lowercase_)  -> Node:
											a__      =self.head
											while node:
																		if node.get_data() == item:
																									return node
																		a__      =node.get_next()
											raise Exception('Node not found')





				def 						__UpperCamelCase    (				self       ,  lowercase_)  -> Dict:
											if (node := self.get_node(lowercase_)) is not None:
																		if node == self.head:
																									a__      =self.head.get_next()

																		if node == self.tail:
																									a__      =self.tail.get_previous()

																		self.remove_node_pointers(lowercase_)





				@staticmethod
				def 						__UpperCamelCase    (				lowercase_)  -> None:
											if node.get_next():
																		a__      =node.previous

											if node.get_previous():
																		a__      =node.next

											a__      =None
											a__      =None





				def 						__UpperCamelCase    (				self)  -> Any:
											return self.head is None







def   _lowercase(					):
							pass


if __name__ == "__main__":
	import doctest

	doctest.testmod()



"""simple docstring"""

import os
import time

import numpy as np
import onnxruntime as ort


SCREAMING_SNAKE_CASE_            =    '''1'''
SCREAMING_SNAKE_CASE_            =    '''0'''
SCREAMING_SNAKE_CASE_            =    '''1'''

SCREAMING_SNAKE_CASE_            =    ort.SessionOptions()
SCREAMING_SNAKE_CASE_            =    ort.GraphOptimizationLevel.ORT_DISABLE_ALL
print('''Create inference session...''')
SCREAMING_SNAKE_CASE_            =    ['''TensorrtExecutionProvider''', '''CUDAExecutionProvider''']
SCREAMING_SNAKE_CASE_            =    ort.InferenceSession('''model.onnx''', sess_options=sess_opt, providers=execution_provider)
SCREAMING_SNAKE_CASE_            =    ort.RunOptions()

SCREAMING_SNAKE_CASE_            =    128
SCREAMING_SNAKE_CASE_            =    1
SCREAMING_SNAKE_CASE_            =    np.ones((batch, sequence), dtype=np.intaa)
SCREAMING_SNAKE_CASE_            =    np.ones((batch, sequence), dtype=np.intaa)
SCREAMING_SNAKE_CASE_            =    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...''')
SCREAMING_SNAKE_CASE_            =    time.time()
SCREAMING_SNAKE_CASE_            =    2000
SCREAMING_SNAKE_CASE_            =    {}
for iter in range(max_iters):
   SCREAMING_SNAKE_CASE_            =    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) * 1000 / max_iters))



