






from __future__ import annotations

import math

def      _lowerCamelCase	(						__A    :							int )      ->					bool:

    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(__A ) + 1 )		,		6 ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True


SCREAMING_SNAKE_CASE 							=						[num for num in range(3, 100001, 2) if not is_prime(num)]

def      _lowerCamelCase	(						__A    :							int )      ->					list[int]:
    if not isinstance(__A		,		__A ):
        raise ValueError('''n must be an integer''' )
    if n <= 0:
        raise ValueError('''n must be >= 0''' )

    _UpperCAmelCase				:      Tuple			  =				[]
    for num in range(len(__A ) ):
        _UpperCAmelCase				:      List[str]			  =				0
        while 2 * i * i <= odd_composites[num]:
            _UpperCAmelCase				:      Dict			  =				odd_composites[num] - 2 * i * i
            if is_prime(__A ):
                break
            i += 1
        else:
            list_nums.append(odd_composites[num] )
            if len(__A ) == n:
                return list_nums

    return []

def      _lowerCamelCase	(						)      ->					int:
    return compute_nums(1 )[0]


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










import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()

def      _lowerCamelCase	(						__A    :							int		,		__A    :							Optional[Any]		,		__A    :							int )      ->					int:
    # Initialise PyTorch model
    _UpperCAmelCase				:      Dict			  =				RemBertConfig.from_json_file(__A )
    print('''Building PyTorch model from configuration: {}'''.format(str(__A ) ) )
    _UpperCAmelCase				:      int			  =				RemBertModel(__A )

    # Load weights from tf checkpoint
    load_tf_weights_in_rembert(__A		,		__A		,		__A )

    # Save pytorch-model
    print('''Save PyTorch model to {}'''.format(__A ) )
    torch.save(model.state_dict()		,		__A )


if __name__ == "__main__":
  SCREAMING_SNAKE_CASE 							=						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(
      '--rembert_config_file',
      default=None,
      type=str,
      required=True,
      help=(
          'The config json file corresponding to the pre-trained RemBERT 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.'
  )
  SCREAMING_SNAKE_CASE 							=						parser.parse_args()
  convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)




