from __future__ import print_function
import sys
import inspect
import contextlib

@contextlib.contextmanager
def redir_stdout(new):
    old = sys.stdout
    sys.stdout = new
    yield
    sys.stdout = old

SPACE = None
class _RUN: pass

def read_word(fil):
    char = ' '
    buffer = []
    delim  = SPACE
    spaces = {' ', '\n', '\t'}
    while char != '':
        char = fil.read(1)
        if char == '':
            yield ''.join(buffer).strip()
            break
        buffer.append(char)
        if delim != SPACE and buffer[-len(delim):] == delim:
            delim = yield ''.join(buffer[:-len(delim)])
            buffer = []
        elif char in spaces:
            delim = yield ''.join(buffer[:-1]).strip()
            if char == '\n':
                yield _RUN
            buffer = []

def skip_run(reader):
    skipped = False
    r = reader.next()
    while r == _RUN:
        skipped = skipped or r == _RUN
        #print(r, end=':')
        r = reader.next()
        #print(r, end=' ')
    #print('out')
    return r, skipped

import collections
import traceback
class SymbolDict(collections.MutableMapping):
    def __init__(self, *args, **kwargs):
        self.ctr = 0
        self.items_ = set()
        self.dct = dict(*args, **kwargs)

    def __getitem__(self, key):
        if self.dct[key] != []:
            return self.dct[key][-1][1]
        else:
            raise KeyError("No such key '%s'" % key)
    def __setitem__(self, key, value):
        self.ctr += 1
        self.items_.add(key)
        self.dct.setdefault(key, []).append((self.ctr, value))
    def __delitem__(self, key):
        state = self.dct[key][-1][0]
        for a in self.dct.keys():
            while self.dct[a] and self.dct[a][-1][0] >= state:
                self.dct[a].pop()
            if self.dct[a] == []: self.dct.pop(a)
    forget = __delitem__
    def __iter__(self):
        return (x for x in self.dct.keys())
    def __len__(self):
        return len(self.dct)

import random

class Reader(object):
    symbols = SymbolDict()

    def rev_pctr(self, stack, rstack):
        num = stack.pop()
        self.program_ctr -= num

    def adv_pctr(self, stack, rstack):
        num = stack.pop()
        self.program_ctr += num

    def adv_pctr0(self, stack, rstack):
        #print('adv0 -->', stack, rstack)
        num = stack.pop()
        cond = stack.pop()
        if cond == 0:
            stack.append(num)
            self.adv_pctr(stack, rstack)

    def save_program_ctr(self):
        self.pcs.append(self.program_ctr)
    def restore_program_ctr(self):
        self.program_ctr = self.pcs.pop()
    def rollback_program(self):
        self.restore_program_ctr()
        del self.program[self.program_ctr:]
    def splice_program(self, words):
        begin = self.peek_saved_program_ctr()
        end = self.program_ctr + 1
        self.program[begin:end] = words
    def peek_saved_program_ctr(self):
        return self.pcs[-1]
    def drop_saved_program_ctr(self):
        return self.pcs.pop()

    def if_(self, stack, rstack=None):
        def if_reader(gen):
            counter = 0
            if_clause = []
            else_clause = []
            cur_clause = if_clause
            for word in gen:
                if word == 'if':
                    cur_clause.extend(if_reader(gen))
                    continue
                elif word == 'else':
                    cur_clause = else_clause
                    continue
                elif word == 'then':
                    else_clause.extend(['nop'])
                    break
                cur_clause.extend(self.expand_word(word))
            if_clause.extend(['%d' % len(else_clause), 'adv'])
            if_clause.insert(0, '%d' % len(if_clause))
            if_clause.insert(1, 'adv0')
            result = if_clause + else_clause
            return result

        ## Below we replace the if statement with a call to lower-level primitives
        ## i.e. if is implemented as a kind of macro.
        self.save_program_ctr()
        self.program_ctr += 1 # since the program counter doesn't update until after the yield
        gen = self.read_word()
        self.splice_program(if_reader(gen))
        self.restore_program_ctr()
        self.program_ctr -= 1 # in order to pick up the beginning of the if statement

    def words(self, stack, rstack=None):
        words = sorted(self.symbols.keys())
        mlen = max(len(x) for x in words)
        c = 80 // (mlen + 2)
        while words:
            head, words = words[:c], words[c:]
            print(' '.join(x.center(mlen) for x in head), file=self.out)

    def forget(self, stack, rstack=None):
        self.program_ctr += 1 # since the program counter doesn't update until after the yield
        name, skipped = skip_run(self.read_word())
        self.symbols.forget(name)
        if skipped: self.inp.append([_RUN])

    def colon(self, stack, rstack=None):
        self.program_ctr += 1 # since the program counter doesn't update until after the yield
        gen = self.read_word()
        name = gen.next()
        word = ' '
        conts = []
        while word != ';':
            word = gen.next()
            if word == _RUN: continue
            conts.append(word)
        conts.pop() # pop off the semicolon

        self.compile(name, filter(None,conts))
        #print(' >name', name, ' >symbols["%s"]' % name, self.symbols[name.lower()])

    def expand_word(self, word):
        if word in self.sym_words:
            outp = [self.expand_word(w) for w in self.sym_words[word][:]]
            return sum(outp, [])
        else:
            return [word]

    def compile(self, name, words):
        if hasattr(words, 'split'): words = words.split()
        self.sym_words[name] = words[:]
        @self.add_symbol(name)
        def newfun(stack, rstack=None):
            self.save_program_ctr()
            self.splice_program(words[:])
            self.program_ctr -= 1
        newfun.__name__ = '_forth_%s' % name
    def prog_print(self, stack, rstack=None):
        print('<%d>' % len(self.program), end=' ', file=self.out)
        for n in self.program:
            print(n, end=' ', file=self.out)
        print(file=self.out)

    def set_pctr(self, v):
        self.program_ctr = v
    def begin_until(self, stack, rstack):
        self.program_ctr += 1 # since the program counter doesn't update until after the yield
        mark = self.program_ctr
        word = ' '
        loop_count = 0
        words = []
        while True:
            word = self.read_word()
            if word == 'begin': loop_count += 1
            elif word == 'until':
                if loop_count == 0: break
                else: loop_count -= 1
            words.append(word)

    def mark_r(self, stack, rstack):
        self.jmpr.append(self.program_ctr-1)
        #print('markr', self.jmpr)
    def jmp_r(self, stack, rstack):
        dst = self.jmpr.pop()
        self.set_pctr(dst)
        #print('jmpr', dst, self.jmpr)
    def jmp_clr(self, stack, rstack):
        self.jmpr.pop()
        #print('clrjmp', self.jmpr)

    def mark(self, stack, rstack):
        self.stack.append(self.program_ctr-1)
    def jmp(self, stack, rstack):
        dst = stack.pop()
        self.set_pctr(dst)

    def __init__(self, out=sys.stdout):
        self.sym_words = SymbolDict()
        self.stack = []
        self.rstack = []
        self.program = []
        self.jmpr = []
        self.pcs = []
        self.mode = 0; # 0 - Normal; 1 - string reading
        self.program_ctr = 0
        self.out = out
        self.add_symbol('words')(self.words)
        self.add_symbol('.p')(self.prog_print)
        self.add_symbol(':')(self.colon)
        self.add_symbol('forget')(self.forget)
        self.add_symbol('if')(self.if_)
        self.add_symbol('jmp')(self.jmp)
        self.add_symbol('rev')(self.rev_pctr)
        self.add_symbol('adv')(self.adv_pctr)
        self.add_symbol('adv0')(self.adv_pctr0)
        self.add_symbol('mark')(self.mark)
        self.add_symbol('markr')(self.mark_r)
        self.add_symbol('jmpr')(self.jmp_r)
        self.add_symbol('clrjmp')(self.jmp_clr)

    def __getword(self):
        while self.inp[-1] == []: self.inp.pop()
        if hasattr(self.inp[-1], 'read'):
            self.inp[-1] = read_word(self.inp[-1])
        if hasattr(self.inp[-1], 'next'):
            result = self.inp[-1].next()
        else:
            result = self.inp[-1].pop(0)
        self.program.append(result)

    def read_word(self):
        while True:
            while self.program_ctr >= len(self.program):
                self.__getword()
            yield self.program[self.program_ctr]
            self.program_ctr += 1

    def read(self, inp, silent=False):
        self.inp = [inp]
        delim = SPACE
        if not silent: print(self.program_ctr, end='? ', file=self.out)
        for word in self.read_word():
            #print('<%s>' % word, end=' ')
            if word == _RUN:
                if not silent:
                    print(' ok', file=self.out)
                    print(self.program_ctr, end='? ', file=self.out)
                continue
            elif word == '."':
                out = []
                word = self.__getword()
                while word != '"':
                    out.append(self.__getword)
                    word = self.__getword()
                print(' '.join(out), file=self.out)
                continue
            elif word == '': continue
            self.stack.append(word)
            self.lookup()
    def lookup(self, sym=None):
        if sym is None:
            sym = self.stack.pop()
        result = None
        if sym.lower() in self.symbols:
            with redir_stdout(self.out):
                result = self.symbols[sym.lower()](self.stack, self.rstack)
        else:
            result = self.numberp(sym)
            if result is None: raise ValueError("Symbol %r not found" % sym)
            else:
                self.stack.append(result)
        return result

    def numberp(self, sym):
        is_valid = -1 # -1 = undecided, 0 = False, 1 = True
        typ = int
        dot_acceptable = False
        if sym == '': is_valid = 0
        elif not (sym.startswith('-') or sym[0].isdigit()): is_valid = 0
        if is_valid == 0: return None
        else:
            for char in sym[1:]:
                if char.isdigit(): dot_acceptable = True
                elif dot_acceptable and char == '.': typ = float
                elif dot_acceptable and char == 'e': typ = float
                else:
                    return None
            else:
                return typ(sym)
    @classmethod
    def add_symbol(cls, name):
        def _i1(func):
            cls.symbols[name.lower()] = func
            return func
        return _i1

@Reader.add_symbol('J')
def J(stack, rstack):
    stack.append(rstack[-3])

@Reader.add_symbol('R@')
def rAt(stack, rstack):
    stack.append(rstack[-1])

@Reader.add_symbol('I')
def I(stack, rstack):
    stack.append(rstack[-1])

@Reader.add_symbol('R>')
def movP(stack, rstack):
    stack.append(rstack.pop())

@Reader.add_symbol('>R')
def movR(stack, rstack):
    rstack.append(stack.pop())

@Reader.add_symbol('2over')
def _2over(stack, rstack=None):
    d, c, b, a = [stack.pop() for _ in range(4)]
    stack.append(a)
    stack.append(b)
    stack.append(c)
    stack.append(d)
    stack.append(a)
    stack.append(b)

@Reader.add_symbol('2dup')
def _2dup(stack, rstack=None):
    b, a = [stack.pop() for _ in range(2)]
    stack.append(a)
    stack.append(b)
    stack.append(a)
    stack.append(b)

@Reader.add_symbol('2swap')
def _2swap(stack, rstack=None):
    d, c, b, a = [stack.pop() for _ in range(4)]
    stack.append(c)
    stack.append(d)
    stack.append(a)
    stack.append(b)

@Reader.add_symbol('.r')
def stack_print(stack, rstack=None):
    print('<%d>' % len(rstack), end=' ')
    for n in rstack:
        print(n, end=' ')
    print()

@Reader.add_symbol('.s')
def stack_print(stack, rstack=None):
    print('<%d>' % len(stack), end=' ')
    for n in stack:
        print(n, end=' ')
    print()

@Reader.add_symbol('drop')
def drop(stack, rstack=None):
    stack.pop()

@Reader.add_symbol('rot')
def rot(stack, rstack=None):
    n1, n2, n3 = stack.pop(), stack.pop(), stack.pop()
    #a,  b,  c
    stack.extend([n2, n1, n3])

@Reader.add_symbol('dup')
def dup(stack, rstack=None):
    a = stack.pop()
    stack.append(a)
    stack.append(a)

@Reader.add_symbol('over')
def over(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a)
    stack.append(b)
    stack.append(a)

@Reader.add_symbol('swap')
def swap(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(b)
    stack.append(a)

@Reader.add_symbol('%')
def mod(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a % b)

@Reader.add_symbol('/')
def div(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a / b)

@Reader.add_symbol('*')
def mul(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a * b)

@Reader.add_symbol('-')
def min_(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a - b)

@Reader.add_symbol('+')
def add(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a + b)

@Reader.add_symbol('and')
def and_(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a and b)

@Reader.add_symbol('or')
def or_(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(a or b)

@Reader.add_symbol('.')
def period(stack, rstack=None):
    print(stack.pop(), end=' ')

@Reader.add_symbol('emit')
def emit(stack, rstack=None):
    print(chr(stack.pop()), end='')

@Reader.add_symbol('=')
def eql(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(int(a == b))

@Reader.add_symbol('<')
def lt(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(int(a < b))

@Reader.add_symbol('>')
def gt(stack, rstack=None):
    b, a = stack.pop(), stack.pop()
    stack.append(int(a > b))

@Reader.add_symbol('nop')
def nop(*_):
    pass

@Reader.add_symbol('clear')
def clear(stack, rstack):
    del stack[:]
    del rstack[:]

def init_reader():
    reader = Reader()
    reader.compile(*'0= 0 ='.split(None,1))
    reader.compile(*'0> 0 >'.split(None,1))
    reader.compile(*'0< 0 <'.split(None,1))
    reader.compile('cr', ['10', 'emit'])
    reader.compile('2drop', ['drop', 'drop'])
    reader.compile('false', ['0'])
    reader.compile('true', ['-1'])
    reader.compile('invert', ['0=', 'if', 'true', 'else', 'false', 'then'])
    reader.compile('?dup', 'dup if dup then'.split())
    reader.compile('1+', '1 +'.split())
    reader.compile('1-', '1 -'.split())
    reader.compile('2+', '2 +'.split())
    reader.compile('2-', '2 -'.split())
    reader.compile('2*', '2 *'.split())
    reader.compile('2/', '2 /'.split())
    reader.compile('abs', 'dup 0< if -1 * then'.split())
    reader.compile('negate', '-1 *'.split())
    reader.compile('min', '2dup - 0> if swap then drop')
    reader.compile('max', '2dup - 0< if swap then drop')
    reader.compile('*/', 'rot rot * swap /')
    reader.compile('*/mod', 'rot rot * swap /mod')
    reader.compile('/mod1', '2dup % dup 2swap / rot drop')
    reader.compile('mark>r', 'mark >r')
    reader.compile('arrow', '45 emit 45 emit 62 emit')
    reader.compile('loop0', '0= arrow .s if  98 emit cr else 97 emit cr .s r> .s jmp then')
    reader.compile(*'spaces 0 do 32 emit loop'.split(None, 1))
    reader.compile(*'do swap >r >r begin'.split(None, 1))
    reader.compile('rdrop', 'r> drop')
    reader.compile(*'loop r> 1+ r> 2dup >r >r < invert until rdrop rdrop'.split(None, 1))
    reader.compile('begin', 'markr')
    reader.compile('until', 'invert if jmpr else clrjmp then')
    return reader

if __name__ == '__main__':
    import sys
    reader = init_reader()

    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('file', nargs='?')
    args = parser.parse_args()
    if args.file == '-' or args.file == None:
        fil = sys.stdin
        reader.read(sys.stdin)
    else:
        with open(args.file) as f:
            reader.read(f, silent=True)