


"""simple docstring"""




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  __snake_case      (unittest.TestCase     ):




							def      __a      (    self:						str    ,       A_:						Tuple      ):
										__lowerCamelCase        =			list(tokenizer_class.max_model_input_sizes.keys()      )
										for model_name in sa_models[:1]:
													__lowerCamelCase        =			tokenizer_class.from_pretrained(A_      )
													self.assertIsNotNone(A_      )
													self.assertIsInstance(A_    ,       A_      )
													self.assertIsInstance(A_    ,       A_      )

													for special_tok in tokenizer.all_special_tokens:
																self.assertIsInstance(A_    ,       A_      )
																__lowerCamelCase        =			tokenizer.convert_tokens_to_ids(A_      )
																self.assertIsInstance(A_    ,       A_      )




							def      __a      (    self:						Any    ,       A_:						BatchEncoding    ,       A_:						Optional[Callable] = None      ):
										__lowerCamelCase        =			pickle.dumps(A_      )
										self.assertIsNotNone(A_      )

										__lowerCamelCase        =			pickle.loads(A_      )

										# 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(A_    ,       A_      )      )
													else:
																self.assertEqual(A_    ,       A_      )




							@slow
							def      __a      (    self:						Any      ):
										self.check_tokenizer_from_pretrained(A_      )




							def      __a      (    self:						Any      ):
										self.assertEqual(TensorType("""tf"""      )    ,       TensorType.TENSORFLOW      )
										self.assertEqual(TensorType("""pt"""      )    ,       TensorType.PYTORCH      )
										self.assertEqual(TensorType("""np"""      )    ,       TensorType.NUMPY      )




							@require_tokenizers
							def      __a      (    self:						Optional[Any]      ):
										import numpy as np

										__lowerCamelCase        =			BertTokenizer.from_pretrained("""bert-base-cased"""      )
										__lowerCamelCase        =			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      __a      (    self:						List[Any]      ):
										import tensorflow as tf

										def tf_array_equals(A_:						Tuple    ,       A_:						Any      ):
													return tf.reduce_all(tf.equal(A_    ,       A_      )      )

										__lowerCamelCase        =			BertTokenizer.from_pretrained("""bert-base-cased"""      )
										__lowerCamelCase        =			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      )    ,       A_      )

										with self.subTest("""BatchEncoding (Rust, return_tensors=TENSORFLOW)"""      ):
													self.assert_dump_and_restore(
													    tokenizer_r("""Small example to encode"""    ,       return_tensors=TensorType.TENSORFLOW      )    ,       A_      )




							@require_torch
							@require_tokenizers
							def      __a      (    self:						Optional[int]      ):
										import torch

										__lowerCamelCase        =			BertTokenizer.from_pretrained("""bert-base-cased"""      )
										__lowerCamelCase        =			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      __a      (    self:						Dict      ):
										__lowerCamelCase        =			BertTokenizer.from_pretrained("""bert-base-cased"""      )
										__lowerCamelCase        =			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      __a      (    self:						Union[str, Any]      ):
										__lowerCamelCase        =			BertTokenizerFast.from_pretrained("""bert-base-cased"""      )
										__lowerCamelCase        =			tokenizer_r(["""Test""", """\xad""", """test"""]    ,       is_split_into_words=A_      )

										self.assertEqual(encoded.word_to_tokens(0      )    ,       TokenSpan(start=1    ,       end=2      )      )
										self.assertEqual(encoded.word_to_tokens(1      )    ,       A_      )
										self.assertEqual(encoded.word_to_tokens(2      )    ,       TokenSpan(start=2    ,       end=3      )      )




							def      __a      (    self:						Any      ):
										__lowerCamelCase        =			BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}      )
										__lowerCamelCase        =			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:
													__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""np"""      )
										self.assertFalse(len(cs.err      )    ,       msg=f'should have no warning, but got {cs.err}'      )

										__lowerCamelCase        =			BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}      )
										__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""np"""    ,       prepend_batch_axis=A_      )
										self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)      )
										self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)      )




							@require_torch
							def      __a      (    self:						int      ):
										__lowerCamelCase        =			BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}      )
										__lowerCamelCase        =			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:
													__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""pt"""      )
										self.assertFalse(len(cs.err      )    ,       msg=f'should have no warning, but got {cs.err}'      )

										__lowerCamelCase        =			BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}      )
										__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""pt"""    ,       prepend_batch_axis=A_      )
										self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)      )
										self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)      )




							@require_tf
							def      __a      (    self:						str      ):
										__lowerCamelCase        =			BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}      )
										__lowerCamelCase        =			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:
													__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""tf"""      )
										self.assertFalse(len(cs.err      )    ,       msg=f'should have no warning, but got {cs.err}'      )

										__lowerCamelCase        =			BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}      )
										__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""tf"""    ,       prepend_batch_axis=A_      )
										self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)      )
										self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)      )




							@require_flax
							def      __a      (    self:						Optional[int]      ):
										__lowerCamelCase        =			BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]}      )
										__lowerCamelCase        =			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:
													__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""jax"""      )
										self.assertFalse(len(cs.err      )    ,       msg=f'should have no warning, but got {cs.err}'      )

										__lowerCamelCase        =			BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0}      )
										__lowerCamelCase        =			batch.convert_to_tensors(tensor_type="""jax"""    ,       prepend_batch_axis=A_      )
										self.assertEqual(tensor_batch["""inputs"""].shape    ,       (1, 3)      )
										self.assertEqual(tensor_batch["""labels"""].shape    ,       (1,)      )




							def      __a      (    self:						Tuple      ):
										__lowerCamelCase        =			[{"""input_ids""": np.array([0, 1, 2]      )}, {"""input_ids""": np.array([0, 1, 2, 3]      )}]
										__lowerCamelCase        =			BertTokenizer.from_pretrained("""bert-base-cased"""      )

										__lowerCamelCase        =			tokenizer.pad(A_    ,       padding=A_      )
										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]]      )
										__lowerCamelCase        =			tokenizer.pad(A_    ,       padding=A_    ,       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      __a      (    self:						List[str]      ):
										import torch

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

										__lowerCamelCase        =			tokenizer.pad(A_    ,       padding=A_      )
										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]]      )
										__lowerCamelCase        =			tokenizer.pad(A_    ,       padding=A_    ,       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      __a      (    self:						str      ):
										import tensorflow as tf

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

										__lowerCamelCase        =			tokenizer.pad(A_    ,       padding=A_      )
										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]]      )
										__lowerCamelCase        =			tokenizer.pad(A_    ,       padding=A_    ,       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      __a      (    self:						Optional[int]      ):
										__lowerCamelCase        =			Tokenizer(WordPiece(unk_token="""[UNK]"""      )      )
										PreTrainedTokenizerFast(tokenizer_object=A_      )




							@require_tokenizers
							def      __a      (    self:						Union[str, Any]      ):
										__lowerCamelCase        =			Tokenizer(WordPiece(unk_token="""[UNK]"""      )      )
										with tempfile.TemporaryDirectory() as tmpdirname:
													bert_tokenizer.save(os.path.join(A_    ,       """tokenizer.json"""      )      )
													PreTrainedTokenizerFast(tokenizer_file=os.path.join(A_    ,       """tokenizer.json"""      )      )








"""simple docstring"""




import os





def 			a_   (  ):
			__lowerCamelCase        =			os.path.dirname(os.path.realpath(lowercase__    )    )
			__lowerCamelCase        =			os.path.join(lowercase__, """triangle.txt"""    )

			with open(lowercase__    ) as in_file:
						__lowerCamelCase        =			[[int(lowercase__    ) for i in line.split()] for line in in_file]

			while len(lowercase__    ) != 1:
						__lowerCamelCase        =			triangle.pop()
						__lowerCamelCase        =			triangle[-1]
						for j in range(len(lowercase__    ) - 1    ):
									curr_row[j] += max(last_row[j], last_row[j + 1]    )
			return triangle[0][0]


if __name__ == "__main__":
					print(solution())




