


from __future__ import annotations

import math



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



def 			lowerCAmelCase (		lowerCAmelCase_ )-> list[int]:
				lowerCAmelCase_ :      Union[str, Any]    				=				str(lowerCAmelCase_ )
				lowerCAmelCase_ :      Union[str, Any]    				=				[n]
				for i in range(1 ,   len(lowerCAmelCase_ ) ):
								list_nums.append(int(str_num[i:] ) )
								list_nums.append(int(str_num[:-i] ) )
				return list_nums



def 			lowerCAmelCase (		lowerCAmelCase_ )-> bool:
				if len(str(lowerCAmelCase_ ) ) > 3:
								if not is_prime(int(str(lowerCAmelCase_ )[-3:] ) ) or not is_prime(int(str(lowerCAmelCase_ )[:3] ) ):
												return False
				return True



def 			lowerCAmelCase (		lowerCAmelCase_ = 11 )-> list[int]:
				lowerCAmelCase_ :      list[int]    				=				[]
				lowerCAmelCase_ :      Optional[int]    				=				13
				while len(lowerCAmelCase_ ) != count:
								if validate(lowerCAmelCase_ ):
												lowerCAmelCase_ :      List[Any]    				=				list_truncated_nums(lowerCAmelCase_ )
												if all(is_prime(lowerCAmelCase_ ) for i in list_nums ):
																list_truncated_primes.append(lowerCAmelCase_ )
								num += 2
				return list_truncated_primes



def 			lowerCAmelCase (		)-> int:
				return sum(compute_truncated_primes(11 ) )


if __name__ == "__main__":
						print(f"""{sum(compute_truncated_primes(11)) = }""")



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase			:  str     =logging.get_logger(__name__)







class 				snake_case__(							UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__      :  Optional[int]					=							"""encoder-decoder"""
						SCREAMING_SNAKE_CASE__      :  str					=							True




						def __init__(				self   ,						**__lowercase							)					->    Union[str, Any]:
										super().__init__(**__lowercase							)
										assert (
										    "encoder" in kwargs and "decoder" in kwargs
										), "Config has to be initialized with encoder and decoder config"
										lowerCAmelCase_ :      str    				=				kwargs.pop('''encoder'''							)
										lowerCAmelCase_ :      int    				=				encoder_config.pop('''model_type'''							)
										lowerCAmelCase_ :      Optional[Any]    				=				kwargs.pop('''decoder'''							)
										lowerCAmelCase_ :      Optional[Any]    				=				decoder_config.pop('''model_type'''							)

										from ..auto.configuration_auto import AutoConfig

										lowerCAmelCase_ :      Union[str, Any]    				=				AutoConfig.for_model(__lowercase   ,						**__lowercase							)
										lowerCAmelCase_ :      List[str]    				=				AutoConfig.for_model(__lowercase   ,						**__lowercase							)
										lowerCAmelCase_ :      Any    				=				True




						@classmethod
						def 						lowercase_ (				cls   ,						__lowercase   ,						__lowercase   ,						**__lowercase							)					->    PretrainedConfig:
										logger.info('''Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''							)
										lowerCAmelCase_ :      int    				=				True
										lowerCAmelCase_ :      List[Any]    				=				True

										return cls(encoder=encoder_config.to_dict()   ,						decoder=decoder_config.to_dict()   ,						**__lowercase							)




						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_ :      Optional[Any]    				=				copy.deepcopy(self.__dict__							)
										lowerCAmelCase_ :      List[str]    				=				self.encoder.to_dict()
										lowerCAmelCase_ :      Dict    				=				self.decoder.to_dict()
										lowerCAmelCase_ :      Optional[Any]    				=				self.__class__.model_type
										return output