


'''simple docstring'''
from __future__ import annotations





def 					a__       (					lowerCAmelCase__						)    ->	list[int]:
    UpperCAmelCase__			:		List[str]													=				[True] * limit
    UpperCAmelCase__			:		Optional[Any]													=				False
    UpperCAmelCase__			:		List[Any]													=				False
    UpperCAmelCase__			:		Optional[int]													=				True

    for i in range(3  ,					int(limit**0.5 + 1						)  ,					2						):
        UpperCAmelCase__			:		Any													=				i * 2
        while index < limit:
            UpperCAmelCase__			:		Union[str, Any]													=				False
            UpperCAmelCase__			:		Dict													=				index + i

    UpperCAmelCase__			:		Optional[int]													=				[2]

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

    return primes





def 					a__       (					lowerCAmelCase__ = 1_00_00_00						)    ->	int:
    UpperCAmelCase__			:		Any													=				prime_sieve(lowercase__						)
    UpperCAmelCase__			:		int													=				0
    UpperCAmelCase__			:		str													=				0

    for i in range(len(lowercase__						)						):
        for j in range(i + length  ,					len(lowercase__						)						):
            UpperCAmelCase__			:		Dict													=				sum(primes[i:j]						)
            if sol >= ceiling:
                break

            if sol in primes:
                UpperCAmelCase__			:		Tuple													=				j - i
                UpperCAmelCase__			:		str													=				sol

    return largest


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




import os
import tempfile
import unittest

from transformers import DistilBertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
	    DistilBertForMaskedLM,
	    DistilBertForMultipleChoice,
	    DistilBertForQuestionAnswering,
	    DistilBertForSequenceClassification,
	    DistilBertForTokenClassification,
	    DistilBertModel,
	)





class       A    (   A_ ):


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase=1_3      ,				lowerCAmelCase=7      ,				lowerCAmelCase=True      ,				lowerCAmelCase=True      ,				lowerCAmelCase=False      ,				lowerCAmelCase=True      ,				lowerCAmelCase=9_9      ,				lowerCAmelCase=3_2      ,				lowerCAmelCase=5      ,				lowerCAmelCase=4      ,				lowerCAmelCase=3_7      ,				lowerCAmelCase="gelu"      ,				lowerCAmelCase=0.1      ,				lowerCAmelCase=0.1      ,				lowerCAmelCase=5_1_2      ,				lowerCAmelCase=1_6      ,				lowerCAmelCase=2      ,				lowerCAmelCase=0.02      ,				lowerCAmelCase=3      ,				lowerCAmelCase=4      ,				lowerCAmelCase=None      ,				):
									__lowercase=			parent
									__lowercase=			batch_size
									__lowercase=			seq_length
									__lowercase=			is_training
									__lowercase=			use_input_mask
									__lowercase=			use_token_type_ids
									__lowercase=			use_labels
									__lowercase=			vocab_size
									__lowercase=			hidden_size
									__lowercase=			num_hidden_layers
									__lowercase=			num_attention_heads
									__lowercase=			intermediate_size
									__lowercase=			hidden_act
									__lowercase=			hidden_dropout_prob
									__lowercase=			attention_probs_dropout_prob
									__lowercase=			max_position_embeddings
									__lowercase=			type_vocab_size
									__lowercase=			type_sequence_label_size
									__lowercase=			initializer_range
									__lowercase=			num_labels
									__lowercase=			num_choices
									__lowercase=			scope


							def 			_A       (self					):
									__lowercase=			ids_tensor([self.batch_size, self.seq_length]      ,				self.vocab_size					)

									__lowercase=			None
									if self.use_input_mask:
											__lowercase=			random_attention_mask([self.batch_size, self.seq_length]					)

									__lowercase=			None
									__lowercase=			None
									__lowercase=			None
									if self.use_labels:
											__lowercase=			ids_tensor([self.batch_size]      ,				self.type_sequence_label_size					)
											__lowercase=			ids_tensor([self.batch_size, self.seq_length]      ,				self.num_labels					)
											__lowercase=			ids_tensor([self.batch_size]      ,				self.num_choices					)

									__lowercase=			self.get_config()

									return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


							def 			_A       (self					):
									return DistilBertConfig(
									    vocab_size=self.vocab_size      ,				dim=self.hidden_size      ,				n_layers=self.num_hidden_layers      ,				n_heads=self.num_attention_heads      ,				hidden_dim=self.intermediate_size      ,				hidden_act=self.hidden_act      ,				dropout=self.hidden_dropout_prob      ,				attention_dropout=self.attention_probs_dropout_prob      ,				max_position_embeddings=self.max_position_embeddings      ,				initializer_range=self.initializer_range      ,				)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			DistilBertModel(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(lowerCAmelCase      ,				lowerCAmelCase					)
									__lowercase=			model(lowerCAmelCase					)
									self.parent.assertEqual(result.last_hidden_state.shape      ,				(self.batch_size, self.seq_length, self.hidden_size)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			DistilBertForMaskedLM(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase					)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.seq_length, self.vocab_size)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			DistilBertForQuestionAnswering(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(
									    lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				start_positions=lowerCAmelCase      ,				end_positions=lowerCAmelCase					)
									self.parent.assertEqual(result.start_logits.shape      ,				(self.batch_size, self.seq_length)					)
									self.parent.assertEqual(result.end_logits.shape      ,				(self.batch_size, self.seq_length)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			self.num_labels
									__lowercase=			DistilBertForSequenceClassification(lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase					)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_labels)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			self.num_labels
									__lowercase=			DistilBertForTokenClassification(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()

									__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase					)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.seq_length, self.num_labels)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			self.num_choices
									__lowercase=			DistilBertForMultipleChoice(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			input_ids.unsqueeze(1					).expand(-1      ,				self.num_choices      ,				-1					).contiguous()
									__lowercase=			input_mask.unsqueeze(1					).expand(-1      ,				self.num_choices      ,				-1					).contiguous()
									__lowercase=			model(
									    lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase      ,				)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_choices)					)







							def 			_A       (self					):
									__lowercase=			self.prepare_config_and_inputs()
									((__lowercase),							(__lowercase),							(__lowercase),							(__lowercase),							(__lowercase),							(__lowercase))=			config_and_inputs
									__lowercase=			{'input_ids': input_ids, 'attention_mask': input_mask}
									return config, inputs_dict





@require_torch
class       A    (   A_					,				A_					,				unittest.TestCase ):
							UpperCamelCase_   :							Any       =(
							    (
							        DistilBertModel,
							        DistilBertForMaskedLM,
							        DistilBertForMultipleChoice,
							        DistilBertForQuestionAnswering,
							        DistilBertForSequenceClassification,
							        DistilBertForTokenClassification,
							    )
							    if is_torch_available()
							    else None
							)
							UpperCamelCase_   :							Optional[int]       =(
							    {
							        '''feature-extraction''': DistilBertModel,
							        '''fill-mask''': DistilBertForMaskedLM,
							        '''question-answering''': DistilBertForQuestionAnswering,
							        '''text-classification''': DistilBertForSequenceClassification,
							        '''token-classification''': DistilBertForTokenClassification,
							        '''zero-shot''': DistilBertForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							UpperCamelCase_   :							str       =True
							UpperCamelCase_   :							str       =True
							UpperCamelCase_   :							Union[str, Any]       =True
							UpperCamelCase_   :							Optional[int]       =True


							def 			_A       (self					):
									__lowercase=			DistilBertModelTester(self					)
									__lowercase=			ConfigTester(self      ,				config_class=lowerCAmelCase      ,				dim=3_7					)


							def 			_A       (self					):
									self.config_tester.run_common_tests()


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_model(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_masked_lm(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_question_answering(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_sequence_classification(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_token_classification(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_multiple_choice(*lowerCAmelCase					)


							@slow
							def 			_A       (self					):
									for model_name in DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase=			DistilBertModel.from_pretrained(lowerCAmelCase					)
											self.assertIsNotNone(lowerCAmelCase					)







							@slow
							@require_torch_gpu
							def 			_A       (self					):
									__lowercase,							__lowercase=			self.model_tester.prepare_config_and_inputs_for_common()
									for model_class in self.all_model_classes:
											# BertForMultipleChoice behaves incorrectly in JIT environments.
											if model_class == DistilBertForMultipleChoice:
													return

											__lowercase=			True
											__lowercase=			model_class(config=lowerCAmelCase					)

											__lowercase=			self._prepare_for_class(lowerCAmelCase      ,				lowerCAmelCase					)
											__lowercase=			torch.jit.trace(
											    lowerCAmelCase      ,				(inputs_dict['input_ids'].to('cpu'					), inputs_dict['attention_mask'].to('cpu'					))					)

											with tempfile.TemporaryDirectory() as tmp:
													torch.jit.save(lowerCAmelCase      ,				os.path.join(lowerCAmelCase      ,				'traced_model.pt'					)					)
													__lowercase=			torch.jit.load(os.path.join(lowerCAmelCase      ,				'traced_model.pt'					)      ,				map_location=lowerCAmelCase					)
													loaded(inputs_dict['input_ids'].to(lowerCAmelCase					)      ,				inputs_dict['attention_mask'].to(lowerCAmelCase					)					)





@require_torch
class       A    (   unittest.TestCase ):


							@slow
							def 			_A       (self					):
									__lowercase=			DistilBertModel.from_pretrained('distilbert-base-uncased'					)
									__lowercase=			torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]					)
									__lowercase=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]					)
									with torch.no_grad():
											__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase					)[0]
									__lowercase=			torch.Size((1, 1_1, 7_6_8)					)
									self.assertEqual(output.shape      ,				lowerCAmelCase					)
									__lowercase=			torch.tensor(
									    [[[-0.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]]					)

									self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,				lowerCAmelCase      ,				atol=1E-4					)					)






