


"""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 	A_       (     snake_case__   ):





  """simple docstring"""

  pass




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__=None       ,   UpperCAmelCase__=False				)     ->     Dict:
   try:
      a   :	Optional[Any]						=    ast.parse(lowerCAmelCase_				)
   except SyntaxError as e:
      print('The code generated by the agent is not valid.\n'       ,   lowerCAmelCase_				)
      return
   if state is None:
      a   :	Any						=    {}
   a   :	Optional[Any]						=    None
   for idx, node in enumerate(expression.body				):
      try:
         a   :	Any						=    evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
      except InterpretorError as e:
         a   :	Union[str, Any]						=    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(lowerCAmelCase_				)
         break
      if line_result is not None:
         a   :	int						=    line_result

   return result




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     Dict:
   if isinstance(lowerCAmelCase_       ,   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(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif isinstance(lowerCAmelCase_       ,   ast.Call				):
      # Function call -> we return the value of the function call
      return evaluate_call(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif isinstance(lowerCAmelCase_       ,   ast.Constant				):
      # Constant -> just return the value
      return expression.value
   elif isinstance(lowerCAmelCase_       ,   ast.Dict				):
      # Dict -> evaluate all keys and values
      a   :	Tuple						=    [evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				) for k in expression.keys]
      a   :	str						=    [evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				) for v in expression.values]
      return dict(zip(lowerCAmelCase_       ,   lowerCAmelCase_				)				)
   elif isinstance(lowerCAmelCase_       ,   ast.Expr				):
      # Expression -> evaluate the content
      return evaluate_ast(expression.value       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif isinstance(lowerCAmelCase_       ,   ast.For				):
      # For loop -> execute the loop
      return evaluate_for(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif isinstance(lowerCAmelCase_       ,   ast.FormattedValue				):
      # Formatted value (part of f-string) -> evaluate the content and return
      return evaluate_ast(expression.value       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif isinstance(lowerCAmelCase_       ,   ast.If				):
      # If -> execute the right branch
      return evaluate_if(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif hasattr(lowerCAmelCase_       ,   'Index'				) and isinstance(lowerCAmelCase_       ,   ast.Index				):
      return evaluate_ast(expression.value       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif isinstance(lowerCAmelCase_       ,   ast.JoinedStr				):
      return "".join([str(evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)				) for v in expression.values]				)
   elif isinstance(lowerCAmelCase_       ,   ast.List				):
      # List -> evaluate all elements
      return [evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				) for elt in expression.elts]
   elif isinstance(lowerCAmelCase_       ,   ast.Name				):
      # Name -> pick up the value in the state
      return evaluate_name(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   elif isinstance(lowerCAmelCase_       ,   ast.Subscript				):
      # Subscript -> return the value of the indexing
      return evaluate_subscript(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   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        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     List[Any]:
   a   :	Union[str, Any]						=    assign.targets
   a   :	str						=    evaluate_ast(assign.value       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)

   if len(lowerCAmelCase_				) == 1:
      a   :	Any						=    result
   else:
      if len(lowerCAmelCase_				) != len(lowerCAmelCase_				):
         raise InterpretorError(F'Expected {len(lowerCAmelCase_				)} values but got {len(lowerCAmelCase_				)}.'				)
      for var_name, r in zip(lowerCAmelCase_       ,   lowerCAmelCase_				):
         a   :	Tuple						=    r
   return result




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     Dict:
   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				)}.'				)
   a   :	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}).'				)

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




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     Optional[int]:
   a   :	Optional[int]						=    evaluate_ast(subscript.slice       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   a   :	Any						=    evaluate_ast(subscript.value       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   if isinstance(lowerCAmelCase_       ,   (list, tuple)				):
      return value[int(lowerCAmelCase_				)]
   if index in value:
      return value[index]
   if isinstance(lowerCAmelCase_       ,   lowerCAmelCase_				) and isinstance(lowerCAmelCase_       ,   lowerCAmelCase_				):
      a   :	int						=    difflib.get_close_matches(lowerCAmelCase_       ,   list(value.keys()				)				)
      if len(lowerCAmelCase_				) > 0:
         return value[close_matches[0]]

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




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     Tuple:
   if name.id in state:
      return state[name.id]
   a   :	Any						=    difflib.get_close_matches(name.id       ,   list(state.keys()				)				)
   if len(lowerCAmelCase_				) > 0:
      return state[close_matches[0]]
   raise InterpretorError(F'The variable `{name.id}` is not defined.'				)




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     Optional[int]:
   if len(condition.ops				) > 1:
      raise InterpretorError('Cannot evaluate conditions with multiple operators'				)

   a   :	List[str]						=    evaluate_ast(condition.left       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   a   :	str						=    condition.ops[0]
   a   :	List[str]						=    evaluate_ast(condition.comparators[0]       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)

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




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     Union[str, Any]:
   a   :	str						=    None
   if evaluate_condition(if_statement.test       ,   lowerCAmelCase_       ,   lowerCAmelCase_				):
      for line in if_statement.body:
         a   :	Tuple						=    evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
         if line_result is not None:
            a   :	Any						=    line_result
   else:
      for line in if_statement.orelse:
         a   :	Optional[Any]						=    evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
         if line_result is not None:
            a   :	Any						=    line_result
   return result




def        A_					(					UpperCAmelCase__       ,   UpperCAmelCase__       ,   UpperCAmelCase__				)     ->     Optional[int]:
   a   :	Any						=    None
   a   :	Any						=    evaluate_ast(for_loop.iter       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
   for counter in iterator:
      a   :	Union[str, Any]						=    counter
      for expression in for_loop.body:
         a   :	Union[str, Any]						=    evaluate_ast(lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_				)
         if line_result is not None:
            a   :	Tuple						=    line_result
   return result






import math







def 						UpperCAmelCase							(		lowerCAmelCase_							)						->						int:
     return sum(int(lowerCAmelCase_							) for digit in str(lowerCAmelCase_							)							)







def 						UpperCAmelCase							(		lowerCAmelCase_ = 3_0							)						->						int:
     a	:     Optional[int]						      =    []
     for digit in range(2    ,   1_0_0							):
          for power in range(2    ,   1_0_0							):
               a	:     List[str]						      =    int(math.pow(lowerCAmelCase_    ,   lowerCAmelCase_							)							)
               if digit == digit_sum(lowerCAmelCase_							):
                    digit_to_powers.append(lowerCAmelCase_							)

     digit_to_powers.sort()
     return digit_to_powers[n - 1]


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