
"""simple docstring"""



from __future__ import annotations

import math
def    _UpperCAmelCase (					__lowerCamelCase  :			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(__A						) + 1						)					,   6						):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True
def    _UpperCAmelCase (					__lowerCamelCase  :			int						)	->   list[int]:
  _snake_case   	=			str(__A						)
  _snake_case   	=			[n]
  for i in range(1					,   len(__A						)						):
    list_nums.append(int(str_num[i:]						)						)
    list_nums.append(int(str_num[:-i]						)						)
  return list_nums
def    _UpperCAmelCase (					__lowerCamelCase  :			int						)	->   bool:
  if len(str(__A						)						) > 3:
    if not is_prime(int(str(__A						)[-3:]						)						) or not is_prime(int(str(__A						)[:3]						)						):
      return False
  return True
def    _UpperCAmelCase (					__lowerCamelCase  :			int = 11						)	->   list[int]:
  _snake_case   	=			[]
  _snake_case   	=			13
  while len(__A						) != count:
    if validate(__A						):
      _snake_case   	=			list_truncated_nums(__A						)
      if all(is_prime(__A						) for i in list_nums						):
        list_truncated_primes.append(__A						)
    num += 2
  return list_truncated_primes
def    _UpperCAmelCase (					)	->   int:
  return sum(compute_truncated_primes(11						)						)


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








"""simple docstring"""

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


A_						:    Optional[Any]				=      {
    'configuration_squeezebert': [
        'SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SqueezeBertConfig',
        'SqueezeBertOnnxConfig',
    ],
    'tokenization_squeezebert': ['SqueezeBertTokenizer'],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    Tuple				=      ['SqueezeBertTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    int				=      [
							    'SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'SqueezeBertForMaskedLM',
							    'SqueezeBertForMultipleChoice',
							    'SqueezeBertForQuestionAnswering',
							    'SqueezeBertForSequenceClassification',
							    'SqueezeBertForTokenClassification',
							    'SqueezeBertModel',
							    'SqueezeBertModule',
							    'SqueezeBertPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_squeezebert import (
							    SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    SqueezeBertConfig,
							    SqueezeBertOnnxConfig,
							)
							from .tokenization_squeezebert import SqueezeBertTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_squeezebert_fast import SqueezeBertTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_squeezebert import (
														    SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    SqueezeBertForMaskedLM,
														    SqueezeBertForMultipleChoice,
														    SqueezeBertForQuestionAnswering,
														    SqueezeBertForSequenceClassification,
														    SqueezeBertForTokenClassification,
														    SqueezeBertModel,
														    SqueezeBertModule,
														    SqueezeBertPreTrainedModel,
														)

else:
							import sys

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





