code: 
  
  import argparse
  
  from transformers import CanineConfig, CanineModel, CanineTokenizer, load_tf_weights_in_canine
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	# Initialize PyTorch model
  	UpperCAmelCase__:  Dict		       =   CanineConfig()
  	UpperCAmelCase__:  Union[str, Any]		       =   CanineModel(SCREAMING_SNAKE_CASE			)
  	model.eval()
  
  	print(f"Building PyTorch model from configuration: {config}"			)
  
  	# Load weights from tf checkpoint
  	load_tf_weights_in_canine(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)
  
  	# Save pytorch-model (weights and configuration)
  	print(f"Save PyTorch model to {pytorch_dump_path}"			)
  	model.save_pretrained(SCREAMING_SNAKE_CASE			)
  
  	# Save tokenizer files
  	UpperCAmelCase__:  Any		       =   CanineTokenizer()
  	print(f"Save tokenizer files to {pytorch_dump_path}"			)
  	tokenizer.save_pretrained(SCREAMING_SNAKE_CASE			)
  
  
  if __name__ == "__main__":
  					_lowerCAmelCase     :			List[str]    =argparse.ArgumentParser()
  					# Required parameters
  					parser.add_argument(
  					    """--tf_checkpoint_path""",
  					    default=None,
  					    type=str,
  					    required=True,
  					    help="""Path to the TensorFlow checkpoint. Should end with model.ckpt""",
  					)
  					parser.add_argument(
  					    """--pytorch_dump_path""",
  					    default=None,
  					    type=str,
  					    required=True,
  					    help="""Path to a folder where the PyTorch model will be placed.""",
  					)
  					_lowerCAmelCase     :			int    =parser.parse_args()
  					convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.pytorch_dump_path)
style_context: 
  
  from __future__ import annotations
  
  from collections import Counter
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Optional[Any]		       =   [True] * n
  	UpperCAmelCase__:  Any		       =   False
  	UpperCAmelCase__:  Tuple		       =   False
  	UpperCAmelCase__:  Optional[Any]		       =   True
  
  	for i in range(3  ,int(n**0.5 + 1			)  ,2			):
  		UpperCAmelCase__:  Any		       =   i * 2
  		while index < n:
  			UpperCAmelCase__:  Optional[int]		       =   False
  			UpperCAmelCase__:  Tuple		       =   index + i
  
  	UpperCAmelCase__:  int		       =   [2]
  
  	for i in range(3  ,SCREAMING_SNAKE_CASE  ,2			):
  		if is_prime[i]:
  			primes.append(SCREAMING_SNAKE_CASE			)
  
  	return primes
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  List[Any]		       =   str(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Tuple		       =   []
  	UpperCAmelCase__:  Optional[int]		       =   ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
  
  	for duplicate in Counter(SCREAMING_SNAKE_CASE			) - Counter(set(SCREAMING_SNAKE_CASE			)			):
  		UpperCAmelCase__:  Optional[Any]		       =   [int(number_str.replace(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)			) for digit in digits]
  		replacements.append(SCREAMING_SNAKE_CASE			)
  
  	return replacements
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE = 8			):
  	UpperCAmelCase__:  Union[str, Any]		       =   set()
  
  	# Filter primes with less than 3 replaceable digits
  	UpperCAmelCase__:  Optional[Any]		       =   {
  	    x for x in set(prime_sieve(1_0_0_0_0_0_0			)			) if len(str(SCREAMING_SNAKE_CASE			)			) - len(set(str(SCREAMING_SNAKE_CASE			)			)			) >= 3
  	}
  
  	for prime in primes:
  		if prime in numbers_checked:
  			continue
  
  		UpperCAmelCase__:  Optional[int]		       =   digit_replacements(SCREAMING_SNAKE_CASE			)
  
  		for family in replacements:
  			numbers_checked.update(SCREAMING_SNAKE_CASE			)
  			UpperCAmelCase__:  Dict		       =   primes.intersection(SCREAMING_SNAKE_CASE			)
  
  			if len(SCREAMING_SNAKE_CASE			) != family_length:
  				continue
  
  			return min(SCREAMING_SNAKE_CASE			)
  
  	return -1
  
  
  if __name__ == "__main__":
  					print(solution())