





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


_UpperCAmelCase				:       Optional[Any]	   =				{
    """configuration_layoutlmv2""": ["""LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LayoutLMv2Config"""],
    """processing_layoutlmv2""": ["""LayoutLMv2Processor"""],
    """tokenization_layoutlmv2""": ["""LayoutLMv2Tokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase				:       List[str]	   =				["""LayoutLMv2TokenizerFast"""]

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase				:       Union[str, Any]	   =				["""LayoutLMv2FeatureExtractor"""]
    _UpperCAmelCase				:       Any	   =				["""LayoutLMv2ImageProcessor"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase				:       Any	   =				[
        """LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """LayoutLMv2ForQuestionAnswering""",
        """LayoutLMv2ForSequenceClassification""",
        """LayoutLMv2ForTokenClassification""",
        """LayoutLMv2Layer""",
        """LayoutLMv2Model""",
        """LayoutLMv2PreTrainedModel""",
    ]

if TYPE_CHECKING:
    from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
    from .processing_layoutlmva import LayoutLMvaProcessor
    from .tokenization_layoutlmva import LayoutLMvaTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_layoutlmva import (
            LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
            LayoutLMvaForQuestionAnswering,
            LayoutLMvaForSequenceClassification,
            LayoutLMvaForTokenClassification,
            LayoutLMvaLayer,
            LayoutLMvaModel,
            LayoutLMvaPreTrainedModel,
        )
else:
    import sys

    _UpperCAmelCase				:       str	   =				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)












from __future__ import annotations

import math


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


_UpperCAmelCase				:       Any	   =				[num for num in range(3, 10_00_01, 2) if not is_prime(num)]


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

    lowerCamelCase__    :      int					 =		[]
    for num in range(len(_UpperCAmelCase ) ):
        lowerCamelCase__    :      Union[str, Any]					 =		0
        while 2 * i * i <= odd_composites[num]:
            lowerCamelCase__    :      Dict					 =		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        SCREAMING_SNAKE_CASE      (       )			->     int:
    return compute_nums(1 )[0]


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





