


from __future__ import annotations

from collections.abc import Generator







def        SCREAMING_SNAKE_CASE_						(			)	->		Generator[int, None, None]:

       """simple docstring"""

       a_					:		dict[int, int]							=  {}
       a_					:		Tuple							=  2
       while True:
              a_					:		Optional[int]							=  factor_map.pop(__A  ,    __A				)
              if factor:
                     a_					:		Union[str, Any]							=  factor + prime
                     while x in factor_map:
                            x += factor
                     a_					:		List[Any]							=  factor
              else:
                     a_					:		Tuple							=  prime
                     yield prime
              prime += 1







def        SCREAMING_SNAKE_CASE_						(			__A :			float = 1e1_0				)	->		int:

       """simple docstring"""

       a_					:		List[str]							=  sieve()

       a_					:		Any							=  1
       while True:
              a_					:		List[Any]							=  next(__A				)
              if (2 * prime * n) > limit:
                     return n
              # Ignore the next prime as the reminder will be 2.
              next(__A				)
              n += 2


if __name__ == "__main__":
   print(solution())




"""simple docstring"""



import os
import time

import numpy as np
import onnxruntime as ort


UpperCAmelCase__          = '1'
UpperCAmelCase__          = '0'
UpperCAmelCase__          = '1'

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

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



