import sys
import string
import random
from operator import *

class State:
    normal, string, skip, end = range(4)
        
class Interpreter:
    def __init__(self, file):
        self.code    = [line.strip('\n') for line in file]
        self.stack   = []
        self.delta   = (1, 0)
        self.pointer = (0, 0)
        self.state   = State.normal
        
        up, down, left, right = (0, -1), (0, 1), (-1, 0), (1, 0)
        pop, push, set_delta  = self._pop, self._push, self._set_delta
        set_state             = self._set_state
        
        self.instructions = {
            '+' : lambda : push( add(*pop(2)) ),
            '-' : lambda : push( sub(*reversed(pop(2))) ),
            '*' : lambda : push( mul(*pop(2)) ),
            '/' : lambda : push( div(*reversed(pop(2))) ),
            '%' : lambda : push( mod(*reversed(pop(2))) ),
            '!' : lambda : push( int(not_(*pop())) ),
            '`' : lambda : push( int(gt(*reversed(pop(2)))) ),
            '>' : lambda : set_delta( right ),
            '<' : lambda : set_delta( left ),
            '^' : lambda : set_delta( up ),
            'v' : lambda : set_delta( down ),
            '?' : lambda : set_delta( random.choice([up, down, left, right]) ),
            '_' : lambda : pop() == 0 and set_delta(right) or set_delta(left),
            '|' : lambda : pop() == 0 and set_delta(down) or set_delta(up),
            '"' : lambda : set_state(State.string),
            ':' : lambda : push(*self.stack[-1:]),
            '\\': lambda : push(*reversed(pop(2))),
            '$' : pop,
            '.' : lambda : sys.stdout.write( str(int(*pop())) ),
            ',' : lambda : sys.stdout.write( chr(*pop()) ),
            '#' : lambda : set_state(State.skip),
            'p' : lambda : self.set(reversed(pop(2)), pop()),
            'g' : lambda : self.get(reversed(pop(2))),
            '&' : lambda : push( int(raw_input()) ),
            '~' : lambda : push( ord(raw_input()) ),
            '@' : lambda : set_state(State.end)
        }

    def run(self):
        while self.state != State.end:
            self.evaluate(self.get(self.pointer))
            self.next()

    def evaluate(self, char):
        if self.state == State.string:
            if char != '"':
                self._push(ord(char))
            else:
                self.state = State.normal
        else:
            if char in string.digits:
                self._push(int(char))
            elif char != ' ':
                self.instructions[char]()

    def next(self):
        if self.state != State.end:
            (x, y), (dx, dy) = self.pointer, self.delta
            self.goto(((x + dx), (y + dy)))
            if self.state == State.skip:
                self.goto(((x + dx), (y + dy)))

    def goto(self, (x, y)):
        y = y % len(self.code)
        x = x % len(self.code[y])
        self.pointer = (x, y)

    def _pop(self, amount = 1):
        return [self.__pop_single() for i in range(amount)]

    def __pop_single(self):
        if not self.stack: return 0
        return self.stack.pop()

    def _push(self, *items):
        self.stack.extend(items)

    def _set_delta(self, delta):
        self.delta = delta
        return True

    def set(self, (x, y), value):
        self.code[y][x] = value

    def get(self, (x, y)):
        return self.code[y][x]
    
    def _set_state(self, state):
        self.state = state
    
if __name__ == '__main__':
    Interpreter(sys.stdin).run()

import sys

class Commands(type):
    def __new__(cls, name, bases, members):
        members['commands'] = dict(
            (m.__doc__, m) for m in members.values() if m.__doc__
        )    
        return type.__new__(cls, name, bases, members)

class Interpreter:
    __metaclass__ = Commands

    def __init__(self, file):
        self.code    = [c for c in file.read() if c in self.commands.keys()]
        self.memory  = {}
        self.pointer = 0
        self.instr   = 0

    def run(self):
        while self.instr < len(self.code):
            self.commands[self.code[self.instr]](self)
            self.instr += 1
    
    def inc(self):
        ">"
        self.pointer += 1

    def dec(self):
        "<"
        self.pointer -= 1

    def inc_value(self):
        "+"
        try:
            self.memory[self.pointer] += 1
        except:
            self.memory[self.pointer] = 1

    def dec_value(self):
        "-"
        try:
            self.memory[self.pointer] -= 1
        except:
            self.memory[self.pointer] = -1
    
    def output(self):
        "."
        sys.stdout.write(chr(self.memory[self.pointer]))

    def input(self):
        ","
        self.memory[self.pointer] = ord(sys.stdin.read(1))

    def start_loop(self):
        "["
        if self.memory[self.pointer] == 0:
            self.instr = self.code.index("]", self.instr) + 1

    def end_loop(self):
        "]"
        if self.memory[self.pointer] != 0:
            for i in xrange(self.instr, 0, -1):
                if self.code[i] == "[":
                    self.instr = i
                    break

if __name__ == '__main__':
    Interpreter(sys.stdin).run()