


import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.testing_utils import require_tensorflow_text, require_tf, slow


if is_tf_available():
	import tensorflow as tf

if is_tensorflow_text_available():
	from transformers.models.bert import TFBertTokenizer


_lowerCAmelCase:						List[str]   				=       ['bert-base-uncased', 'bert-base-cased']
_lowerCAmelCase:						List[str]   				=       'hf-internal-testing/tiny-bert-tf-only'

if is_tf_available():




	class       lowercase_					(tf.keras.Model   ):





					def __init__(				self       ,  lowercase_)  -> List[str]:
												super().__init__()
												a__      =tokenizer
												a__      =AutoConfig.from_pretrained(lowercase_)
												a__      =TFAutoModel.from_config(lowercase_)





					def 						__UpperCamelCase    (				self       ,  lowercase_)  -> Optional[int]:
												a__      =self.tokenizer(lowercase_)
												a__      =self.bert(**lowercase_)
												return out["pooler_output"]




@require_tf
@require_tensorflow_text
class       lowercase_					(unittest.TestCase   ):





				def 						__UpperCamelCase    (				self)  -> Dict:
											super().setUp()

											a__      =[
											    BertTokenizer.from_pretrained(lowercase_) for checkpoint in (TOKENIZER_CHECKPOINTS * 2)
											]  # repeat for when fast_bert_tokenizer=false
											a__      =[TFBertTokenizer.from_pretrained(lowercase_) for checkpoint in TOKENIZER_CHECKPOINTS] + [
											    TFBertTokenizer.from_pretrained(lowercase_       ,  use_fast_bert_tokenizer=lowercase_)
											    for checkpoint in TOKENIZER_CHECKPOINTS
											]
											assert len(self.tokenizers) == len(self.tf_tokenizers)

											a__      =[
											    'This is a straightforward English test sentence.',
											    'This one has some weird characters\rto\nsee\r\nif  those\u00E9break things.',
											    'Now we\'re going to add some Chinese: 一 二 三 一二三',
											    'And some much more rare Chinese: 齉 堃 齉堃',
											    'Je vais aussi écrire en français pour tester les accents',
											    'Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ',
											]
											a__      =list(zip(self.test_sentences       ,  self.test_sentences[::-1]))





				def 						__UpperCamelCase    (				self)  -> List[str]:
											for tokenizer, tf_tokenizer in zip(self.tokenizers       ,  self.tf_tokenizers):
																		for test_inputs in (self.test_sentences, self.paired_sentences):
																									a__      =tokenizer(lowercase_       ,  return_tensors='tf'       ,  padding='longest')
																									a__      =tf_tokenizer(lowercase_)

																									for key in python_outputs.keys():
																																self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape))
																																self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key]       ,  tf.intaa) == tf_outputs[key]))





				@slow
				def 						__UpperCamelCase    (				self)  -> Union[str, Any]:
											for tf_tokenizer in self.tf_tokenizers:
																		a__      =tf_tokenizer(self.paired_sentences)
																		a__      =tf_tokenizer(
																		    text=[sentence[0] for sentence in self.paired_sentences]       ,  text_pair=[sentence[1] for sentence in self.paired_sentences]       ,  )
																		for key in merged_outputs.keys():
																									self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key]       ,  tf.intaa) == separated_outputs[key]))





				@slow
				def 						__UpperCamelCase    (				self)  -> Union[str, Any]:
											for tf_tokenizer in self.tf_tokenizers:
																		a__      =tf.function(lowercase_)
																		for test_inputs in (self.test_sentences, self.paired_sentences):
																									a__      =tf.constant(lowercase_)
																									a__      =compiled_tokenizer(lowercase_)
																									a__      =tf_tokenizer(lowercase_)

																									for key in eager_outputs.keys():
																																self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key]))





				@slow
				def 						__UpperCamelCase    (				self)  -> Union[str, Any]:
											for tf_tokenizer in self.tf_tokenizers:
																		a__      =ModelToSave(tokenizer=lowercase_)
																		a__      =tf.convert_to_tensor(self.test_sentences)
																		a__      =model(lowercase_)  # Build model with some sample inputs
																		with TemporaryDirectory() as tempdir:
																									a__      =Path(lowercase_) / 'saved.model'
																									model.save(lowercase_)
																									a__      =tf.keras.models.load_model(lowercase_)
																		a__      =loaded_model(lowercase_)
																		# We may see small differences because the loaded model is compiled, so we need an epsilon for the test
																		self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output))       ,  1e-5)






'''simple docstring'''





def 							lowerCamelCase	(					_snake_case	:    int = 50_000_000							):





    '''simple docstring'''


    lowercase__									=    set()
    lowercase__									=    int((limit - 24) ** (1 / 2)							)

    lowercase__									=    set(range(3  ,prime_square_limit + 1  ,2							)							)
    primes.add(2							)
    for p in range(3  ,prime_square_limit + 1  ,2							):
        if p not in primes:
            continue
        primes.difference_update(set(range(p * p  ,prime_square_limit + 1  ,_snake_case							)							)							)

    for primea in primes:
        lowercase__									=    primea * primea
        for primea in primes:
            lowercase__									=    primea * primea * primea
            if square + cube >= limit - 16:
                break
            for primea in primes:
                lowercase__									=    primea * primea * primea * primea
                lowercase__									=    square + cube + tetr
                if total >= limit:
                    break
                ret.add(_snake_case							)

    return len(_snake_case							)


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




