
"""simple docstring"""





from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class A_      (lowercase__ ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__     :		int    	=						["""image_processor""", """tokenizer"""]
  SCREAMING_SNAKE_CASE__     :		Any    	=						"""EfficientNetImageProcessor"""
  SCREAMING_SNAKE_CASE__     :		Any    	=						("""BertTokenizer""", """BertTokenizerFast""")







  def __init__(						self							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     super().__init__(lowercase_							,  lowercase_    )







  def __call__(						self							,  lowercase_=None							,  lowercase_=None							,  lowercase_="max_length"							,  lowercase_=64							,  lowercase_=None							,  **lowercase_    ):

     """simple docstring"""
     if text is None and images is None:
        raise ValueError("You have to specify either text or images. Both cannot be none."    )

     if text is not None:
        UpperCAmelCase_   :   List[str]     	=       self.tokenizer(
            lowercase_							,  padding=lowercase_							,  max_length=lowercase_							,  return_tensors=lowercase_							,  **lowercase_    )

     if images is not None:
        UpperCAmelCase_   :   Optional[Any]     	=       self.image_processor(lowercase_							,  return_tensors=lowercase_							,  **lowercase_    )

     if text is not None and images is not None:
        UpperCAmelCase_   :   Tuple     	=       image_features.pixel_values
        return encoding
     elif text is not None:
        return encoding
     else:
        return BatchEncoding(data=dict(**lowercase_    )							,  tensor_type=lowercase_    )







  def 			UpperCamelCase__   (						self							,  *lowercase_							,  **lowercase_    ):

     """simple docstring"""
     return self.tokenizer.batch_decode(*lowercase_							,  **lowercase_    )







  def 			UpperCamelCase__   (						self							,  *lowercase_							,  **lowercase_    ):

     """simple docstring"""
     return self.tokenizer.decode(*lowercase_							,  **lowercase_    )







  @property
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       self.tokenizer.model_input_names
     UpperCAmelCase_   :   int     	=       self.image_processor.model_input_names
     return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names    )    )







"""simple docstring"""
import os
def   A_    (     ):







						'''simple docstring'''


						snake_case_					:Optional[Any]		=     os.path.dirname(os.path.realpath(_lowercase      )      )
						snake_case_					:int		=     os.path.join(_lowercase,   """triangle.txt"""      )

						with open(_lowercase      ) as in_file:
												snake_case_					:List[Any]		=     [[int(_lowercase      ) for i in line.split()] for line in in_file]

						while len(_lowercase      ) != 1:
												snake_case_					:str		=     triangle.pop()
												snake_case_					:int		=     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())
