






def        a_	( _A = 30					)     ->     int:







				"""simple docstring"""
				snake_case__													=       exponent + 2
				snake_case__													=       (1 + 5**0.5) / 2
				snake_case__													=       (phi**fibonacci_index - (phi - 1) ** fibonacci_index) / 5**0.5

				return int(SCREAMING_SNAKE_CASE_					)


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










import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
							from tokenizers import Tokenizer
							from tokenizers.models import WordPiece


class 					__SCREAMING_SNAKE_CASE(		unittest.TestCase		):
							def lowerCAmelCase_	(       self: Any    ,		UpperCamelCase: Union[str, Any]  )						->						Optional[int]:
											snake_case__													=       list(tokenizer_class.max_model_input_sizes.keys()  )
											for model_name in sa_models[:1]:
															snake_case__													=       tokenizer_class.from_pretrained(UpperCamelCase  )
															self.assertIsNotNone(UpperCamelCase  )
															self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )
															self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )

															for special_tok in tokenizer.all_special_tokens:
																			self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )
																			snake_case__													=       tokenizer.convert_tokens_to_ids(UpperCamelCase  )
																			self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )
							def lowerCAmelCase_	(       self: Optional[int]    ,		UpperCamelCase: BatchEncoding    ,		UpperCamelCase: Optional[Callable] = None  )						->						List[str]:
											snake_case__													=       pickle.dumps(UpperCamelCase  )
											self.assertIsNotNone(UpperCamelCase  )

											snake_case__													=       pickle.loads(UpperCamelCase  )

											# Ensure is_fast is correctly restored
											self.assertEqual(be_restored.is_fast    ,		be_original.is_fast  )

											# Ensure encodings are potentially correctly restored
											if be_original.is_fast:
															self.assertIsNotNone(be_restored.encodings  )
											else:
															self.assertIsNone(be_restored.encodings  )

											# Ensure the keys are the same
											for original_v, restored_v in zip(be_original.values()    ,		be_restored.values()  ):
															if equal_op:
																			self.assertTrue(equal_op(UpperCamelCase    ,		UpperCamelCase  )  )
															else:
																			self.assertEqual(UpperCamelCase    ,		UpperCamelCase  )
							@slow
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[int]:
											self.check_tokenizer_from_pretrained(UpperCamelCase  )
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[Any]:
											self.assertEqual(TensorType('tf'  )    ,		TensorType.TENSORFLOW  )
											self.assertEqual(TensorType('pt'  )    ,		TensorType.PYTORCH  )
											self.assertEqual(TensorType('np'  )    ,		TensorType.NUMPY  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[Any]:
											import numpy as np

											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											# Python no tensor
											with self.subTest('BatchEncoding (Python, return_tensors=None)'  ):
															self.assert_dump_and_restore(tokenizer_p('Small example to encode'  )  )

											with self.subTest('BatchEncoding (Python, return_tensors=NUMPY)'  ):
															self.assert_dump_and_restore(
															    tokenizer_p('Small example to encode'    ,		return_tensors=TensorType.NUMPY  )    ,		np.array_equal  )

											with self.subTest('BatchEncoding (Rust, return_tensors=None)'  ):
															self.assert_dump_and_restore(tokenizer_r('Small example to encode'  )  )

											with self.subTest('BatchEncoding (Rust, return_tensors=NUMPY)'  ):
															self.assert_dump_and_restore(
															    tokenizer_r('Small example to encode'    ,		return_tensors=TensorType.NUMPY  )    ,		np.array_equal  )
							@require_tf
							@require_tokenizers
							def lowerCAmelCase_	(       self: Any  )						->						Optional[Any]:
											import tensorflow as tf

											def tf_array_equals(UpperCamelCase: Optional[int]    ,		UpperCamelCase: Dict  ):
															return tf.reduce_all(tf.equal(UpperCamelCase    ,		UpperCamelCase  )  )

											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											with self.subTest('BatchEncoding (Python, return_tensors=TENSORFLOW)'  ):
															self.assert_dump_and_restore(
															    tokenizer_p('Small example to encode'    ,		return_tensors=TensorType.TENSORFLOW  )    ,		UpperCamelCase  )

											with self.subTest('BatchEncoding (Rust, return_tensors=TENSORFLOW)'  ):
															self.assert_dump_and_restore(
															    tokenizer_r('Small example to encode'    ,		return_tensors=TensorType.TENSORFLOW  )    ,		UpperCamelCase  )
							@require_torch
							@require_tokenizers
							def lowerCAmelCase_	(       self: int  )						->						List[str]:
											import torch

											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											with self.subTest('BatchEncoding (Python, return_tensors=PYTORCH)'  ):
															self.assert_dump_and_restore(
															    tokenizer_p('Small example to encode'    ,		return_tensors=TensorType.PYTORCH  )    ,		torch.equal  )

											with self.subTest('BatchEncoding (Rust, return_tensors=PYTORCH)'  ):
															self.assert_dump_and_restore(
															    tokenizer_r('Small example to encode'    ,		return_tensors=TensorType.PYTORCH  )    ,		torch.equal  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Any  )						->						Optional[int]:
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											with self.subTest('Python Tokenizer'  ):
															self.assertFalse(tokenizer_p('Small example to_encode'  ).is_fast  )

											with self.subTest('Rust Tokenizer'  ):
															self.assertTrue(tokenizer_r('Small example to_encode'  ).is_fast  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Dict  )						->						Union[str, Any]:
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )
											snake_case__													=       tokenizer_r(['Test', '\xad', 'test']    ,		is_split_into_words=UpperCamelCase  )

											self.assertEqual(encoded.word_to_tokens(0  )    ,		TokenSpan(start=1    ,		end=2  )  )
											self.assertEqual(encoded.word_to_tokens(1  )    ,		UpperCamelCase  )
											self.assertEqual(encoded.word_to_tokens(2  )    ,		TokenSpan(start=2    ,		end=3  )  )
							def lowerCAmelCase_	(       self: Dict  )						->						Tuple:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='np'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='np'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='np'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							@require_torch
							def lowerCAmelCase_	(       self: List[str]  )						->						Dict:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='pt'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='pt'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='pt'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							@require_tf
							def lowerCAmelCase_	(       self: Any  )						->						Optional[int]:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='tf'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='tf'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='tf'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							@require_flax
							def lowerCAmelCase_	(       self: Optional[int]  )						->						List[str]:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='jax'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='jax'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='jax'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							def lowerCAmelCase_	(       self: Union[str, Any]  )						->						str:
											snake_case__													=       [{'input_ids': np.array([0, 1, 2]  )}, {'input_ids': np.array([0, 1, 2, 3]  )}]
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )

											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase  )
											self.assertTrue(isinstance(batch['input_ids']    ,		np.ndarray  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase    ,		return_tensors='np'  )
											self.assertTrue(isinstance(batch['input_ids']    ,		np.ndarray  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
							@require_torch
							def lowerCAmelCase_	(       self: Dict  )						->						str:
											import torch

											snake_case__													=       [{'input_ids': torch.tensor([0, 1, 2]  )}, {'input_ids': torch.tensor([0, 1, 2, 3]  )}]
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )

											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase  )
											self.assertTrue(isinstance(batch['input_ids']    ,		torch.Tensor  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase    ,		return_tensors='pt'  )
											self.assertTrue(isinstance(batch['input_ids']    ,		torch.Tensor  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
							@require_tf
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[int]:
											import tensorflow as tf

											snake_case__													=       [{'input_ids': tf.constant([0, 1, 2]  )}, {'input_ids': tf.constant([0, 1, 2, 3]  )}]
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )

											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase  )
											self.assertTrue(isinstance(batch['input_ids']    ,		tf.Tensor  )  )
											self.assertEqual(batch['input_ids'].numpy().tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase    ,		return_tensors='tf'  )
											self.assertTrue(isinstance(batch['input_ids']    ,		tf.Tensor  )  )
											self.assertEqual(batch['input_ids'].numpy().tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Any  )						->						List[str]:
											snake_case__													=       Tokenizer(WordPiece(unk_token='[UNK]'  )  )
											PreTrainedTokenizerFast(tokenizer_object=UpperCamelCase  )


							@require_tokenizers
							def lowerCAmelCase_	(       self: Tuple  )						->						str:
											snake_case__													=       Tokenizer(WordPiece(unk_token='[UNK]'  )  )
											with tempfile.TemporaryDirectory() as tmpdirname:
															bert_tokenizer.save(os.path.join(UpperCamelCase    ,		'tokenizer.json'  )  )
															PreTrainedTokenizerFast(tokenizer_file=os.path.join(UpperCamelCase    ,		'tokenizer.json'  )  )




