
from typing import TYPE_CHECKING

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


__a         =   {
    'configuration_wav2vec2': ['WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Wav2Vec2Config'],
    'feature_extraction_wav2vec2': ['Wav2Vec2FeatureExtractor'],
    'processing_wav2vec2': ['Wav2Vec2Processor'],
    'tokenization_wav2vec2': ['Wav2Vec2CTCTokenizer', 'Wav2Vec2Tokenizer'],
}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a         =   [
						    'WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'Wav2Vec2ForAudioFrameClassification',
						    'Wav2Vec2ForCTC',
						    'Wav2Vec2ForMaskedLM',
						    'Wav2Vec2ForPreTraining',
						    'Wav2Vec2ForSequenceClassification',
						    'Wav2Vec2ForXVector',
						    'Wav2Vec2Model',
						    'Wav2Vec2PreTrainedModel',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a         =   [
						    'TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'TFWav2Vec2ForCTC',
						    'TFWav2Vec2Model',
						    'TFWav2Vec2PreTrainedModel',
						    'TFWav2Vec2ForSequenceClassification',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a         =   [
						    'FlaxWav2Vec2ForCTC',
						    'FlaxWav2Vec2ForPreTraining',
						    'FlaxWav2Vec2Model',
						    'FlaxWav2Vec2PreTrainedModel',
						]


if TYPE_CHECKING:
						from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
						from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
						from .processing_wavaveca import WavaVecaProcessor
						from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_wavaveca import (
												    WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
												    WavaVecaForAudioFrameClassification,
												    WavaVecaForCTC,
												    WavaVecaForMaskedLM,
												    WavaVecaForPreTraining,
												    WavaVecaForSequenceClassification,
												    WavaVecaForXVector,
												    WavaVecaModel,
												    WavaVecaPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_wavaveca import (
												    TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFWavaVecaForCTC,
												    TFWavaVecaForSequenceClassification,
												    TFWavaVecaModel,
												    TFWavaVecaPreTrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_wavaveca import (
												    FlaxWavaVecaForCTC,
												    FlaxWavaVecaForPreTraining,
												    FlaxWavaVecaModel,
												    FlaxWavaVecaPreTrainedModel,
												)


else:
						import sys

						__a         =   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)











import itertools
import math


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


def       UpperCamelCase__(			)->Tuple:
       A__		   =		2
       while True:
              if is_prime(UpperCamelCase__    ):
                     yield num
              num += 1


def       UpperCamelCase__(			UpperCamelCase__     :			int = 1_00_01    )->int:
       return next(itertools.islice(prime_generator()					,	nth - 1					,	UpperCamelCase__    )    )


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





