


'''simple docstring'''

import math



def 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					int )		->       bool:





   '''simple docstring'''







   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 							SCREAMING_SNAKE_CASE__(		_UpperCamelCase   :					int = 10_00     ,		_UpperCamelCase   :					int = 10_00 )		->       int:





   '''simple docstring'''







   UpperCamelCase__			    =    [0, 0, 0]  # length, a, b
   for a in range((a_limit * -1) + 1     ,		_UpperCamelCase ):
      for b in range(2     ,		_UpperCamelCase ):
         if is_prime(_UpperCamelCase ):
            UpperCamelCase__			    =    0
            UpperCamelCase__			    =    0
            while is_prime((n**2) + (a * n) + b ):
               count += 1
               n += 1
            if count > longest[0]:
               UpperCamelCase__			    =    [count, a, b]
   UpperCamelCase__			    =    longest[1] * longest[2]
   return ans


if __name__ == "__main__":
       print(solution(1_000, 1_000))
import torch
import torch.nn.functional as F

from diffusers import VQDiffusionScheduler

from .test_schedulers import SchedulerCommonTest







class       __snake_case (  lowerCamelCase__ ):
 __lowerCamelCase     : Dict 	=   (VQDiffusionScheduler,)
 def 						UpperCAmelCase__							(	self		, **snake_case__    )						->				Dict:
       '''simple docstring'''





       UpperCAmelCase     :			Dict     	={
           '''num_vec_classes''': 4097,
           '''num_train_timesteps''': 100,
       }

       config.update(**snake_case__    )
       return config
 def 						UpperCAmelCase__							(	self		, snake_case__    )						->				List[Any]:
       '''simple docstring'''





       UpperCAmelCase     :			List[str]     	=4
       UpperCAmelCase     :			Optional[int]     	=8
       UpperCAmelCase     :			Optional[Any]     	=8

       UpperCAmelCase     :			str     	=torch.randint(0		, snake_case__		, (batch_size, height * width)    )

       return sample
 @property
 def 						UpperCAmelCase__							(	self    )						->				List[Any]:
       '''simple docstring'''





       assert False
 def 						UpperCAmelCase__							(	self		, snake_case__    )						->				Tuple:
       '''simple docstring'''





       def model(snake_case__		, snake_case__		, *snake_case__    ):
             UpperCAmelCase	,    UpperCAmelCase     :			Union[str, Any]     	=sample.shape
             UpperCAmelCase     :			Tuple     	=torch.rand((batch_size, num_vec_classes - 1, num_latent_pixels)    )
             UpperCAmelCase     :			List[str]     	=F.log_softmax(logits.double()		, dim=1    ).float()
             return return_value

       return model
 def 						UpperCAmelCase__							(	self    )						->				Dict:
       '''simple docstring'''





       for timesteps in [2, 5, 100, 1000]:
             self.check_over_configs(num_train_timesteps=snake_case__    )
 def 						UpperCAmelCase__							(	self    )						->				Optional[Any]:
       '''simple docstring'''





       for num_vec_classes in [5, 100, 1000, 4000]:
             self.check_over_configs(num_vec_classes=snake_case__    )
 def 						UpperCAmelCase__							(	self    )						->				str:
       '''simple docstring'''





       for t in [0, 50, 99]:
             self.check_over_forward(time_step=snake_case__    )






 def 						UpperCAmelCase__							(	self    )						->				int:
       '''simple docstring'''





       pass
