


'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A	:	int     =     {
    'configuration_blip_2': [
        'BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'Blip2Config',
        'Blip2QFormerConfig',
        'Blip2VisionConfig',
    ],
    'processing_blip_2': ['Blip2Processor'],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__A	:	List[Any]     =     [
							    'BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'Blip2Model',
							    'Blip2QFormerModel',
							    'Blip2PreTrainedModel',
							    'Blip2ForConditionalGeneration',
							    'Blip2VisionModel',
							]

if TYPE_CHECKING:
							from .configuration_blip_a import (
							    BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    BlipaConfig,
							    BlipaQFormerConfig,
							    BlipaVisionConfig,
							)
							from .processing_blip_a import BlipaProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_blip_a import (
														    BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST,
														    BlipaForConditionalGeneration,
														    BlipaModel,
														    BlipaPreTrainedModel,
														    BlipaQFormerModel,
														    BlipaVisionModel,
														)

else:
							import sys

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



'''simple docstring'''






from __future__ import annotations





def      UpperCAmelCase      (		lowerCamelCase_  :int ):







		'''simple docstring'''
		snake_case_		:							List[str]			       =						[True] * limit
		snake_case_		:							Union[str, Any]			       =						False
		snake_case_		:							List[str]			       =						False
		snake_case_		:							Any			       =						True

		for i in range(3				,      int(limit**0.5 + 1 )				,      2 ):
				snake_case_		:							Tuple			       =						i * 2
				while index < limit:
						snake_case_		:							Any			       =						False
						snake_case_		:							Optional[Any]			       =						index + i

		snake_case_		:							List[str]			       =						[2]

		for i in range(3				,      lowerCamelCase_				,      2 ):
				if is_prime[i]:
						primes.append(lowerCamelCase_ )

		return primes





def      UpperCAmelCase      (		lowerCamelCase_  :int = 1_00_00_00 ):







		'''simple docstring'''
		snake_case_		:							Optional[int]			       =						prime_sieve(lowerCamelCase_ )
		snake_case_		:							Optional[Any]			       =						0
		snake_case_		:							Optional[int]			       =						0

		for i in range(len(lowerCamelCase_ ) ):
				for j in range(i + length				,      len(lowerCamelCase_ ) ):
						snake_case_		:							Optional[int]			       =						sum(primes[i:j] )
						if sol >= ceiling:
								break

						if sol in primes:
								snake_case_		:							Optional[Any]			       =						j - i
								snake_case_		:							Tuple			       =						sol

		return largest


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