
from __future__ import annotations

import math






def 				UpperCAmelCase_						(				__SCREAMING_SNAKE_CASE				):






	if 1 < number < 4:
		# 2 and 3 are primes
		return True
	elif number < 2 or number % 2 == 0 or number % 3 == 0:
		# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
		return False

	# All primes number are in format of 6k +/- 1
	for i in range(5					,				int(math.sqrt(UpperCamelCase__				) + 1				)					,				6				):
		if number % i == 0 or number % (i + 2) == 0:
			return False
	return True


UpperCAmelCase       =					[num for num in range(3, 10_0001, 2) if not is_prime(num)]






def 				UpperCAmelCase_						(				__SCREAMING_SNAKE_CASE				):






	if not isinstance(UpperCamelCase__					,				UpperCamelCase__				):
		raise ValueError('n must be an integer'				)
	if n <= 0:
		raise ValueError('n must be >= 0'				)

	lowercase	    =       []
	for num in range(len(UpperCamelCase__				)				):
		lowercase	    =       0
		while 2 * i * i <= odd_composites[num]:
			lowercase	    =       odd_composites[num] - 2 * i * i
			if is_prime(UpperCamelCase__				):
				break
			i += 1
		else:
			list_nums.append(odd_composites[num]				)
			if len(UpperCamelCase__				) == n:
				return list_nums

	return []






def 				UpperCAmelCase_						(				):
	return compute_nums(1				)[0]


if __name__ == "__main__":
	print(F"""{solution() = }""")




import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()





def    __lowerCamelCase      (					UpperCamelCase__  ,				UpperCamelCase__  ,				UpperCamelCase__ ):







							'''simple docstring'''






							snake_case_     							=       BertConfig.from_json_file(UpperCamelCase__ )
							print(F'''Building PyTorch model from configuration: {config}''' )
							snake_case_     							=       BertForPreTraining(UpperCamelCase__ )

							# Load weights from tf checkpoint
							load_tf_weights_in_bert(UpperCamelCase__  ,				UpperCamelCase__  ,				UpperCamelCase__ )

							# Save pytorch-model
							print(F'''Save PyTorch model to {pytorch_dump_path}''' )
							torch.save(model.state_dict()  ,				UpperCamelCase__ )


if __name__ == "__main__":
					_UpperCAmelCase						:  Union[str, Any]									=			argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
					)
					parser.add_argument(
					    """--bert_config_file""",
					    default=None,
					    type=str,
					    required=True,
					    help=(
					        """The config json file corresponding to the pre-trained BERT model. \n"""
					        """This specifies the model architecture."""
					    ),
					)
					parser.add_argument(
					    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
					)
					_UpperCAmelCase						:  Any									=			parser.parse_args()
					convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)




