

from math import isqrt

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  Optional[Any] )   ->       list[int]:
    _UpperCAmelCase       :		Tuple 		=    [True] * max_number
    for i in range(2  ,      isqrt(max_number - 1 ) + 1 ):
        if is_prime[i]:
            for j in range(i**2  ,      lowerCAmelCase  ,      lowerCAmelCase ):
                _UpperCAmelCase       :		int 		=    False

    return [i for i in range(2  ,      lowerCAmelCase ) if is_prime[i]]

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  str = 10**8 )   ->       int:
    _UpperCAmelCase       :		str 		=    calculate_prime_numbers(max_number // 2 )

    _UpperCAmelCase       :		Any 		=    0
    _UpperCAmelCase       :		Any 		=    0
    _UpperCAmelCase       :		Optional[Any] 		=    len(lowerCAmelCase ) - 1
    while left <= right:
        while prime_numbers[left] * prime_numbers[right] >= max_number:
            right -= 1
        semiprimes_count += right - left + 1
        left += 1

    return semiprimes_count


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





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


SCREAMING_SNAKE_CASE_        =      False

class 				a  (	unittest.TestCase				):


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										return 12


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										return 12


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										return 32


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										torch.manual_seed(0	)
										_UpperCAmelCase       :		Optional[int] 		=    VQModel(
										    block_out_channels=[32, 64]						,					in_channels=3						,					out_channels=3						,					down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]						,					up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]						,					latent_channels=3						,					num_vq_embeddings=self.num_embed						,					vq_embed_dim=3						,					)
										return model


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		List[str] 		=    CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)
										return tokenizer


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										torch.manual_seed(0	)
										_UpperCAmelCase       :		int 		=    CLIPTextConfig(
										    bos_token_id=0						,					eos_token_id=2						,					hidden_size=self.text_embedder_hidden_size						,					intermediate_size=37						,					layer_norm_eps=1e-05						,					num_attention_heads=4						,					num_hidden_layers=5						,					pad_token_id=1						,					vocab_size=1000						,					)
										return CLIPTextModel(A_	)


						@property
						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										torch.manual_seed(0	)

										_UpperCAmelCase       :		Optional[int] 		=    12
										_UpperCAmelCase       :		Union[str, Any] 		=    12

										_UpperCAmelCase       :		str 		=    {
										    "attention_bias": True,
										    "cross_attention_dim": 32,
										    "attention_head_dim": height * width,
										    "num_attention_heads": 1,
										    "num_vector_embeds": self.num_embed,
										    "num_embeds_ada_norm": self.num_embeds_ada_norm,
										    "norm_num_groups": 32,
										    "sample_size": width,
										    "activation_fn": "geglu-approximate",
										}

										_UpperCAmelCase       :		Any 		=    TransformeraDModel(**A_	)
										return model


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		Dict 		=    "cpu"

										_UpperCAmelCase       :		List[str] 		=    self.dummy_vqvae
										_UpperCAmelCase       :		Any 		=    self.dummy_text_encoder
										_UpperCAmelCase       :		Optional[int] 		=    self.dummy_tokenizer
										_UpperCAmelCase       :		List[Any] 		=    self.dummy_transformer
										_UpperCAmelCase       :		Union[str, Any] 		=    VQDiffusionScheduler(self.num_embed	)
										_UpperCAmelCase       :		Union[str, Any] 		=    LearnedClassifierFreeSamplingEmbeddings(learnable=A_	)

										_UpperCAmelCase       :		Optional[Any] 		=    VQDiffusionPipeline(
										    vqvae=A_						,					text_encoder=A_						,					tokenizer=A_						,					transformer=A_						,					scheduler=A_						,					learned_classifier_free_sampling_embeddings=A_						,					)
										_UpperCAmelCase       :		Optional[int] 		=    pipe.to(A_	)
										pipe.set_progress_bar_config(disable=A_	)

										_UpperCAmelCase       :		Union[str, Any] 		=    "teddy bear playing in the pool"

										_UpperCAmelCase       :		Union[str, Any] 		=    torch.Generator(device=A_	).manual_seed(0	)
										_UpperCAmelCase       :		List[Any] 		=    pipe([prompt]						,					generator=A_						,					num_inference_steps=2						,					output_type="np"	)
										_UpperCAmelCase       :		List[Any] 		=    output.images

										_UpperCAmelCase       :		Dict 		=    torch.Generator(device=A_	).manual_seed(0	)
										_UpperCAmelCase       :		Union[str, Any] 		=    pipe(
										    [prompt]						,					generator=A_						,					output_type="np"						,					return_dict=A_						,					num_inference_steps=2	)[0]

										_UpperCAmelCase       :		Optional[Any] 		=    image[0, -3:, -3:, -1]
										_UpperCAmelCase       :		int 		=    image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 24, 24, 3)

										_UpperCAmelCase       :		List[str] 		=    np.array([0.65_51, 0.61_68, 0.50_08, 0.56_76, 0.56_59, 0.42_95, 0.60_73, 0.55_99, 0.49_92]	)

										assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
										assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2





						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		Optional[int] 		=    "cpu"

										_UpperCAmelCase       :		Tuple 		=    self.dummy_vqvae
										_UpperCAmelCase       :		Optional[Any] 		=    self.dummy_text_encoder
										_UpperCAmelCase       :		List[str] 		=    self.dummy_tokenizer
										_UpperCAmelCase       :		List[Any] 		=    self.dummy_transformer
										_UpperCAmelCase       :		Dict 		=    VQDiffusionScheduler(self.num_embed	)
										_UpperCAmelCase       :		Dict 		=    LearnedClassifierFreeSamplingEmbeddings(
										    learnable=A_						,					hidden_size=self.text_embedder_hidden_size						,					length=tokenizer.model_max_length	)

										_UpperCAmelCase       :		Optional[int] 		=    VQDiffusionPipeline(
										    vqvae=A_						,					text_encoder=A_						,					tokenizer=A_						,					transformer=A_						,					scheduler=A_						,					learned_classifier_free_sampling_embeddings=A_						,					)
										_UpperCAmelCase       :		Union[str, Any] 		=    pipe.to(A_	)
										pipe.set_progress_bar_config(disable=A_	)

										_UpperCAmelCase       :		int 		=    "teddy bear playing in the pool"

										_UpperCAmelCase       :		Dict 		=    torch.Generator(device=A_	).manual_seed(0	)
										_UpperCAmelCase       :		int 		=    pipe([prompt]						,					generator=A_						,					num_inference_steps=2						,					output_type="np"	)
										_UpperCAmelCase       :		Union[str, Any] 		=    output.images

										_UpperCAmelCase       :		Optional[Any] 		=    torch.Generator(device=A_	).manual_seed(0	)
										_UpperCAmelCase       :		int 		=    pipe(
										    [prompt]						,					generator=A_						,					output_type="np"						,					return_dict=A_						,					num_inference_steps=2	)[0]

										_UpperCAmelCase       :		Any 		=    image[0, -3:, -3:, -1]
										_UpperCAmelCase       :		Optional[int] 		=    image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 24, 24, 3)

										_UpperCAmelCase       :		Union[str, Any] 		=    np.array([0.66_93, 0.60_75, 0.49_59, 0.57_01, 0.55_83, 0.43_33, 0.61_71, 0.56_84, 0.49_88]	)

										assert np.abs(image_slice.flatten() - expected_slice	).max() < 2.0
										assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2







@slow
@require_torch_gpu
class 				a  (	unittest.TestCase				):


						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()





						def        _UpperCAmelCase				(       self	):







										'''simple docstring'''


										_UpperCAmelCase       :		Optional[Any] 		=    load_numpy(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
										    "/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy"	)

										_UpperCAmelCase       :		Dict 		=    VQDiffusionPipeline.from_pretrained("microsoft/vq-diffusion-ithq"	)
										_UpperCAmelCase       :		Optional[int] 		=    pipeline.to(A_	)
										pipeline.set_progress_bar_config(disable=A_	)

										# requires GPU generator for gumbel softmax
										# don't use GPU generator in tests though
										_UpperCAmelCase       :		Optional[int] 		=    torch.Generator(device=A_	).manual_seed(0	)
										_UpperCAmelCase       :		Optional[Any] 		=    pipeline(
										    "teddy bear playing in the pool"						,					num_images_per_prompt=1						,					generator=A_						,					output_type="np"						,					)

										_UpperCAmelCase       :		str 		=    output.images[0]

										assert image.shape == (256, 256, 3)
										assert np.abs(expected_image - image	).max() < 2.0


