| n | class Calculator: | n | class ExpressionCalculator: | 
             |  |  |  | 
             |     def __init__(self): |  |     def __init__(self): | 
            | n |         self.variables = {} | n |         self.storage = {} | 
             |         self.allowed_namespaces = {'__builtins__': {}} |  |         self.safe_env = {'__builtins__': {}} | 
             |  |  |  | 
            | n |     def process_input(self, line): | n |     def handle_input(self, command): | 
             |         line = line.strip() |  |         command = command.strip() | 
             |         if not line or line.startswith('#'): |  |         if not command or command.startswith('#'): | 
             |             return None |  |             return None | 
            | n |         if '=' in line: | n |         if '=' in command: | 
             |             identifier, expr = map(str.strip, line.split('=', 1)) |  |             variable, expression = map(str.strip, command.split('=', 1)) | 
             |             return self.assign(identifier, expr) |  |             return self.set_variable(variable, expression) | 
             |         return self.evaluate_expression(line) |  |         return self.evaluate(command) | 
             |  |  |  | 
            | n |     def assign(self, identifier, expr): | n |     def set_variable(self, variable, expression): | 
             |         if not identifier.isidentifier(): |  |         if not variable.isidentifier(): | 
             |             return 'Assignment error' |  |             return 'Assignment error' | 
             |         try: |  |         try: | 
            | n |             self.variables[identifier] = eval(expr, self.allowed_namespa | n |             self.storage[variable] = eval(expression, self.safe_env, sel | 
             | ces, self.variables) |  | f.storage) | 
             |         except SyntaxError: |  |         except SyntaxError: | 
             |             return 'Syntax error' |  |             return 'Syntax error' | 
             |         except NameError: |  |         except NameError: | 
             |             return 'Name error' |  |             return 'Name error' | 
             |         except Exception: |  |         except Exception: | 
             |             return 'Runtime error' |  |             return 'Runtime error' | 
             |         return None |  |         return None | 
             |  |  |  | 
            | n |     def evaluate_expression(self, expr): | n |     def evaluate(self, expression): | 
             |         try: |  |         try: | 
            | n |             result = eval(expr, self.allowed_namespaces, self.variables) | n |             result = eval(expression, self.safe_env, self.storage) | 
             |             return result |  |             return result | 
             |         except SyntaxError: |  |         except SyntaxError: | 
             |             return 'Syntax error' |  |             return 'Syntax error' | 
             |         except NameError: |  |         except NameError: | 
             |             return 'Name error' |  |             return 'Name error' | 
             |         except Exception: |  |         except Exception: | 
             |             return 'Runtime error' |  |             return 'Runtime error' | 
            | n | calculator = Calculator() | n | calc = ExpressionCalculator() | 
             | while True: |  | while True: | 
            | n |     line = input().strip() | n |     cmd = input().strip() | 
             |     if not line: |  |     if not cmd: | 
             |         break |  |         break | 
            | t |     result = calculator.process_input(line) | t |     output = calc.handle_input(cmd) | 
             |     if result is not None: |  |     if output is not None: | 
             |         print(result) |  |         print(output) |