#include <stdint.h>

#define NAKED __attribute__((naked))

#define END_OF(arr) ((arr) + (sizeof((arr)) / sizeof(*(arr))))
#define NEXT        { goto *(*++pp); }

#define LIT(x)  push, (void *)(x)
#define FTH(w)  enter, (w##_body)
#define EXIT    doexit

#define ATTR_NATIVE     (1 << 7)
#define ATTR_IMMEDIATE  (1 << 6)
#define ATTR_LEN        (0x3F)

#define WORD(name, tname, prev, attr) \
    extern const void *name##_body[]; \
    struct word_t w_##name = { \
        name##_body, prev, attr + sizeof(tname) - 1, tname \
    }; \
    const void *name##_body[] = {
#define END    EXIT, };

#define W(name, tname, prev) WORD(name, tname, prev, 0)
#define I(name, tname, prev) WORD(name, tname, prev, ATTR_IMMEDIATE)
#define N(name, tname, prev) \
    extern const void *name##_body[]; \
    struct word_t w_##name = { \
        name##_body, prev, \
        ATTR_NATIVE + sizeof(tname) - 1, tname \
    }; \
    const void *name##_body[] = { name, EXIT };
#define C(name, tname, prev) \
    extern const void *name##_body[]; \
    struct word_t w_##name = { \
        name##_body, prev, \
        (ATTR_NATIVE | ATTR_IMMEDIATE) + sizeof(tname) - 1, tname \
    }; \
    const void *name##_body[] = { name, EXIT };

struct word_t
{
    const void **body;
    struct word_t *prev;
    unsigned char attr;
    char name[];
} __attribute__ ((packed));

intptr_t dstack[32];
intptr_t **rstack[32];
intptr_t dict[8192];
struct word_t *latest;
//char       inbuf  [ 128];
//intptr_t   inpos;

register intptr_t     tmp asm("r12");
register intptr_t *   sp  asm("r13"); // pointer to stack cells
register intptr_t *** rp  asm("r14"); // stack of pp
register intptr_t **  pp  asm("r15"); // pointer to ip

#define STASH   asm("push %r12; push %r13; push %r14; push %r15")
#define RESTORE asm("pop %r15; pop %r14; pop %r13; pop %r12")

NAKED
void enter(void)
{
    *--rp = ++pp;
    pp = (intptr_t **)*pp;
    goto *(*pp);
}

void doexit(void)
{
    if (rp < END_OF(rstack)) {
        pp = *rp++;
        NEXT;
    }
}

intptr_t state = 0;
intptr_t *here = dict;

NAKED void   dot(void);
NAKED void  push(void) { *--sp = (intptr_t)*++pp; NEXT; }
NAKED void   dup(void) { --sp; sp[0] = sp[1]; NEXT; }
NAKED void  drop(void) { ++sp; NEXT; }
NAKED void  swap(void) { tmp = sp[0]; sp[0] = sp[1]; sp[1] = tmp; NEXT; }
NAKED void   rot(void) { tmp = sp[0]; sp[0] = sp[2]; sp[2] = sp[1]; sp[1] = tmp; NEXT; }
NAKED void   add(void) { sp[1] += sp[0]; ++sp; NEXT; }
NAKED void   sub(void) { sp[1] -= sp[0]; ++sp; NEXT; }
NAKED void   mul(void) { sp[1] *= sp[0]; ++sp; NEXT; }
NAKED void   div(void) { sp[1] /= sp[0]; ++sp; NEXT; }
NAKED void   mod(void) { sp[1] %= sp[0]; ++sp; NEXT; }
NAKED void   and(void) { sp[1] &= sp[0]; ++sp; NEXT; }
NAKED void    or(void) { sp[1] |= sp[0]; ++sp; NEXT; }
NAKED void   xor(void) { sp[1] ^= sp[0]; ++sp; NEXT; }
NAKED void  peek(void) { *sp = *(intptr_t *)*sp; NEXT; }
NAKED void  poke(void) { *(intptr_t *)sp[0] = sp[1]; sp += 2; NEXT; }
NAKED void cpeek(void) { *sp = *(char *)*sp; NEXT; }
NAKED void cpoke(void) { *(char *)sp[0] = (char)sp[1]; sp += 2; NEXT; }
NAKED void  comp(void) { state = -1; NEXT; }
NAKED void  intr(void) { state = 0; NEXT; }
NAKED void comma(void) { *here++ = *sp++; NEXT; }

NAKED void compname(void)
{
    static int ch;

    STASH;
    for (;;) {
        extern int getchar(void);
        ch = getchar();

        if (ch <= 0x20)
            break;

        *(unsigned char *)here += 1;
        ((char *)here)[*(unsigned char *)here] = ch;
    }
    here = (intptr_t *)((intptr_t)here + *(unsigned char *)here);
    RESTORE;

    NEXT;
}

N(dup,    "dup",    0)
N(drop,   "drop",   &w_dup)
N(swap,   "swap",   &w_drop)
N(rot,    "rot",    &w_swap)
N(peek,   "@",      &w_rot)
N(poke,   "!",      &w_peek)
N(cpeek,  "c@",     &w_poke)
N(cpoke,  "c!",     &w_cpeek)
N(add,    "+",      &w_cpoke)
N(sub,    "-",      &w_add)
N(mul,    "*",      &w_sub)
N(div,    "/",      &w_mul)
N(mod,    "mod",    &w_div)
N(and,    "and",    &w_mod)
N(or,     "or",     &w_and)
N(xor,    "xor",    &w_or)
W(cell,   "cell",   &w_xor)    LIT(sizeof(*sp)),   END
W(cellp,  "cell+",  &w_cell)   FTH(cell), add,     END
W(cells,  "cells",  &w_cellp)  FTH(cell), mul,     END
W(dict,   "_d",     &w_cells)  LIT(dict),          END
W(here,   "here",   &w_dict)   LIT(&here), peek,   END
W(latest, "latest", &w_here)   LIT(&latest), peek, END
C(intr,   "[",      &w_latest)
N(comp,   "]",      &w_intr)
N(dot,    ".",      &w_comp)
W(negate, "negate", &w_dot)    LIT(-1), mul, END
W(invert, "invert", &w_negate) LIT(-1), xor, END
W(dec,    "1-",     &w_invert) LIT(1), sub,  END
W(inc,    "1+",     &w_dec)    LIT(1), add,  END
W(aligned, "aligned", &w_inc) LIT(sizeof(*sp) - 1), add, LIT(~(sizeof(*sp) - 1)), and, END
W(align,  "align",  &w_aligned) FTH(here), FTH(aligned), LIT(&here), poke, END
N(comma,  ",",      &w_align)
W(colon,  ":",      &w_comma)
    FTH(here), LIT(0), comma, FTH(latest), comma,
    compname, FTH(align), dup, FTH(here), swap, poke, comp, END
I(semic,  ";",      &w_colon) LIT(doexit), comma, LIT(&latest), poke, intr, END
#define LATEST      &w_semic

#include <ctype.h>
#include <stdio.h>
#include <string.h>

NAKED void dot() {
    STASH;
    printf("%ld ", *sp++);
    RESTORE;
    NEXT;
}

extern long strtol(char *, char **, int);
static void call(void *ptr);
//static void dump(void);
static void init(void);

int base = 10;

int main()
{
    char buf[128];

    init();

    for (;;) {
        //dump();

        char c;
        do c = getchar();
        while (!isgraph(c));

        char *s = buf;
        do {
            *s++ = c;
            c = getchar();
        } while (isgraph(c));
        *s = '\0';

        if (strcmp(buf, "bye") == 0)
            break;

        struct word_t *l;
        for (l = latest; l; l = l->prev) {
            const int ln = l->attr & ATTR_LEN;

            if (s - buf == ln && !strncmp(buf, l->name, ln))
                break;
        }

        if (l == 0) {
            char *end;
            long n = strtol(buf, &end, base);
            if (*end == '\0') {
                if (state) {
                    *here++ = (intptr_t)push;
                    *here++ = n;
                } else {
                    *--sp = n;
                }
            } else {
                puts("word not found");
            }
        } else {
            if (state && !(l->attr & ATTR_IMMEDIATE)) {
                if (!(l->attr & ATTR_NATIVE)) {
                    *here++ = (intptr_t)enter;
                    *here++ = (intptr_t)l->body;
                } else {
                    *here++ = (intptr_t)l->body[0];
                }
            } else {
                call(l->body);
            }
        }

        puts(state ? "compiled" : "ok");
    }

    return 0;
}

void init(void)
{
    sp = END_OF(dstack);
    rp = END_OF(rstack);
    pp = 0;

    latest = LATEST;
}

//void dump(void)
//{
//    //printf("IP: %ld\n", (intptr_t)pp);
//
//    printf("DS: ");
//    intptr_t *it = END_OF(dstack) - 1;
//    while (it >= sp) {
//        printf("%ld ", *it);
//        --it;
//    }
//    putchar('\n');
//
//    //printf("RS: ");
//    //intptr_t ***rt = END_OF(rstack) - 1;
//    //while (rt >= rp) {
//    //    printf("%ld ", (intptr_t)*rt);
//    //    --rt;
//    //}
//    //putchar('\n');
//}

void call(void *ptr)
{
    pp = ptr;
    ((void (*)())*pp)();
}