





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase    : Any    	=  {"""configuration_opt""": ["""OPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OPTConfig"""]}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase    : Dict    	=  [
           """OPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """OPTForCausalLM""",
           """OPTModel""",
           """OPTPreTrainedModel""",
           """OPTForSequenceClassification""",
           """OPTForQuestionAnswering""",
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase    : Optional[int]    	=  ["""TFOPTForCausalLM""", """TFOPTModel""", """TFOPTPreTrainedModel"""]

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase    : List[Any]    	=  [
           """FlaxOPTForCausalLM""",
           """FlaxOPTModel""",
           """FlaxOPTPreTrainedModel""",
       ]


if TYPE_CHECKING:
       from .configuration_opt import OPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPTConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_opt import (
                  OPT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  OPTForCausalLM,
                  OPTForQuestionAnswering,
                  OPTForSequenceClassification,
                  OPTModel,
                  OPTPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_opt import TFOPTForCausalLM, TFOPTModel, TFOPTPreTrainedModel

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_opt import FlaxOPTForCausalLM, FlaxOPTModel, FlaxOPTPreTrainedModel

else:
       import sys

       lowercase    : Optional[int]    	=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)













from __future__ import annotations

import math


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):

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


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


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

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

       return []


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


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






