from argparse import ArgumentParser
from typing import Callable, Dict, Optional


class Byte(int):
    def __init__(self, *_):
        assert self >= 0 and self <= 255, 'pizdec'

    def __add__(self, value: int) -> 'Byte':
        return Byte((int(self) + value) % 256)

    def __sub__(self, value: int) -> 'Byte':
        return Byte((int(self) - value) % 256)


class Interpretator:
    def __init__(self, instructions: str):
        self._instructions = instructions
        self._stack = [
            Byte(0),
        ]
        self._pointer = 0
        self._position = 0
        self._jump_to = {}
        self._stdout = []

        left_stack = []
        for i, char in enumerate(instructions):
            if char == '[':
                left_stack.append(i)
            elif char == ']':
                to = left_stack.pop()
                self._jump_to[to] = i
                self._jump_to[i] = to

    def now(self):
        handlers: Dict[str, Callable[[], Optional[int]]] = {
            '>': self._handle_increment_pointer,
            '<': self._handle_decrement_pointer,
            '+': self._handle_increment_data,
            '-': self._handle_decrement_data,
            '.': self._handle_stdout,
            '[': self._handle_left_jump,
            ']': self._handle_right_jump,
        }

        stop = len(self._instructions)
        while self._position < stop:
            instruction = self._instructions[self._position]
            new_position = handlers[instruction]()
            if new_position is None:
                new_position = self._position + 1
            self._position = new_position

        if self._stdout:
            output = ''.join(self._stdout)
            print(output)

    @property
    def _pdata(self) -> Byte:
        return self._stack[self._pointer]

    @_pdata.setter
    def _pdata(self, value: Byte):
        self._stack[self._pointer] = value

    def _move_pointer(self, to: int):
        if to < 0:
            raise ValueError('ebanulsja?')

        self._pointer = to
        increase_on = self._pointer - (len(self._stack) - 1)
        if increase_on > 0:
            self._stack.extend(
                [Byte(0)] * increase_on
            )

    def _handle_increment_pointer(self) -> Optional[int]:
        self._move_pointer(self._pointer + 1)

    def _handle_decrement_pointer(self) -> Optional[int]:
        self._move_pointer(self._pointer - 1)

    def _handle_increment_data(self) -> Optional[int]:
        self._pdata += 1

    def _handle_decrement_data(self) -> Optional[int]:
        self._pdata -= 1

    def _handle_left_jump(self) -> Optional[int]:
        if self._pdata == 0:
             return self._jump_to[self._position]

    def _handle_right_jump(self) -> Optional[int]:
        if self._pdata != 0:
            return self._jump_to[self._position]

    def _handle_stdout(self) -> Optional[int]:
        self._stdout.append(chr(self._pdata))


def interpretate(data: str) -> str:
    return data


def main():
    parser = ArgumentParser()
    parser.add_argument('brainfuck', action='store', type=str)
    data: str = parser.parse_args().brainfuck
    interpretate = Interpretator(data)
    interpretate.now()


if __name__ == '__main__':
    main()