'''simple docstring'''


# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ast
import difflib
from collections.abc import Mapping
from typing import Any, Callable, Dict






class 	__SCREAMING_SNAKE_CASE		(			__snake_case			):







  '''simple docstring'''






  pass







def    _lowerCamelCase       ( lowerCamelCase_   :				Dict      ,	lowerCamelCase_   :				Any      ,	lowerCamelCase_   :				Optional[Any]=None      ,	lowerCamelCase_   :				Dict=False  ):



     """simple docstring"""





     try:
          UpperCAmelCase_				:  Optional[int]  = ast.parse(lowercase_  )
     except SyntaxError as e:
          print('The code generated by the agent is not valid.\n'      ,	lowercase_  )
          return
     if state is None:
          UpperCAmelCase_				:  Any  = {}
     UpperCAmelCase_				:  Optional[Any]  = None
     for idx, node in enumerate(expression.body  ):
          try:
               UpperCAmelCase_				:  Tuple  = evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  )
          except InterpretorError as e:
               UpperCAmelCase_				:  int  = F'''Evaluation of the code stopped at line {idx} before the end because of the following error'''
               if chat_mode:
                    msg += (
                        F'''. Copy paste the following error message and send it back to the agent:\nI get an error: \'{e}\''''
                    )
               else:
                    msg += F''':\n{e}'''
               print(lowercase_  )
               break
          if line_result is not None:
               UpperCAmelCase_				:  int  = line_result

     return result


def    _lowerCamelCase       ( lowerCamelCase_   :				List[Any]      ,	lowerCamelCase_   :				Optional[Any]      ,	lowerCamelCase_   :				List[Any]  ):



     """simple docstring"""





     if isinstance(lowercase_      ,	ast.Assign  ):
          # Assignement -> we evaluate the assignement which should update the state
          # We return the variable assigned as it may be used to determine the final result.
          return evaluate_assign(lowercase_      ,	lowercase_      ,	lowercase_  )
     elif isinstance(lowercase_      ,	ast.Call  ):
          # Function call -> we return the value of the function call
          return evaluate_call(lowercase_      ,	lowercase_      ,	lowercase_  )
     elif isinstance(lowercase_      ,	ast.Constant  ):
          # Constant -> just return the value
          return expression.value
     elif isinstance(lowercase_      ,	ast.Dict  ):
          # Dict -> evaluate all keys and values
          UpperCAmelCase_				:  Dict  = [evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  ) for k in expression.keys]
          UpperCAmelCase_				:  Tuple  = [evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  ) for v in expression.values]
          return dict(zip(lowercase_      ,	lowercase_  )  )
     elif isinstance(lowercase_      ,	ast.Expr  ):
          # Expression -> evaluate the content
          return evaluate_ast(expression.value      ,	lowercase_      ,	lowercase_  )
     elif isinstance(lowercase_      ,	ast.For  ):
          # For loop -> execute the loop
          return evaluate_for(lowercase_      ,	lowercase_      ,	lowercase_  )
     elif isinstance(lowercase_      ,	ast.FormattedValue  ):
          # Formatted value (part of f-string) -> evaluate the content and return
          return evaluate_ast(expression.value      ,	lowercase_      ,	lowercase_  )
     elif isinstance(lowercase_      ,	ast.If  ):
          # If -> execute the right branch
          return evaluate_if(lowercase_      ,	lowercase_      ,	lowercase_  )
     elif hasattr(lowercase_      ,	'Index'  ) and isinstance(lowercase_      ,	ast.Index  ):
          return evaluate_ast(expression.value      ,	lowercase_      ,	lowercase_  )
     elif isinstance(lowercase_      ,	ast.JoinedStr  ):
          return "".join([str(evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  )  ) for v in expression.values]  )
     elif isinstance(lowercase_      ,	ast.List  ):
          # List -> evaluate all elements
          return [evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  ) for elt in expression.elts]
     elif isinstance(lowercase_      ,	ast.Name  ):
          # Name -> pick up the value in the state
          return evaluate_name(lowercase_      ,	lowercase_      ,	lowercase_  )
     elif isinstance(lowercase_      ,	ast.Subscript  ):
          # Subscript -> return the value of the indexing
          return evaluate_subscript(lowercase_      ,	lowercase_      ,	lowercase_  )
     else:
          # For now we refuse anything else. Let's add things as we need them.
          raise InterpretorError(F'''{expression.__class__.__name__} is not supported.'''  )


def    _lowerCamelCase       ( lowerCamelCase_   :				int      ,	lowerCamelCase_   :				Any      ,	lowerCamelCase_   :				Optional[int]  ):



     """simple docstring"""





     UpperCAmelCase_				:  Dict  = assign.targets
     UpperCAmelCase_				:  List[str]  = evaluate_ast(assign.value      ,	lowercase_      ,	lowercase_  )

     if len(lowercase_  ) == 1:
          UpperCAmelCase_				:  str  = result
     else:
          if len(lowercase_  ) != len(lowercase_  ):
               raise InterpretorError(F'''Expected {len(lowercase_  )} values but got {len(lowercase_  )}.'''  )
          for var_name, r in zip(lowercase_      ,	lowercase_  ):
               UpperCAmelCase_				:  int  = r
     return result


def    _lowerCamelCase       ( lowerCamelCase_   :				Dict      ,	lowerCamelCase_   :				Dict      ,	lowerCamelCase_   :				Union[str, Any]  ):



     """simple docstring"""





     if not isinstance(call.func      ,	ast.Name  ):
          raise InterpretorError(
              F'''It is not permitted to evaluate other functions than the provided tools (tried to execute {call.func} of '''
              F'''type {type(call.func  )}.'''  )
     UpperCAmelCase_				:  Dict  = call.func.id
     if func_name not in tools:
          raise InterpretorError(
              F'''It is not permitted to evaluate other functions than the provided tools (tried to execute {call.func.id}).'''  )

     UpperCAmelCase_				:  Any  = tools[func_name]
     # Todo deal with args
     UpperCAmelCase_				:  Optional[int]  = [evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  ) for arg in call.args]
     UpperCAmelCase_				:  str  = {keyword.arg: evaluate_ast(keyword.value      ,	lowercase_      ,	lowercase_  ) for keyword in call.keywords}
     return func(*lowercase_      ,	**lowercase_  )


def    _lowerCamelCase       ( lowerCamelCase_   :				Optional[Any]      ,	lowerCamelCase_   :				List[str]      ,	lowerCamelCase_   :				Tuple  ):



     """simple docstring"""





     UpperCAmelCase_				:  int  = evaluate_ast(subscript.slice      ,	lowercase_      ,	lowercase_  )
     UpperCAmelCase_				:  Union[str, Any]  = evaluate_ast(subscript.value      ,	lowercase_      ,	lowercase_  )
     if isinstance(lowercase_      ,	(list, tuple)  ):
          return value[int(lowercase_  )]
     if index in value:
          return value[index]
     if isinstance(lowercase_      ,	lowercase_  ) and isinstance(lowercase_      ,	lowercase_  ):
          UpperCAmelCase_				:  List[Any]  = difflib.get_close_matches(lowercase_      ,	list(value.keys()  )  )
          if len(lowercase_  ) > 0:
               return value[close_matches[0]]

     raise InterpretorError(F'''Could not index {value} with \'{index}\'.'''  )


def    _lowerCamelCase       ( lowerCamelCase_   :				List[str]      ,	lowerCamelCase_   :				Optional[int]      ,	lowerCamelCase_   :				Optional[Any]  ):



     """simple docstring"""





     if name.id in state:
          return state[name.id]
     UpperCAmelCase_				:  Union[str, Any]  = difflib.get_close_matches(name.id      ,	list(state.keys()  )  )
     if len(lowercase_  ) > 0:
          return state[close_matches[0]]
     raise InterpretorError(F'''The variable `{name.id}` is not defined.'''  )


def    _lowerCamelCase       ( lowerCamelCase_   :				Union[str, Any]      ,	lowerCamelCase_   :				List[str]      ,	lowerCamelCase_   :				int  ):



     """simple docstring"""





     if len(condition.ops  ) > 1:
          raise InterpretorError('Cannot evaluate conditions with multiple operators'  )

     UpperCAmelCase_				:  Union[str, Any]  = evaluate_ast(condition.left      ,	lowercase_      ,	lowercase_  )
     UpperCAmelCase_				:  List[str]  = condition.ops[0]
     UpperCAmelCase_				:  Any  = evaluate_ast(condition.comparators[0]      ,	lowercase_      ,	lowercase_  )

     if isinstance(lowercase_      ,	ast.Eq  ):
          return left == right
     elif isinstance(lowercase_      ,	ast.NotEq  ):
          return left != right
     elif isinstance(lowercase_      ,	ast.Lt  ):
          return left < right
     elif isinstance(lowercase_      ,	ast.LtE  ):
          return left <= right
     elif isinstance(lowercase_      ,	ast.Gt  ):
          return left > right
     elif isinstance(lowercase_      ,	ast.GtE  ):
          return left >= right
     elif isinstance(lowercase_      ,	ast.Is  ):
          return left is right
     elif isinstance(lowercase_      ,	ast.IsNot  ):
          return left is not right
     elif isinstance(lowercase_      ,	ast.In  ):
          return left in right
     elif isinstance(lowercase_      ,	ast.NotIn  ):
          return left not in right
     else:
          raise InterpretorError(F'''Operator not supported: {comparator}'''  )


def    _lowerCamelCase       ( lowerCamelCase_   :				Dict      ,	lowerCamelCase_   :				Union[str, Any]      ,	lowerCamelCase_   :				Optional[int]  ):



     """simple docstring"""





     UpperCAmelCase_				:  Any  = None
     if evaluate_condition(if_statement.test      ,	lowercase_      ,	lowercase_  ):
          for line in if_statement.body:
               UpperCAmelCase_				:  Optional[int]  = evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  )
               if line_result is not None:
                    UpperCAmelCase_				:  List[Any]  = line_result
     else:
          for line in if_statement.orelse:
               UpperCAmelCase_				:  str  = evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  )
               if line_result is not None:
                    UpperCAmelCase_				:  List[str]  = line_result
     return result





def    _lowerCamelCase       ( lowerCamelCase_   :				int      ,	lowerCamelCase_   :				Tuple      ,	lowerCamelCase_   :				Tuple  ):



     """simple docstring"""





     UpperCAmelCase_				:  Union[str, Any]  = None
     UpperCAmelCase_				:  Dict  = evaluate_ast(for_loop.iter      ,	lowercase_      ,	lowercase_  )
     for counter in iterator:
          UpperCAmelCase_				:  Optional[int]  = counter
          for expression in for_loop.body:
               UpperCAmelCase_				:  Optional[Any]  = evaluate_ast(lowercase_      ,	lowercase_      ,	lowercase_  )
               if line_result is not None:
                    UpperCAmelCase_				:  Dict  = line_result
     return result









def   UpperCamelCase(   lowercase_ = 100     ,   lowercase_ = 100				)      ->							int:





  '''simple docstring'''





  return max(
      sum(int(lowercase_				) for x in str(base**power				)				)
      for base in range(lowercase_				)
      for power in range(lowercase_				)				)


# Tests
if __name__ == "__main__":
    import doctest

    doctest.testmod()