code: 
  
  
  """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"""      )      )
  
  
  
  
  
style_context: 
  
  
  """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())
  
  
  
  
  