import sys
import getopt
import fileinput

class RecurseFunction:
    def __init__( self, _nn, _lines ):
        self.funcName = _nn
        self.body = []
        self.topEntry = _lines[0].find( "v" )
        self.bottomEntry = _lines[-1].find( "^" )
        self.leftEntry = None
        self.rightEntry = None
        for line in _lines[1:-1]:
            ll = line.strip()
            if ll[0] == ">":
                self.leftEntry = len( self.body )
            if ll[-1] == "<":
                self.rightEntry = len( self.body )
            self.body.append( ll[1:-1] )
        assert self.leftEntry != None
        assert self.rightEntry != None

    def __getitem__( self, _kk ):
        return self.body[ _kk ]

    def getEntry( self, _dd ):
        if _dd == '>':
            return 0, self.leftEntry
        elif _dd == 'v':
            return self.topEntry, 0
        elif _dd == '<':
            return len( self.body[ self.rightEntry ] ) - 1, self.rightEntry 
        elif _dd == '^':
            return self.bottomEntry, len( self.body ) - 1

class Recurse:
    def __init__( self, _in ):
        self.functions = {}

        funcName = None
        funcLines = None

        for line in _in:
            if funcName != None:
                funcLines.append( line )
                if line[ 0 ] == funcName:
                    self.functions[ funcName ] = RecurseFunction(
                        funcName, funcLines
                    )
                    funcName = None
            elif len( line ) <= 1 or line[:1].isspace():
                pass
            else:
                funcName = line[0]
                funcLines = [ line ]

        assert funcName == None
        assert self.functions.has_key( '$' )

    def getFunction( self, _nn ):
        if self.functions.has_key( _nn ):
            return self.functions[ _nn ]
        else:
            return None

RECURSE_NEXT_INSTRUCTION = 0
RECURSE_RETURN = 1
RECURSE_CALLING_FUNCTION = 2

class RecurseRuntime:
    def __init__( self, _prog ):
        self.program = _prog
        self.callstack = []
        self.left = []
        self.right = []
        self.direction = '>'
        self.function = self.program.getFunction( '$' )
        self.pcx, self.pcy = self.function.getEntry( self.direction )
        self.register = 0

    def run( self ):
        done = False
        while not done:
            rr = self.executeInstruction()
            if rr == RECURSE_NEXT_INSTRUCTION:
                self.advanceInstructionPointer()
            elif rr == RECURSE_RETURN:
                if len( self.callstack ) > 0:
                    self.popLocation()
                    self.advanceInstructionPointer()
                else:
                    done = True
            elif rr == RECURSE_CALLING_FUNCTION:
                pass

    def advanceInstructionPointer( self ):
        if self.direction == '>':
            self.pcx += 1
        elif self.direction == 'v':
            self.pcy += 1
        elif self.direction == '<':
            self.pcx -= 1
        elif self.direction == '^':
            self.pcy -= 1

    def popLocation( self ):
        self.function, self.pcx, self.pcy = self.callstack.pop()

    def pushLocation( self ):
        self.callstack.append( ( self.function, self.pcx, self.pcy ) )

    def turnCCW( self ):
        if self.direction == '>':
            self.direction = '^'
        elif self.direction == 'v':
            self.direction = '>'
        elif self.direction == '<':
            self.direction = 'v'
        elif self.direction == '^':
            self.direction = '<'

    def turnCW( self ):
        if self.direction == '>':
            self.direction = 'v'
        elif self.direction == 'v':
            self.direction = '<'
        elif self.direction == '<':
            self.direction = '^'
        elif self.direction == '^':
            self.direction = '>'

    def executeInstruction( self ):
        ret = RECURSE_NEXT_INSTRUCTION
        if self.pcy < 0 or self.pcx < 0:
            ret = RECURSE_RETURN
            return ret
        try:
            ii = self.function[ self.pcy ][ self.pcx ]
        except:
            ret = RECURSE_RETURN
            return ret

        if ii == '{':
            self.left.append( self.register )
        elif ii == '}':
            self.right.append( self.register )
        elif ii == '[':
            self.register = self.left.pop()
        elif ii == ']':
            self.register = self.right.pop()
        elif ii == '>':
            self.direction = '>'
        elif ii == '^':
            self.direction = '^'
        elif ii == '<':
            self.direction = '<'
        elif ii == 'v':
            self.direction = 'v'
        elif ii == '@':
            if self.register > 0:
                self.turnCCW()
            elif self.register < 0:
                self.turnCW()
        elif ii == '%':
            sys.stdout.write( "%d" % self.register )
        elif ii == '&':
            self.register = int(
                sys.stdin.raw_input( "Enter a number: " )
            )
            pass
        elif ii == '?':
            self.register = ord( sys.stdin.read(1) )
            pass
        elif ii == '!':
            sys.stdout.write( chr( self.register ) )
        elif ii == 'a':
            aa = self.left.pop()
            bb = self.right.pop()
            self.register = aa + bb
        elif ii == 's':
            aa = self.left.pop()
            bb = self.right.pop()
            self.register = aa - bb
        elif ii == 'm':
            aa = self.left.pop()
            bb = self.right.pop()
            self.register = aa * bb
        elif ii == 'd':
            aa = self.left.pop()
            bb = self.right.pop()
            self.register = aa / bb
        elif ii == 'r':
            aa = self.left.pop()
            bb = self.right.pop()
            self.register = aa % bb
        elif ord(ii) in range( ord('0'), ord('9')+1 ):
            self.register = ord( ii ) - ord( '0' )
        elif ii == '#':
            ret = RECURSE_RETURN
        else:
            nf = self.program.getFunction( ii )
            if nf != None:
                self.pushLocation()
                self.function = nf
                self.pcx, self.pcy = self.function.getEntry( self.direction )
                ret = RECURSE_CALLING_FUNCTION

        return ret

if __name__ == "__main__":
    optlist, args = getopt.getopt( sys.argv[1:], "c" )
    if len( args ) == 0:
        ff = fileinput.FileInput()
    else:
        ff = fileinput.FileInput( args )

    pp = Recurse( ff )

    if ( '-c', '' ) not in optlist:
        rr = RecurseRuntime( pp )
        rr.run()