class AbacusCore:

    def __init__(self):
        self._input_string = input
        self._vars = dict()
        self._funcs = dict()

        self._vars['alphabet'] = 28
        self._vars['alpha'] = 1
        self._vars['beta'] = 2

        self._funcs['r2'] = lambda x: round(x, 2)
        self._funcs['r0'] = lambda x: int(x)


    def _calculate(self, input_str):
        try:
            return True, eval(input_str)
        except ZeroDivisionError:
            res = 'Division by Zero'
        except NameError as e:
            res = 'Variable '+ e.name + ' not exists'
        return False, res

    def get_vars(self):
        return self._vars

    def add_var(self, name, value):
        self._vars[name] = value

    def parse_input(self, input_str):
        comment = None
        input_wo_com = None
        success = False
        input_str = str(input_str).strip()
        input_str = input_str.replace(',', '.')
        if input_str[0] == '#':
            comment = input_str[1:]
        com_index = input_str.find('#')
        if com_index > -1:
            input_wo_com = input_str[:com_index]
            comment = input_str[com_index + 1:]
        if input_wo_com is None:
            input_wo_com = input_str
        print('comment', comment)
        result = self._split_input(input_wo_com)
        print('result:',result)
        if result[1] is not None:
            success, res = self._calculate(result[1])
        if success:
            operators = result[0]
            operators.reverse()
            for op in operators:
                if op[-1] == '=':
                    self._vars[op[:-1]] = res
                elif op[-1] == ':':
                    res = self._funcs.get(op[:-1])(res)
            print('vars:', self._vars)
        else:
            print("Error")


    def _split_input(self, input_str):
        last_position = 0
        varchunks = list()
        for i, c in enumerate(input_str):
            if c in [':', '=']:
                chunk = input_str[last_position:i].strip()
                chunk = chunk + input_str[i]
                varchunks.append(chunk)
                last_position = i+1
        rest = input_str[last_position:].strip()
        print('rest', rest)
        rest = self._find_vars(rest)[1]
        return varchunks, rest

    def _find_vars(self, input_str):
        chunks = list()
        last_position = 0
        for i, c in enumerate(input_str):
            if c in ['+', '-', '/', '*', '(', ')', '[', ']', ';']:
                ch = input_str[last_position:i].strip()
                if len(ch)>0:
                    chunks.append(ch)
                chunks.append(input_str[i].strip())
                last_position = i+1

        if last_position<len(input_str):
            chunks.append(input_str[last_position:].strip())
        cp_chunks = chunks.copy()
        for i, chunk in enumerate(chunks):
            if chunk in self._vars:
                cp_chunks[i] = str(self._vars.get(chunk))
        print(chunks, cp_chunks)
        return len(cp_chunks)>1, ''.join(cp_chunks)