changeset 1:b683d796e07e tip basis

Added generated Keiko files
author Mike Spivey <mike@cs.ox.ac.uk>
date Mon, 10 Sep 2018 20:34:00 +0100
parents 5dd13b8deb54
children
files .hgignore keiko/interp.c keiko/keiko.h keiko/template.c
diffstat 4 files changed, 3106 insertions(+), 3 deletions(-) [+]
line wrap: on
line diff
--- a/.hgignore	Thu Aug 16 13:59:09 2018 +0100
+++ b/.hgignore	Mon Sep 10 20:34:00 2018 +0100
@@ -6,12 +6,9 @@
 *~
 .git
 .gitignore
-keiko/interp.c
-keiko/keiko.h
 keiko/obx-t.a
 keiko/pplink
 keiko/ppx
-keiko/template.c
 lab1/a.k
 lab1/a.test
 lab1/a.x
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/keiko/interp.c	Mon Sep 10 20:34:00 2018 +0100
@@ -0,0 +1,1639 @@
+/* Instruction interpreter -- generated by iset.tcl */
+
+/*
+ * iskel.c
+ * 
+ * This file is part of the Oxford Oberon-2 compiler
+ * Copyright (c) 2006--2016 J. M. Spivey
+ * All rights reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* This file is the skeleton of the bytecode interpreter; the parts
+   specific to each instruction are inserted from the file
+   'keiko.iset' by the script 'iset.tcl'.  There are three places that
+   code is inserted, each marked by two dollar signs.  In order of
+   appearance, they are:
+
+   1. A jump table for quick dispatching (used if JTABLE is defined).
+
+   2. Macro definitions used in the action routines.
+
+   3. Action routines for each instruction, forming the cases in a big
+      switch. */
+
+#include <math.h>
+#include "obx.h"
+#include "keiko.h"
+
+#ifdef HAVE_INDEXED_JUMPS
+#define JTABLE 1
+#endif
+
+#ifdef TRACE
+#define DISASS 1
+#undef JTABLE
+#define do_find_proc if (dflag > 1) thisproc = find_proc(cp)
+#else
+#define do_find_proc
+#endif
+
+#ifdef PROFILE
+#undef JTABLE
+#endif
+
+
+#define local(n)        ((uchar *) bp + (n))
+#define parent(a, t)    indir(pointer(bp[SL]) + a, t)
+#define indir(p, t)     (* (t *) (p))
+#define subs(p, n, t)   ((t *) (p))[n]
+#define const(n)        cp[CP_CONST+n]
+#define jump(lab)       pc = pc0 + lab
+
+
+#define dup(n, sp)      sp--; sp[0] = sp[n+1]
+#define swap(sp)        sp[-1] = sp[1]; sp[1] = sp[0]; sp[0] = sp[-1]
+
+
+#define ror(a, b) ((((unsigned) a) >> b) | (((unsigned) a) << (32-b)))
+
+
+/* The DIV and MOD instructions must give the correct results, even if 
+   C is wrong.  Correct means that b * (a DIV b) + a MOD b = a, and 
+   (-a) DIV (-b) = a DIV b, and if b > 0 then 0 <= a MOD b < b. */
+
+static inline divop_decl(int)
+static inline divop_decl(longint)
+
+
+#define jcase(x, n)  if ((unsigned) x < (unsigned) n) { pc0 = pc + 2*x; jump(get2(pc0)); }  else pc += 2*n
+
+
+static inline int fcmpl(double a, double b) {
+     return (a > b ? 1 : a == b ? 0 : -1);
+}
+
+static inline int fcmpg(double a, double b) {
+     return (a < b ? -1 : a == b ? 0 : 1);
+}
+
+static inline int lcmp(longint a, longint b) {
+     return (a < b ? -1 : a > b ? 1 : 0);
+}
+
+
+#ifdef UNALIGNED_MEM
+#define getdbl get_double
+#define putdbl put_double
+#define getlong get_long
+#define putlong put_long
+#else
+static inline double getdbl(value *v) {
+     dblbuf dd;
+     dd.n.lo = v[0].i;
+     dd.n.hi = v[1].i;
+     return dd.d;
+}
+
+static inline void putdbl(value *v, double x) {
+     dblbuf dd;
+     dd.d = x;
+     v[0].i = dd.n.lo;
+     v[1].i = dd.n.hi;
+}
+
+static inline longint getlong(value *v) {
+     dblbuf dd;
+     dd.n.lo = v[0].i;
+     dd.n.hi = v[1].i;
+     return dd.q;
+}
+
+static inline void putlong(value *v, longint x) {
+     dblbuf dd;
+     dd.q = x;
+     v[0].i = dd.n.lo;
+     v[1].i = dd.n.hi;
+}
+#endif
+
+
+static inline int boundcheck(unsigned i, unsigned n, int line,               
+                             value *bp, uchar *pc) {         
+     if (i >= n) runtime_error(E_BOUND, line, bp, pc);
+     return i;                                               
+}
+
+#define checkdef(name, type, arg, extra, test, msg)                      static inline type name(type arg extra, int line,                       value *bp, uchar *pc) {                         if (test) runtime_error(msg, line, bp, pc);                     return arg;                                                     }
+
+checkdef(nullcheck, uchar *, p,, p == NULL, E_NULL)
+checkdef(zerocheck, int, n,, n == 0, E_DIV)
+checkdef(fzerocheck, double, x,, x == 0.0, E_FDIV)
+checkdef(lzerocheck, longint, n,, n == 0, E_DIV)
+checkdef(globcheck, value *, p,, p != NULL, E_GLOB)
+
+#define czech(chk, a, n) chk(a, n, bp, pc0)
+#define czech2(chk, a, b, n) chk(a, b, n, bp, pc0)
+#define error(msg, n) runtime_error(msg, n, bp, pc0);
+
+
+#ifdef WORDS_BIGENDIAN
+#define alignx(a, n)    (a <<= (32-n))
+#else
+#define alignx(a, n)    a
+#endif
+
+
+#ifdef PROFILE
+#define prof_charge(n)  ticks += n
+#else
+#define prof_charge(n)
+#endif
+
+
+#define fixcopy(a, b, n) prof_charge(n/4); memcpy(a, b, n)
+
+
+#define flexcopy(d0, size0)                                              { value *d = (value *) d0; int size = size0;                    int sizew = (size+3)/4; prof_charge(sizew);                     sp -= sizew;                                                    if ((uchar *) sp < stack + SLIMIT)                              error(E_STACK, 0);                                              memcpy(sp, pointer(d[0]), size);                                        d[0].a = address(sp);}
+
+
+#define frame()                                                          bp = sp;                                                                sp = (value *) ((uchar *) bp - cp[CP_FRAME].i);                         if ((uchar *) sp < stack + SLIMIT) error(E_STACK, 0);           memset(sp, 0, cp[CP_FRAME].i);
+
+#ifdef OBXDEB
+#define cond_break()  if (one_shot && *pc != K_LNUM_2 && *pc != K_BREAK_2)  debug_break(cp, bp, pc, "stop")
+#else
+#define cond_break()
+#endif
+
+
+#define slide(nargs) sp += HEAD + nargs; cond_break();
+
+
+
+/* interp -- main loop of the interpreter */
+void interp(value *sp0) {
+     register value *cp = valptr(sp0[CP]);
+     uchar *pc = pointer(cp[CP_CODE]);
+     register uchar *pc0 = NULL;
+     register value *sp = sp0;
+     register uchar ir = 0;
+#ifdef PROFILE
+     register counter ticks = 0;
+#endif
+     register value *bp = NULL;
+     value *base = sp0;
+#ifdef TRACE
+     proc thisproc = NULL;
+#endif
+
+#ifdef JTABLE
+     /* Save time by using gcc's label array feature */
+     static void *jtable[256] = {
+          &&lbl_ILLEGAL,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_x1,
+          &&lbl_PUSH_1,
+          &&lbl_PUSH_2,
+          &&lbl_LDKW_1,
+          &&lbl_LDKW_2,
+          &&lbl_LDKF_1,
+          &&lbl_LDKF_2,
+          &&lbl_LOCAL_1,
+          &&lbl_LOCAL_2,
+          &&lbl_OFFSET,
+          &&lbl_INDEXS,
+          &&lbl_INDEXW,
+          &&lbl_INDEXD,
+          &&lbl_LOADW,
+          &&lbl_LOADS,
+          &&lbl_LOADC,
+          &&lbl_LOADF,
+          &&lbl_STOREW,
+          &&lbl_STORES,
+          &&lbl_STOREC,
+          &&lbl_STOREF,
+          &&lbl_LDLW_x1,
+          &&lbl_LDLW_x1,
+          &&lbl_LDLW_x1,
+          &&lbl_LDLW_x1,
+          &&lbl_LDLW_x1,
+          &&lbl_LDLW_x1,
+          &&lbl_LDLW_x2,
+          &&lbl_LDLW_x2,
+          &&lbl_LDLW_x2,
+          &&lbl_LDLW_x2,
+          &&lbl_LDLW_x2,
+          &&lbl_LDLW_x2,
+          &&lbl_LDLW_1,
+          &&lbl_LDLW_2,
+          &&lbl_LDLS_1,
+          &&lbl_LDLS_2,
+          &&lbl_LDLC_1,
+          &&lbl_LDLC_2,
+          &&lbl_LDLF_1,
+          &&lbl_LDLF_2,
+          &&lbl_STLW_x1,
+          &&lbl_STLW_x1,
+          &&lbl_STLW_x1,
+          &&lbl_STLW_x1,
+          &&lbl_STLW_x1,
+          &&lbl_STLW_x1,
+          &&lbl_STLW_x2,
+          &&lbl_STLW_x2,
+          &&lbl_STLW_x2,
+          &&lbl_STLW_x2,
+          &&lbl_STLW_x2,
+          &&lbl_STLW_x2,
+          &&lbl_STLW_1,
+          &&lbl_STLW_2,
+          &&lbl_STLS_1,
+          &&lbl_STLS_2,
+          &&lbl_STLC_1,
+          &&lbl_STLC_2,
+          &&lbl_STLF_1,
+          &&lbl_STLF_2,
+          &&lbl_LDGW_K,
+          &&lbl_LDGW_L,
+          &&lbl_LDGS_K,
+          &&lbl_LDGS_L,
+          &&lbl_LDGC_K,
+          &&lbl_LDGC_L,
+          &&lbl_LDGF_K,
+          &&lbl_LDGF_L,
+          &&lbl_STGW_K,
+          &&lbl_STGW_L,
+          &&lbl_STGS_K,
+          &&lbl_STGS_L,
+          &&lbl_STGC_K,
+          &&lbl_STGC_L,
+          &&lbl_STGF_K,
+          &&lbl_STGF_L,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_x1,
+          &&lbl_LDNW_1,
+          &&lbl_LDNW_2,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_x1,
+          &&lbl_STNW_1,
+          &&lbl_STNW_2,
+          &&lbl_LDIW,
+          &&lbl_LDIF,
+          &&lbl_LDIS,
+          &&lbl_LDIC,
+          &&lbl_STIW,
+          &&lbl_STIF,
+          &&lbl_STIS,
+          &&lbl_STIC,
+          &&lbl_LDID,
+          &&lbl_STID,
+          &&lbl_LDIQ,
+          &&lbl_STIQ,
+          &&lbl_LOADD,
+          &&lbl_STORED,
+          &&lbl_LDKD_1,
+          &&lbl_LDKD_2,
+          &&lbl_LOADQ,
+          &&lbl_STOREQ,
+          &&lbl_LDKQ_1,
+          &&lbl_LDKQ_2,
+          &&lbl_INCL_1,
+          &&lbl_DECL_1,
+          &&lbl_DUP,
+          &&lbl_DUP,
+          &&lbl_DUP,
+          &&lbl_SWAP,
+          &&lbl_POP_1,
+          &&lbl_PLUS,
+          &&lbl_MINUS,
+          &&lbl_TIMES,
+          &&lbl_UMINUS,
+          &&lbl_AND,
+          &&lbl_OR,
+          &&lbl_NOT,
+          &&lbl_INC,
+          &&lbl_DEC,
+          &&lbl_BITAND,
+          &&lbl_BITOR,
+          &&lbl_BITXOR,
+          &&lbl_BITNOT,
+          &&lbl_LSL,
+          &&lbl_LSR,
+          &&lbl_ASR,
+          &&lbl_ROR,
+          &&lbl_DIV,
+          &&lbl_MOD,
+          &&lbl_EQ,
+          &&lbl_LT,
+          &&lbl_GT,
+          &&lbl_LEQ,
+          &&lbl_GEQ,
+          &&lbl_NEQ,
+          &&lbl_JEQ_S,
+          &&lbl_JEQ_R,
+          &&lbl_JLT_S,
+          &&lbl_JLT_R,
+          &&lbl_JGT_S,
+          &&lbl_JGT_R,
+          &&lbl_JLEQ_S,
+          &&lbl_JLEQ_R,
+          &&lbl_JGEQ_S,
+          &&lbl_JGEQ_R,
+          &&lbl_JNEQ_S,
+          &&lbl_JNEQ_R,
+          &&lbl_JLTZ_S,
+          &&lbl_JGTZ_S,
+          &&lbl_JLEQZ_S,
+          &&lbl_JGEQZ_S,
+          &&lbl_JNEQZ_S,
+          &&lbl_JNEQZ_R,
+          &&lbl_JEQZ_S,
+          &&lbl_JEQZ_R,
+          &&lbl_JUMP_S,
+          &&lbl_JUMP_R,
+          &&lbl_QPLUS,
+          &&lbl_QMINUS,
+          &&lbl_QTIMES,
+          &&lbl_QUMINUS,
+          &&lbl_QDIV,
+          &&lbl_QMOD,
+          &&lbl_JCASE_1,
+          &&lbl_JRANGE_S,
+          &&lbl_JRANGE_R,
+          &&lbl_TESTGEQ_S,
+          &&lbl_TESTGEQ_R,
+          &&lbl_FPLUS,
+          &&lbl_FMINUS,
+          &&lbl_FTIMES,
+          &&lbl_FDIV,
+          &&lbl_FUMINUS,
+          &&lbl_FCMPL,
+          &&lbl_FCMPG,
+          &&lbl_DPLUS,
+          &&lbl_DMINUS,
+          &&lbl_DTIMES,
+          &&lbl_DDIV,
+          &&lbl_DUMINUS,
+          &&lbl_DCMPL,
+          &&lbl_DCMPG,
+          &&lbl_QCMP,
+          &&lbl_CONVNF,
+          &&lbl_CONVND,
+          &&lbl_CONVFN,
+          &&lbl_CONVDN,
+          &&lbl_CONVFD,
+          &&lbl_CONVDF,
+          &&lbl_CONVNC,
+          &&lbl_CONVNS,
+          &&lbl_CONVNQ,
+          &&lbl_CONVQN,
+          &&lbl_CONVQD,
+          &&lbl_BOUND_2,
+          &&lbl_NCHECK_2,
+          &&lbl_GCHECK_2,
+          &&lbl_ZCHECK_2,
+          &&lbl_FZCHECK_2,
+          &&lbl_DZCHECK_2,
+          &&lbl_QZCHECK_2,
+          &&lbl_ERROR_12,
+          &&lbl_ALIGNC,
+          &&lbl_ALIGNS,
+          &&lbl_FIXCOPY,
+          &&lbl_FLEXCOPY,
+          &&lbl_LINK,
+          &&lbl_SAVELINK,
+          &&lbl_JPROC,
+          &&lbl_SLIDE_1,
+          &&lbl_SLIDEW_1,
+          &&lbl_SLIDED_1,
+          &&lbl_SLIDEF_1,
+          &&lbl_SLIDEQ_1,
+          &&lbl_RESULTW,
+          &&lbl_RESULTD,
+          &&lbl_RESULTF,
+          &&lbl_RESULTQ,
+          &&lbl_RETURN,
+          &&lbl_LNUM_2,
+          &&lbl_BREAK_2,
+          &&lbl_ILLEGAL,
+          &&lbl_ILLEGAL,
+          &&lbl_ILLEGAL,
+          &&lbl_ILLEGAL,
+     };
+#endif
+
+#ifdef JTABLE
+/* Each action ends with an indexed jump to the next */
+#define ACTION(op) lbl_ ## op:
+#define ALSO(op)
+#define DEFAULT
+#define NEXT       goto *jtable[ir = *(pc0 = pc)]
+#else
+/* Actions are just cases in a big switch */
+#define ACTION(op) case K_ ## op:
+#define ALSO(op)   case K_ ## op:
+#define DEFAULT    default:
+#define NEXT       break
+#endif
+
+     level++;
+     do_find_proc;
+
+#ifdef PROFILE
+     prof_enter(cp, 0, PROF_CALL);
+#endif
+
+     frame();
+
+#ifdef JTABLE
+     NEXT;
+#else
+     while (TRUE) {
+#ifdef TRACE
+          if (dflag > 1) {
+               printf("pc=%s+%ld(%p) sp=%p bp=%p cp=%p",
+                      thisproc->p_name,
+                      (long) (pc - (uchar *) pointer(cp[CP_CODE])),
+                      pc, sp, bp, cp);
+               fflush(stdout);
+               for (int i = 0; i < 8; i++) printf(" %x", sp[i].i);
+               printf("\n");
+               printf("%6ld: %s\n", (long) (pc-imem), fmt_inst(pc));
+               fflush(stdout);
+          }
+#endif
+
+#ifdef PROFILE
+          ticks++;
+#endif
+
+          switch (ir = *(pc0 = pc)) {
+#endif
+
+          ACTION(PUSH_x1)
+          ALSO(PUSH_x1+1)
+          ALSO(PUSH_x1+2)
+          ALSO(PUSH_x1+3)
+          ALSO(PUSH_x1+4)
+          ALSO(PUSH_x1+5)
+          ALSO(PUSH_x1+6)
+          ALSO(PUSH_x1+7)
+               pc = pc0 + 1;
+               sp--; sp[0].i = ir-2;
+               NEXT;
+
+          ACTION(PUSH_1)
+               pc = pc0 + 2;
+               sp--; sp[0].i = get1(pc0+1);
+               NEXT;
+
+          ACTION(PUSH_2)
+               pc = pc0 + 3;
+               sp--; sp[0].i = get2(pc0+1);
+               NEXT;
+
+          ACTION(LDKW_1)
+               pc = pc0 + 2;
+               sp--; sp[0].i = const(get1(pc0+1)).i;
+               NEXT;
+
+          ACTION(LDKW_2)
+               pc = pc0 + 3;
+               sp--; sp[0].i = const(get2(pc0+1)).i;
+               NEXT;
+
+          ACTION(LDKF_1)
+               pc = pc0 + 2;
+               sp--; sp[0].f = const(get1(pc0+1)).f;
+               NEXT;
+
+          ACTION(LDKF_2)
+               pc = pc0 + 3;
+               sp--; sp[0].f = const(get2(pc0+1)).f;
+               NEXT;
+
+          ACTION(LOCAL_1)
+               pc = pc0 + 2;
+               sp--; sp[0].a = address(local(get1(pc0+1)));
+               NEXT;
+
+          ACTION(LOCAL_2)
+               pc = pc0 + 3;
+               sp--; sp[0].a = address(local(get2(pc0+1)));
+               NEXT;
+
+          ACTION(OFFSET)
+               pc = pc0 + 1;
+               sp++; sp[0].a = address(pointer(sp[0]) + sp[-1].i);
+               NEXT;
+
+          ACTION(INDEXS)
+               pc = pc0 + 1;
+               sp++; sp[0].a = address(pointer(sp[0]) + (sp[-1].i<<1));
+               NEXT;
+
+          ACTION(INDEXW)
+               pc = pc0 + 1;
+               sp++; sp[0].a = address(pointer(sp[0]) + (sp[-1].i<<2));
+               NEXT;
+
+          ACTION(INDEXD)
+               pc = pc0 + 1;
+               sp++; sp[0].a = address(pointer(sp[0]) + (sp[-1].i<<3));
+               NEXT;
+
+          ACTION(LOADW)
+               pc = pc0 + 1;
+               sp[0].i = indir(pointer(sp[0]), int);
+               NEXT;
+
+          ACTION(LOADS)
+               pc = pc0 + 1;
+               sp[0].i = indir(pointer(sp[0]), short);
+               NEXT;
+
+          ACTION(LOADC)
+               pc = pc0 + 1;
+               sp[0].i = indir(pointer(sp[0]), uchar);
+               NEXT;
+
+          ACTION(LOADF)
+               pc = pc0 + 1;
+               sp[0].f = indir(pointer(sp[0]), float);
+               NEXT;
+
+          ACTION(STOREW)
+               pc = pc0 + 1;
+               sp += 2; { indir(pointer(sp[-2]), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STORES)
+               pc = pc0 + 1;
+               sp += 2; { indir(pointer(sp[-2]), short) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STOREC)
+               pc = pc0 + 1;
+               sp += 2; { indir(pointer(sp[-2]), uchar) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STOREF)
+               pc = pc0 + 1;
+               sp += 2; { indir(pointer(sp[-2]), float) = sp[-1].f; }
+               NEXT;
+
+          ACTION(LDLW_x1)
+          ALSO(LDLW_x1+1)
+          ALSO(LDLW_x1+2)
+          ALSO(LDLW_x1+3)
+          ALSO(LDLW_x1+4)
+          ALSO(LDLW_x1+5)
+               pc = pc0 + 1;
+               sp--; sp[0].i = indir(local(ir*4-140), int);
+               NEXT;
+
+          ACTION(LDLW_x2)
+          ALSO(LDLW_x2+1)
+          ALSO(LDLW_x2+2)
+          ALSO(LDLW_x2+3)
+          ALSO(LDLW_x2+4)
+          ALSO(LDLW_x2+5)
+               pc = pc0 + 1;
+               sp--; sp[0].i = indir(local(ir*4-128), int);
+               NEXT;
+
+          ACTION(LDLW_1)
+               pc = pc0 + 2;
+               sp--; sp[0].i = indir(local(get1(pc0+1)), int);
+               NEXT;
+
+          ACTION(LDLW_2)
+               pc = pc0 + 3;
+               sp--; sp[0].i = indir(local(get2(pc0+1)), int);
+               NEXT;
+
+          ACTION(LDLS_1)
+               pc = pc0 + 2;
+               sp--; sp[0].i = indir(local(get1(pc0+1)), short);
+               NEXT;
+
+          ACTION(LDLS_2)
+               pc = pc0 + 3;
+               sp--; sp[0].i = indir(local(get2(pc0+1)), short);
+               NEXT;
+
+          ACTION(LDLC_1)
+               pc = pc0 + 2;
+               sp--; sp[0].i = indir(local(get1(pc0+1)), uchar);
+               NEXT;
+
+          ACTION(LDLC_2)
+               pc = pc0 + 3;
+               sp--; sp[0].i = indir(local(get2(pc0+1)), uchar);
+               NEXT;
+
+          ACTION(LDLF_1)
+               pc = pc0 + 2;
+               sp--; sp[0].f = indir(local(get1(pc0+1)), float);
+               NEXT;
+
+          ACTION(LDLF_2)
+               pc = pc0 + 3;
+               sp--; sp[0].f = indir(local(get2(pc0+1)), float);
+               NEXT;
+
+          ACTION(STLW_x1)
+          ALSO(STLW_x1+1)
+          ALSO(STLW_x1+2)
+          ALSO(STLW_x1+3)
+          ALSO(STLW_x1+4)
+          ALSO(STLW_x1+5)
+               pc = pc0 + 1;
+               sp += 1; { indir(local(ir*4-220), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLW_x2)
+          ALSO(STLW_x2+1)
+          ALSO(STLW_x2+2)
+          ALSO(STLW_x2+3)
+          ALSO(STLW_x2+4)
+          ALSO(STLW_x2+5)
+               pc = pc0 + 1;
+               sp += 1; { indir(local(ir*4-208), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLW_1)
+               pc = pc0 + 2;
+               sp += 1; { indir(local(get1(pc0+1)), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLW_2)
+               pc = pc0 + 3;
+               sp += 1; { indir(local(get2(pc0+1)), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLS_1)
+               pc = pc0 + 2;
+               sp += 1; { indir(local(get1(pc0+1)), short) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLS_2)
+               pc = pc0 + 3;
+               sp += 1; { indir(local(get2(pc0+1)), short) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLC_1)
+               pc = pc0 + 2;
+               sp += 1; { indir(local(get1(pc0+1)), uchar) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLC_2)
+               pc = pc0 + 3;
+               sp += 1; { indir(local(get2(pc0+1)), uchar) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STLF_1)
+               pc = pc0 + 2;
+               sp += 1; { indir(local(get1(pc0+1)), float) = sp[-1].f; }
+               NEXT;
+
+          ACTION(STLF_2)
+               pc = pc0 + 3;
+               sp += 1; { indir(local(get2(pc0+1)), float) = sp[-1].f; }
+               NEXT;
+
+          ACTION(LDGW_K)
+               pc = pc0 + 2;
+               sp--; sp[0].i = indir(pointer(const(get1(pc0+1))), int);
+               NEXT;
+
+          ACTION(LDGW_L)
+               pc = pc0 + 3;
+               sp--; sp[0].i = indir(pointer(const(get2(pc0+1))), int);
+               NEXT;
+
+          ACTION(LDGS_K)
+               pc = pc0 + 2;
+               sp--; sp[0].i = indir(pointer(const(get1(pc0+1))), short);
+               NEXT;
+
+          ACTION(LDGS_L)
+               pc = pc0 + 3;
+               sp--; sp[0].i = indir(pointer(const(get2(pc0+1))), short);
+               NEXT;
+
+          ACTION(LDGC_K)
+               pc = pc0 + 2;
+               sp--; sp[0].i = indir(pointer(const(get1(pc0+1))), uchar);
+               NEXT;
+
+          ACTION(LDGC_L)
+               pc = pc0 + 3;
+               sp--; sp[0].i = indir(pointer(const(get2(pc0+1))), uchar);
+               NEXT;
+
+          ACTION(LDGF_K)
+               pc = pc0 + 2;
+               sp--; sp[0].f = indir(pointer(const(get1(pc0+1))), float);
+               NEXT;
+
+          ACTION(LDGF_L)
+               pc = pc0 + 3;
+               sp--; sp[0].f = indir(pointer(const(get2(pc0+1))), float);
+               NEXT;
+
+          ACTION(STGW_K)
+               pc = pc0 + 2;
+               sp += 1; { indir(pointer(const(get1(pc0+1))), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STGW_L)
+               pc = pc0 + 3;
+               sp += 1; { indir(pointer(const(get2(pc0+1))), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STGS_K)
+               pc = pc0 + 2;
+               sp += 1; { indir(pointer(const(get1(pc0+1))), short) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STGS_L)
+               pc = pc0 + 3;
+               sp += 1; { indir(pointer(const(get2(pc0+1))), short) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STGC_K)
+               pc = pc0 + 2;
+               sp += 1; { indir(pointer(const(get1(pc0+1))), uchar) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STGC_L)
+               pc = pc0 + 3;
+               sp += 1; { indir(pointer(const(get2(pc0+1))), uchar) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STGF_K)
+               pc = pc0 + 2;
+               sp += 1; { indir(pointer(const(get1(pc0+1))), float) = sp[-1].f; }
+               NEXT;
+
+          ACTION(STGF_L)
+               pc = pc0 + 3;
+               sp += 1; { indir(pointer(const(get2(pc0+1))), float) = sp[-1].f; }
+               NEXT;
+
+          ACTION(LDNW_x1)
+          ALSO(LDNW_x1+1)
+          ALSO(LDNW_x1+2)
+          ALSO(LDNW_x1+3)
+          ALSO(LDNW_x1+4)
+          ALSO(LDNW_x1+5)
+          ALSO(LDNW_x1+6)
+          ALSO(LDNW_x1+7)
+          ALSO(LDNW_x1+8)
+          ALSO(LDNW_x1+9)
+          ALSO(LDNW_x1+10)
+          ALSO(LDNW_x1+11)
+          ALSO(LDNW_x1+12)
+          ALSO(LDNW_x1+13)
+          ALSO(LDNW_x1+14)
+               pc = pc0 + 1;
+               sp[0].i = indir(pointer(sp[0]) + ir*4-356, int);
+               NEXT;
+
+          ACTION(LDNW_1)
+               pc = pc0 + 2;
+               sp[0].i = indir(pointer(sp[0]) + get1(pc0+1), int);
+               NEXT;
+
+          ACTION(LDNW_2)
+               pc = pc0 + 3;
+               sp[0].i = indir(pointer(sp[0]) + get2(pc0+1), int);
+               NEXT;
+
+          ACTION(STNW_x1)
+          ALSO(STNW_x1+1)
+          ALSO(STNW_x1+2)
+          ALSO(STNW_x1+3)
+          ALSO(STNW_x1+4)
+          ALSO(STNW_x1+5)
+          ALSO(STNW_x1+6)
+          ALSO(STNW_x1+7)
+          ALSO(STNW_x1+8)
+          ALSO(STNW_x1+9)
+               pc = pc0 + 1;
+               sp += 2; { indir(pointer(sp[-2]) + ir*4-424, int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STNW_1)
+               pc = pc0 + 2;
+               sp += 2; { indir(pointer(sp[-2]) + get1(pc0+1), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STNW_2)
+               pc = pc0 + 3;
+               sp += 2; { indir(pointer(sp[-2]) + get2(pc0+1), int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(LDIW)
+               pc = pc0 + 1;
+               sp++; sp[0].i = subs(pointer(sp[0]), sp[-1].i, int);
+               NEXT;
+
+          ACTION(LDIF)
+               pc = pc0 + 1;
+               sp++; sp[0].f = subs(pointer(sp[0]), sp[-1].i, float);
+               NEXT;
+
+          ACTION(LDIS)
+               pc = pc0 + 1;
+               sp++; sp[0].i = subs(pointer(sp[0]), sp[-1].i, short);
+               NEXT;
+
+          ACTION(LDIC)
+               pc = pc0 + 1;
+               sp++; sp[0].i = subs(pointer(sp[0]), sp[-1].i, uchar);
+               NEXT;
+
+          ACTION(STIW)
+               pc = pc0 + 1;
+               sp += 3; { subs(pointer(sp[-2]), sp[-3].i, int) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STIF)
+               pc = pc0 + 1;
+               sp += 3; { subs(pointer(sp[-2]), sp[-3].i, float) = sp[-1].f; }
+               NEXT;
+
+          ACTION(STIS)
+               pc = pc0 + 1;
+               sp += 3; { subs(pointer(sp[-2]), sp[-3].i, short) = sp[-1].i; }
+               NEXT;
+
+          ACTION(STIC)
+               pc = pc0 + 1;
+               sp += 3; { subs(pointer(sp[-2]), sp[-3].i, uchar) = sp[-1].i; }
+               NEXT;
+
+          ACTION(LDID)
+               pc = pc0 + 1;
+               putdbl(&sp[0], getdbl((value *) &subs(pointer(sp[1]), sp[0].i, double)));
+               NEXT;
+
+          ACTION(STID)
+               pc = pc0 + 1;
+               sp += 4; { putdbl((value *) &subs(pointer(sp[-3]), sp[-4].i, double), getdbl(&sp[-2])); }
+               NEXT;
+
+          ACTION(LDIQ)
+               pc = pc0 + 1;
+               putlong(&sp[0], getlong((value *) &subs(pointer(sp[1]), sp[0].i, longint)));
+               NEXT;
+
+          ACTION(STIQ)
+               pc = pc0 + 1;
+               sp += 4; { putlong((value *) &subs(pointer(sp[-3]), sp[-4].i, longint), getlong(&sp[-2])); }
+               NEXT;
+
+          ACTION(LOADD)
+               pc = pc0 + 1;
+               sp--; putdbl(&sp[0], getdbl(valptr(sp[1])));
+               NEXT;
+
+          ACTION(STORED)
+               pc = pc0 + 1;
+               sp += 3; { putdbl(valptr(sp[-3]), getdbl(&sp[-2])); }
+               NEXT;
+
+          ACTION(LDKD_1)
+               pc = pc0 + 2;
+               sp -= 2; putdbl(&sp[0], getdbl(&const(get1(pc0+1))));
+               NEXT;
+
+          ACTION(LDKD_2)
+               pc = pc0 + 3;
+               sp -= 2; putdbl(&sp[0], getdbl(&const(get2(pc0+1))));
+               NEXT;
+
+          ACTION(LOADQ)
+               pc = pc0 + 1;
+               sp--; putlong(&sp[0], getlong(valptr(sp[1])));
+               NEXT;
+
+          ACTION(STOREQ)
+               pc = pc0 + 1;
+               sp += 3; { putlong(valptr(sp[-3]), getlong(&sp[-2])); }
+               NEXT;
+
+          ACTION(LDKQ_1)
+               pc = pc0 + 2;
+               sp -= 2; putlong(&sp[0], getlong(&const(get1(pc0+1))));
+               NEXT;
+
+          ACTION(LDKQ_2)
+               pc = pc0 + 3;
+               sp -= 2; putlong(&sp[0], getlong(&const(get2(pc0+1))));
+               NEXT;
+
+          ACTION(INCL_1)
+               pc = pc0 + 2;
+               { indir(local(get1(pc0+1)), int)++; }
+               NEXT;
+
+          ACTION(DECL_1)
+               pc = pc0 + 2;
+               { indir(local(get1(pc0+1)), int)--; }
+               NEXT;
+
+          ACTION(DUP)
+          ALSO(DUP+1)
+          ALSO(DUP+2)
+               pc = pc0 + 1;
+               { dup(ir-136, sp); }
+               NEXT;
+
+          ACTION(SWAP)
+               pc = pc0 + 1;
+               { swap(sp); }
+               NEXT;
+
+          ACTION(POP_1)
+               pc = pc0 + 2;
+               { sp += get1(pc0+1); }
+               NEXT;
+
+          ACTION(PLUS)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i + sp[-1].i;
+               NEXT;
+
+          ACTION(MINUS)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i - sp[-1].i;
+               NEXT;
+
+          ACTION(TIMES)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i * sp[-1].i;
+               NEXT;
+
+          ACTION(UMINUS)
+               pc = pc0 + 1;
+               sp[0].i = - sp[0].i;
+               NEXT;
+
+          ACTION(AND)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i && sp[-1].i;
+               NEXT;
+
+          ACTION(OR)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i || sp[-1].i;
+               NEXT;
+
+          ACTION(NOT)
+               pc = pc0 + 1;
+               sp[0].i = ! sp[0].i;
+               NEXT;
+
+          ACTION(INC)
+               pc = pc0 + 1;
+               sp[0].i = sp[0].i + 1;
+               NEXT;
+
+          ACTION(DEC)
+               pc = pc0 + 1;
+               sp[0].i = sp[0].i - 1;
+               NEXT;
+
+          ACTION(BITAND)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i & sp[-1].i;
+               NEXT;
+
+          ACTION(BITOR)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i | sp[-1].i;
+               NEXT;
+
+          ACTION(BITXOR)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i ^ sp[-1].i;
+               NEXT;
+
+          ACTION(BITNOT)
+               pc = pc0 + 1;
+               sp[0].i = ~ sp[0].i;
+               NEXT;
+
+          ACTION(LSL)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i << sp[-1].i;
+               NEXT;
+
+          ACTION(LSR)
+               pc = pc0 + 1;
+               sp++; sp[0].i = ((unsigned) sp[0].i) >> sp[-1].i;
+               NEXT;
+
+          ACTION(ASR)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i >> sp[-1].i;
+               NEXT;
+
+          ACTION(ROR)
+               pc = pc0 + 1;
+               sp++; sp[0].i = ror(sp[0].i, sp[-1].i);
+               NEXT;
+
+          ACTION(DIV)
+               pc = pc0 + 1;
+               sp++; sp[0].i = int_divop(sp[0].i, sp[-1].i, 1);
+               NEXT;
+
+          ACTION(MOD)
+               pc = pc0 + 1;
+               sp++; sp[0].i = int_divop(sp[0].i, sp[-1].i, 0);
+               NEXT;
+
+          ACTION(EQ)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i == sp[-1].i;
+               NEXT;
+
+          ACTION(LT)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i < sp[-1].i;
+               NEXT;
+
+          ACTION(GT)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i > sp[-1].i;
+               NEXT;
+
+          ACTION(LEQ)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i <= sp[-1].i;
+               NEXT;
+
+          ACTION(GEQ)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i >= sp[-1].i;
+               NEXT;
+
+          ACTION(NEQ)
+               pc = pc0 + 1;
+               sp++; sp[0].i = sp[0].i != sp[-1].i;
+               NEXT;
+
+          ACTION(JEQ_S)
+               pc = pc0 + 2;
+               sp += 2; { if (sp[-1].i == sp[-2].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JEQ_R)
+               pc = pc0 + 3;
+               sp += 2; { if (sp[-1].i == sp[-2].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JLT_S)
+               pc = pc0 + 2;
+               sp += 2; { if (sp[-1].i < sp[-2].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JLT_R)
+               pc = pc0 + 3;
+               sp += 2; { if (sp[-1].i < sp[-2].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JGT_S)
+               pc = pc0 + 2;
+               sp += 2; { if (sp[-1].i > sp[-2].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JGT_R)
+               pc = pc0 + 3;
+               sp += 2; { if (sp[-1].i > sp[-2].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JLEQ_S)
+               pc = pc0 + 2;
+               sp += 2; { if (sp[-1].i <= sp[-2].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JLEQ_R)
+               pc = pc0 + 3;
+               sp += 2; { if (sp[-1].i <= sp[-2].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JGEQ_S)
+               pc = pc0 + 2;
+               sp += 2; { if (sp[-1].i >= sp[-2].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JGEQ_R)
+               pc = pc0 + 3;
+               sp += 2; { if (sp[-1].i >= sp[-2].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JNEQ_S)
+               pc = pc0 + 2;
+               sp += 2; { if (sp[-1].i != sp[-2].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JNEQ_R)
+               pc = pc0 + 3;
+               sp += 2; { if (sp[-1].i != sp[-2].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JLTZ_S)
+               pc = pc0 + 2;
+               sp += 1; { if (sp[-1].i < 0) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JGTZ_S)
+               pc = pc0 + 2;
+               sp += 1; { if (sp[-1].i > 0) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JLEQZ_S)
+               pc = pc0 + 2;
+               sp += 1; { if (sp[-1].i <= 0) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JGEQZ_S)
+               pc = pc0 + 2;
+               sp += 1; { if (sp[-1].i >= 0) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JNEQZ_S)
+               pc = pc0 + 2;
+               sp += 1; { if (sp[-1].i != 0) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JNEQZ_R)
+               pc = pc0 + 3;
+               sp += 1; { if (sp[-1].i != 0) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JEQZ_S)
+               pc = pc0 + 2;
+               sp += 1; { if (sp[-1].i == 0) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JEQZ_R)
+               pc = pc0 + 3;
+               sp += 1; { if (sp[-1].i == 0) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(JUMP_S)
+               pc = pc0 + 2;
+               { jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JUMP_R)
+               pc = pc0 + 3;
+               { jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(QPLUS)
+               pc = pc0 + 1;
+               sp += 2; putlong(&sp[0], getlong(&sp[0]) + getlong(&sp[-2]));
+               NEXT;
+
+          ACTION(QMINUS)
+               pc = pc0 + 1;
+               sp += 2; putlong(&sp[0], getlong(&sp[0]) - getlong(&sp[-2]));
+               NEXT;
+
+          ACTION(QTIMES)
+               pc = pc0 + 1;
+               sp += 2; putlong(&sp[0], getlong(&sp[0]) * getlong(&sp[-2]));
+               NEXT;
+
+          ACTION(QUMINUS)
+               pc = pc0 + 1;
+               putlong(&sp[0], - getlong(&sp[0]));
+               NEXT;
+
+          ACTION(QDIV)
+               pc = pc0 + 1;
+               sp += 2; putlong(&sp[0], longint_divop(getlong(&sp[0]), getlong(&sp[-2]), 1));
+               NEXT;
+
+          ACTION(QMOD)
+               pc = pc0 + 1;
+               sp += 2; putlong(&sp[0], longint_divop(getlong(&sp[0]), getlong(&sp[-2]), 0));
+               NEXT;
+
+          ACTION(JCASE_1)
+               pc = pc0 + 2;
+               sp += 1; { jcase(sp[-1].i, get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JRANGE_S)
+               pc = pc0 + 2;
+               sp += 3; { if (sp[-1].i >= sp[-2].i && sp[-1].i <= sp[-3].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(JRANGE_R)
+               pc = pc0 + 3;
+               sp += 3; { if (sp[-1].i >= sp[-2].i && sp[-1].i <= sp[-3].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(TESTGEQ_S)
+               pc = pc0 + 2;
+               sp++; { if (sp[0].i >= sp[-1].i) jump(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(TESTGEQ_R)
+               pc = pc0 + 3;
+               sp++; { if (sp[0].i >= sp[-1].i) jump(get2(pc0+1)); }
+               NEXT;
+
+          ACTION(FPLUS)
+               pc = pc0 + 1;
+               sp++; sp[0].f = sp[0].f + sp[-1].f;
+               NEXT;
+
+          ACTION(FMINUS)
+               pc = pc0 + 1;
+               sp++; sp[0].f = sp[0].f - sp[-1].f;
+               NEXT;
+
+          ACTION(FTIMES)
+               pc = pc0 + 1;
+               sp++; sp[0].f = sp[0].f * sp[-1].f;
+               NEXT;
+
+          ACTION(FDIV)
+               pc = pc0 + 1;
+               sp++; sp[0].f = sp[0].f / sp[-1].f;
+               NEXT;
+
+          ACTION(FUMINUS)
+               pc = pc0 + 1;
+               sp[0].f = - sp[0].f;
+               NEXT;
+
+          ACTION(FCMPL)
+               pc = pc0 + 1;
+               sp++; sp[0].i = fcmpl(sp[0].f, sp[-1].f);
+               NEXT;
+
+          ACTION(FCMPG)
+               pc = pc0 + 1;
+               sp++; sp[0].i = fcmpg(sp[0].f, sp[-1].f);
+               NEXT;
+
+          ACTION(DPLUS)
+               pc = pc0 + 1;
+               sp += 2; putdbl(&sp[0], getdbl(&sp[0]) + getdbl(&sp[-2]));
+               NEXT;
+
+          ACTION(DMINUS)
+               pc = pc0 + 1;
+               sp += 2; putdbl(&sp[0], getdbl(&sp[0]) - getdbl(&sp[-2]));
+               NEXT;
+
+          ACTION(DTIMES)
+               pc = pc0 + 1;
+               sp += 2; putdbl(&sp[0], getdbl(&sp[0]) * getdbl(&sp[-2]));
+               NEXT;
+
+          ACTION(DDIV)
+               pc = pc0 + 1;
+               sp += 2; putdbl(&sp[0], getdbl(&sp[0]) / getdbl(&sp[-2]));
+               NEXT;
+
+          ACTION(DUMINUS)
+               pc = pc0 + 1;
+               putdbl(&sp[0], - getdbl(&sp[0]));
+               NEXT;
+
+          ACTION(DCMPL)
+               pc = pc0 + 1;
+               sp += 3; sp[0].i = fcmpl(getdbl(&sp[-1]), getdbl(&sp[-3]));
+               NEXT;
+
+          ACTION(DCMPG)
+               pc = pc0 + 1;
+               sp += 3; sp[0].i = fcmpg(getdbl(&sp[-1]), getdbl(&sp[-3]));
+               NEXT;
+
+          ACTION(QCMP)
+               pc = pc0 + 1;
+               sp += 3; sp[0].i = lcmp(getlong(&sp[-1]), getlong(&sp[-3]));
+               NEXT;
+
+          ACTION(CONVNF)
+               pc = pc0 + 1;
+               sp[0].f = flo_conv(sp[0].i);
+               NEXT;
+
+          ACTION(CONVND)
+               pc = pc0 + 1;
+               sp--; putdbl(&sp[0], flo_conv(sp[1].i));
+               NEXT;
+
+          ACTION(CONVFN)
+               pc = pc0 + 1;
+               sp[0].i = (int) sp[0].f;
+               NEXT;
+
+          ACTION(CONVDN)
+               pc = pc0 + 1;
+               sp++; sp[0].i = (int) getdbl(&sp[-1]);
+               NEXT;
+
+          ACTION(CONVFD)
+               pc = pc0 + 1;
+               sp--; putdbl(&sp[0], sp[1].f);
+               NEXT;
+
+          ACTION(CONVDF)
+               pc = pc0 + 1;
+               sp++; sp[0].f = (float) getdbl(&sp[-1]);
+               NEXT;
+
+          ACTION(CONVNC)
+               pc = pc0 + 1;
+               sp[0].i = sp[0].i & 0xff;
+               NEXT;
+
+          ACTION(CONVNS)
+               pc = pc0 + 1;
+               sp[0].i = (short) sp[0].i;
+               NEXT;
+
+          ACTION(CONVNQ)
+               pc = pc0 + 1;
+               sp--; putlong(&sp[0], sp[1].i);
+               NEXT;
+
+          ACTION(CONVQN)
+               pc = pc0 + 1;
+               sp++; sp[0].i = (int) getlong(&sp[-1]);
+               NEXT;
+
+          ACTION(CONVQD)
+               pc = pc0 + 1;
+               putdbl(&sp[0], flo_convq(getlong(&sp[0])));
+               NEXT;
+
+          ACTION(BOUND_2)
+               pc = pc0 + 3;
+               sp++; sp[0].i = czech2(boundcheck, sp[0].i, sp[-1].i, get2(pc0+1));
+               NEXT;
+
+          ACTION(NCHECK_2)
+               pc = pc0 + 3;
+               sp[0].a = address(czech(nullcheck, pointer(sp[0]), get2(pc0+1)));
+               NEXT;
+
+          ACTION(GCHECK_2)
+               pc = pc0 + 3;
+               sp += 1; { czech(globcheck, valptr(sp[-1]), get2(pc0+1)); }
+               NEXT;
+
+          ACTION(ZCHECK_2)
+               pc = pc0 + 3;
+               sp[0].i = czech(zerocheck, sp[0].i, get2(pc0+1));
+               NEXT;
+
+          ACTION(FZCHECK_2)
+               pc = pc0 + 3;
+               sp[0].f = czech(fzerocheck, sp[0].f, get2(pc0+1));
+               NEXT;
+
+          ACTION(DZCHECK_2)
+               pc = pc0 + 3;
+               putdbl(&sp[0], czech(fzerocheck, getdbl(&sp[0]), get2(pc0+1)));
+               NEXT;
+
+          ACTION(QZCHECK_2)
+               pc = pc0 + 3;
+               putlong(&sp[0], czech(lzerocheck, getlong(&sp[0]), get2(pc0+1)));
+               NEXT;
+
+          ACTION(ERROR_12)
+               pc = pc0 + 4;
+               { error(get1(pc0+1), get2(pc0+2)); }
+               NEXT;
+
+          ACTION(ALIGNC)
+               pc = pc0 + 1;
+               sp[0].i = alignx(sp[0].i, 8);
+               NEXT;
+
+          ACTION(ALIGNS)
+               pc = pc0 + 1;
+               sp[0].i = alignx(sp[0].i, 16);
+               NEXT;
+
+          ACTION(FIXCOPY)
+               pc = pc0 + 1;
+               sp += 3; { fixcopy(pointer(sp[-1]), pointer(sp[-2]), sp[-3].i); }
+               NEXT;
+
+          ACTION(FLEXCOPY)
+               pc = pc0 + 1;
+               sp += 2; { flexcopy(pointer(sp[-1]), sp[-2].i); }
+               NEXT;
+
+          ACTION(LINK)
+               pc = pc0 + 1;
+               sp += 1; { statlink = valptr(sp[-1]); }
+               NEXT;
+
+          ACTION(SAVELINK)
+               pc = pc0 + 1;
+               { bp[SL].a = address(statlink); }
+               NEXT;
+
+          ACTION(JPROC)
+               pc = pc0 + 1;
+               { 
+     value *p = valptr(sp[0]);
+     sp -= HEAD-1; sp[BP].a = address(bp); sp[PC].a = address(pc);
+     if (! interpreted(p)) {
+#ifdef PROFILE
+          /* Calling a native-code routine */
+          prof_enter(p, ticks, PROF_PRIM);
+          ticks = 0;
+#endif
+#ifdef OBXDEB
+          prim_bp = sp;
+#endif
+          primcall(p, sp);
+#ifdef OBXDEB
+          prim_bp = NULL;
+#endif
+     } else {
+#ifdef PROFILE
+          prof_enter(p, ticks, PROF_CALL);
+#endif
+          cp = p; pc = pointer(cp[CP_CODE]);
+          do_find_proc;
+          frame();
+     }
+ }
+               NEXT;
+
+          ACTION(SLIDE_1)
+               pc = pc0 + 2;
+               { slide(get1(pc0+1)); }
+               NEXT;
+
+          ACTION(SLIDEW_1)
+               pc = pc0 + 2;
+               { slide(get1(pc0+1)); sp--; sp[0].i = ob_res.i; }
+               NEXT;
+
+          ACTION(SLIDED_1)
+               pc = pc0 + 2;
+               { slide(get1(pc0+1)); sp -= 2; 
+                                putdbl(&sp[0], getdbl(&ob_res)); }
+               NEXT;
+
+          ACTION(SLIDEF_1)
+               pc = pc0 + 2;
+               { slide(get1(pc0+1)); sp--; sp[0].f = ob_res.f; }
+               NEXT;
+
+          ACTION(SLIDEQ_1)
+               pc = pc0 + 2;
+               { slide(get1(pc0+1)); sp -= 2;
+                                putlong(&sp[0], getlong(&ob_res)); }
+               NEXT;
+
+          ACTION(RESULTW)
+               pc = pc0 + 1;
+               sp += 1; { ob_res = sp[-1]; }
+               NEXT;
+
+          ACTION(RESULTD)
+               pc = pc0 + 1;
+               sp += 2; { putdbl(&ob_res, getdbl(&sp[-2])); }
+               NEXT;
+
+          ACTION(RESULTF)
+               pc = pc0 + 1;
+               sp += 1; { ob_res.f = sp[-1].f; }
+               NEXT;
+
+          ACTION(RESULTQ)
+               pc = pc0 + 1;
+               sp += 2; { putlong(&ob_res, getlong(&sp[-2])); }
+               NEXT;
+
+          ACTION(RETURN)
+               pc = pc0 + 1;
+               { 
+     if (bp == base) {
+          level--;
+#ifdef PROFILE
+          prof_exit(NULL, ticks);
+#endif
+          return;
+     }
+
+     sp = bp; pc = pointer(sp[PC]); bp = valptr(sp[BP]); cp = valptr(bp[CP]);
+     do_find_proc;
+#ifdef PROFILE
+     prof_exit(cp, ticks);
+     ticks = 0;
+#endif
+     cond_break();
+ }
+               NEXT;
+
+          ACTION(LNUM_2)
+               pc = pc0 + 3;
+               { 
+#ifdef PROFILE
+     if (lflag) { 
+          static module m = NULL; /* Cache most recent module */
+          ticks--;
+          if (m == NULL || cp < (value *) m->m_addr 
+                || cp >= (value *) (m->m_addr + m->m_length)) {
+               m = find_module(cp);
+          }
+          m->m_lcount[get2(pc0+1)-1]++; 
+     }
+#endif
+#ifdef OBXDEB
+     if (intflag)
+          debug_break(cp, bp, pc0, "interrupt");
+     else if (one_shot) 
+          debug_break(cp, bp, pc0, "line");
+#endif
+ }
+               NEXT;
+
+          ACTION(BREAK_2)
+               pc = pc0 + 3;
+               { 
+#ifdef OBXDEB
+     debug_break(cp, bp, pc0, "break");
+#endif
+ }
+               NEXT;
+
+
+          ACTION(ILLEGAL)
+          DEFAULT
+               panic("*illegal instruction %d", ir);
+#ifndef JTABLE
+          }
+     }
+#endif
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/keiko/keiko.h	Mon Sep 10 20:34:00 2018 +0100
@@ -0,0 +1,719 @@
+/* Header file -- generated by iset.tcl */
+
+#define NTEMPLATES 290
+#define NTRIE 995
+#define MAXARGS 2
+
+#define __INSTRS__(i) \
+     i(ILLEGAL) \
+     i(PUSH) \
+     i(LDKW) \
+     i(LDKF) \
+     i(LOCAL) \
+     i(OFFSET) \
+     i(INDEXS) \
+     i(INDEXW) \
+     i(INDEXD) \
+     i(LOADW) \
+     i(LOADS) \
+     i(LOADC) \
+     i(LOADF) \
+     i(STOREW) \
+     i(STORES) \
+     i(STOREC) \
+     i(STOREF) \
+     i(LDLW, I_LOCAL|IARG, I_LOADW) \
+     i(LDLS, I_LOCAL|IARG, I_LOADS) \
+     i(LDLC, I_LOCAL|IARG, I_LOADC) \
+     i(LDLF, I_LOCAL|IARG, I_LOADF) \
+     i(STLW, I_LOCAL|IARG, I_STOREW) \
+     i(STLS, I_LOCAL|IARG, I_STORES) \
+     i(STLC, I_LOCAL|IARG, I_STOREC) \
+     i(STLF, I_LOCAL|IARG, I_STOREF) \
+     i(LDGW, I_LDKW|IARG, I_LOADW) \
+     i(LDGS, I_LDKW|IARG, I_LOADS) \
+     i(LDGC, I_LDKW|IARG, I_LOADC) \
+     i(LDGF, I_LDKW|IARG, I_LOADF) \
+     i(STGW, I_LDKW|IARG, I_STOREW) \
+     i(STGS, I_LDKW|IARG, I_STORES) \
+     i(STGC, I_LDKW|IARG, I_STOREC) \
+     i(STGF, I_LDKW|IARG, I_STOREF) \
+     i(LDNW, I_PUSH|IARG, I_OFFSET, I_LOADW) \
+     i(STNW, I_PUSH|IARG, I_OFFSET, I_STOREW) \
+     i(LDIW) \
+     i(LDIF) \
+     i(LDIS) \
+     i(LDIC) \
+     i(STIW) \
+     i(STIF) \
+     i(STIS) \
+     i(STIC) \
+     i(LDID) \
+     i(STID) \
+     i(LDIQ, I_INDEXD, I_LOADQ) \
+     i(STIQ, I_INDEXD, I_STOREQ) \
+     i(LOADD) \
+     i(STORED) \
+     i(LDKD) \
+     i(LOADQ) \
+     i(STOREQ) \
+     i(LDKQ) \
+     i(LDLD, I_LOCAL|IARG, I_LOADD) \
+     i(STLD, I_LOCAL|IARG, I_STORED) \
+     i(LDGD, I_LDKW|IARG, I_LOADD) \
+     i(STGD, I_LDKW|IARG, I_STORED) \
+     i(LDLQ) \
+     i(STLQ) \
+     i(LDGQ) \
+     i(STGQ) \
+     i(INCL, I_LDLW|IARG, I_INC, I_STLW|IARG) \
+     i(DECL, I_LDLW|IARG, I_DEC, I_STLW|IARG) \
+     i(DUP) \
+     i(SWAP) \
+     i(POP) \
+     i(PLUS) \
+     i(MINUS) \
+     i(TIMES) \
+     i(UMINUS) \
+     i(AND) \
+     i(OR) \
+     i(NOT) \
+     i(INC, I_PUSH|ICON, 1, I_PLUS) \
+     i(DEC, I_PUSH|ICON, 1, I_MINUS) \
+     i(BITAND) \
+     i(BITOR) \
+     i(BITXOR) \
+     i(BITNOT) \
+     i(LSL) \
+     i(LSR) \
+     i(ASR) \
+     i(ROR) \
+     i(DIV) \
+     i(MOD) \
+     i(EQ) \
+     i(LT) \
+     i(GT) \
+     i(LEQ) \
+     i(GEQ) \
+     i(NEQ) \
+     i(JEQ) \
+     i(JLT) \
+     i(JGT) \
+     i(JLEQ) \
+     i(JGEQ) \
+     i(JNEQ) \
+     i(JLTZ, I_PUSH|ICON, 0, I_JLT|IARG) \
+     i(JGTZ, I_PUSH|ICON, 0, I_JGT|IARG) \
+     i(JLEQZ, I_PUSH|ICON, 0, I_JLEQ|IARG) \
+     i(JGEQZ, I_PUSH|ICON, 0, I_JGEQ|IARG) \
+     i(JNEQZ, I_PUSH|ICON, 0, I_JNEQ|IARG) \
+     i(JEQZ, I_PUSH|ICON, 0, I_JEQ|IARG) \
+     i(JUMP) \
+     i(QPLUS) \
+     i(QMINUS) \
+     i(QTIMES) \
+     i(QUMINUS) \
+     i(QDIV) \
+     i(QMOD) \
+     i(QINC) \
+     i(QDEC) \
+     i(JCASE) \
+     i(CASEL) \
+     i(JRANGE) \
+     i(TESTGEQ) \
+     i(FPLUS) \
+     i(FMINUS) \
+     i(FTIMES) \
+     i(FDIV) \
+     i(FUMINUS) \
+     i(FCMPL) \
+     i(FCMPG) \
+     i(FEQ) \
+     i(FNEQ) \
+     i(FLT) \
+     i(FGT) \
+     i(FLEQ) \
+     i(FGEQ) \
+     i(FJEQ) \
+     i(FJNEQ) \
+     i(FJLT) \
+     i(FJGT) \
+     i(FJLEQ) \
+     i(FJGEQ) \
+     i(FJNLT) \
+     i(FJNGT) \
+     i(FJNLEQ) \
+     i(FJNGEQ) \
+     i(DPLUS) \
+     i(DMINUS) \
+     i(DTIMES) \
+     i(DDIV) \
+     i(DUMINUS) \
+     i(DCMPL) \
+     i(DCMPG) \
+     i(DEQ) \
+     i(DNEQ) \
+     i(DLT) \
+     i(DGT) \
+     i(DLEQ) \
+     i(DGEQ) \
+     i(DJEQ) \
+     i(DJNEQ) \
+     i(DJLT) \
+     i(DJGT) \
+     i(DJLEQ) \
+     i(DJGEQ) \
+     i(DJNLT) \
+     i(DJNGT) \
+     i(DJNLEQ) \
+     i(DJNGEQ) \
+     i(QCMP) \
+     i(QEQ) \
+     i(QLT) \
+     i(QGT) \
+     i(QLEQ) \
+     i(QGEQ) \
+     i(QNEQ) \
+     i(QJEQ) \
+     i(QJLT) \
+     i(QJGT) \
+     i(QJLEQ) \
+     i(QJGEQ) \
+     i(QJNEQ) \
+     i(CONVNF) \
+     i(CONVND) \
+     i(CONVFN) \
+     i(CONVDN) \
+     i(CONVFD) \
+     i(CONVDF) \
+     i(CONVNC) \
+     i(CONVNS) \
+     i(CONVNQ) \
+     i(CONVQN) \
+     i(CONVQD) \
+     i(BOUND) \
+     i(NCHECK) \
+     i(GCHECK) \
+     i(ZCHECK) \
+     i(FZCHECK) \
+     i(DZCHECK) \
+     i(QZCHECK) \
+     i(ERROR) \
+     i(EASSERT) \
+     i(ALIGNC) \
+     i(ALIGNS) \
+     i(FIXCOPY) \
+     i(FLEXCOPY) \
+     i(CALL) \
+     i(CALLW) \
+     i(CALLQ) \
+     i(CALLF) \
+     i(CALLD) \
+     i(LINK) \
+     i(SAVELINK) \
+     i(JPROC) \
+     i(SLIDE) \
+     i(SLIDEW) \
+     i(SLIDED) \
+     i(SLIDEF) \
+     i(SLIDEQ) \
+     i(RETURNW) \
+     i(RETURNF) \
+     i(RETURND) \
+     i(RETURNQ) \
+     i(RESULTW) \
+     i(RESULTD) \
+     i(RESULTF) \
+     i(RESULTQ) \
+     i(RETURN) \
+     i(LNUM) \
+     i(BREAK) \
+     i(REG) \
+     i(ADDR) \
+     i(STACKW) \
+     i(STACKQ) \
+     i(CON)
+
+#define __i1__(sym, ...) I_##sym,
+enum { __INSTRS__(__i1__) };
+
+#define __DIRS__(d) \
+     d(ILLEGAL) \
+     d(CONST) \
+     d(FCONST) \
+     d(DCONST) \
+     d(QCONST) \
+     d(GLOBAL) \
+     d(LABEL) \
+     d(PROC) \
+     d(END) \
+     d(PRIMDEF) \
+     d(DEFINE) \
+     d(STRING) \
+     d(GLOVAR) \
+     d(WORD) \
+     d(MODULE) \
+     d(ENDHDR) \
+     d(IMPORT) \
+     d(STKMAP) \
+     d(LINE) \
+     d(PCALL) \
+     d(PCALLW)
+
+#define __d1__(sym) D_##sym,
+enum { __DIRS__(__d1__) };
+
+#define K_ILLEGAL 0
+#define K_PUSH_x1 1
+#define K_PUSH_1 9
+#define K_PUSH_2 10
+#define K_LDKW_1 11
+#define K_LDKW_2 12
+#define K_LDKF_1 13
+#define K_LDKF_2 14
+#define K_LOCAL_1 15
+#define K_LOCAL_2 16
+#define K_OFFSET 17
+#define K_INDEXS 18
+#define K_INDEXW 19
+#define K_INDEXD 20
+#define K_LOADW 21
+#define K_LOADS 22
+#define K_LOADC 23
+#define K_LOADF 24
+#define K_STOREW 25
+#define K_STORES 26
+#define K_STOREC 27
+#define K_STOREF 28
+#define K_LDLW_x1 29
+#define K_LDLW_x2 35
+#define K_LDLW_1 41
+#define K_LDLW_2 42
+#define K_LDLS_1 43
+#define K_LDLS_2 44
+#define K_LDLC_1 45
+#define K_LDLC_2 46
+#define K_LDLF_1 47
+#define K_LDLF_2 48
+#define K_STLW_x1 49
+#define K_STLW_x2 55
+#define K_STLW_1 61
+#define K_STLW_2 62
+#define K_STLS_1 63
+#define K_STLS_2 64
+#define K_STLC_1 65
+#define K_STLC_2 66
+#define K_STLF_1 67
+#define K_STLF_2 68
+#define K_LDGW_K 69
+#define K_LDGW_L 70
+#define K_LDGS_K 71
+#define K_LDGS_L 72
+#define K_LDGC_K 73
+#define K_LDGC_L 74
+#define K_LDGF_K 75
+#define K_LDGF_L 76
+#define K_STGW_K 77
+#define K_STGW_L 78
+#define K_STGS_K 79
+#define K_STGS_L 80
+#define K_STGC_K 81
+#define K_STGC_L 82
+#define K_STGF_K 83
+#define K_STGF_L 84
+#define K_LDNW_x1 85
+#define K_LDNW_1 100
+#define K_LDNW_2 101
+#define K_STNW_x1 102
+#define K_STNW_1 112
+#define K_STNW_2 113
+#define K_LDIW 114
+#define K_LDIF 115
+#define K_LDIS 116
+#define K_LDIC 117
+#define K_STIW 118
+#define K_STIF 119
+#define K_STIS 120
+#define K_STIC 121
+#define K_LDID 122
+#define K_STID 123
+#define K_LDIQ 124
+#define K_STIQ 125
+#define K_LOADD 126
+#define K_STORED 127
+#define K_LDKD_1 128
+#define K_LDKD_2 129
+#define K_LOADQ 130
+#define K_STOREQ 131
+#define K_LDKQ_1 132
+#define K_LDKQ_2 133
+#define K_INCL_1 134
+#define K_DECL_1 135
+#define K_DUP 136
+#define K_SWAP 139
+#define K_POP_1 140
+#define K_PLUS 141
+#define K_MINUS 142
+#define K_TIMES 143
+#define K_UMINUS 144
+#define K_AND 145
+#define K_OR 146
+#define K_NOT 147
+#define K_INC 148
+#define K_DEC 149
+#define K_BITAND 150
+#define K_BITOR 151
+#define K_BITXOR 152
+#define K_BITNOT 153
+#define K_LSL 154
+#define K_LSR 155
+#define K_ASR 156
+#define K_ROR 157
+#define K_DIV 158
+#define K_MOD 159
+#define K_EQ 160
+#define K_LT 161
+#define K_GT 162
+#define K_LEQ 163
+#define K_GEQ 164
+#define K_NEQ 165
+#define K_JEQ_S 166
+#define K_JEQ_R 167
+#define K_JLT_S 168
+#define K_JLT_R 169
+#define K_JGT_S 170
+#define K_JGT_R 171
+#define K_JLEQ_S 172
+#define K_JLEQ_R 173
+#define K_JGEQ_S 174
+#define K_JGEQ_R 175
+#define K_JNEQ_S 176
+#define K_JNEQ_R 177
+#define K_JLTZ_S 178
+#define K_JGTZ_S 179
+#define K_JLEQZ_S 180
+#define K_JGEQZ_S 181
+#define K_JNEQZ_S 182
+#define K_JNEQZ_R 183
+#define K_JEQZ_S 184
+#define K_JEQZ_R 185
+#define K_JUMP_S 186
+#define K_JUMP_R 187
+#define K_QPLUS 188
+#define K_QMINUS 189
+#define K_QTIMES 190
+#define K_QUMINUS 191
+#define K_QDIV 192
+#define K_QMOD 193
+#define K_JCASE_1 194
+#define K_JRANGE_S 195
+#define K_JRANGE_R 196
+#define K_TESTGEQ_S 197
+#define K_TESTGEQ_R 198
+#define K_FPLUS 199
+#define K_FMINUS 200
+#define K_FTIMES 201
+#define K_FDIV 202
+#define K_FUMINUS 203
+#define K_FCMPL 204
+#define K_FCMPG 205
+#define K_DPLUS 206
+#define K_DMINUS 207
+#define K_DTIMES 208
+#define K_DDIV 209
+#define K_DUMINUS 210
+#define K_DCMPL 211
+#define K_DCMPG 212
+#define K_QCMP 213
+#define K_CONVNF 214
+#define K_CONVND 215
+#define K_CONVFN 216
+#define K_CONVDN 217
+#define K_CONVFD 218
+#define K_CONVDF 219
+#define K_CONVNC 220
+#define K_CONVNS 221
+#define K_CONVNQ 222
+#define K_CONVQN 223
+#define K_CONVQD 224
+#define K_BOUND_2 225
+#define K_NCHECK_2 226
+#define K_GCHECK_2 227
+#define K_ZCHECK_2 228
+#define K_FZCHECK_2 229
+#define K_DZCHECK_2 230
+#define K_QZCHECK_2 231
+#define K_ERROR_12 232
+#define K_ALIGNC 233
+#define K_ALIGNS 234
+#define K_FIXCOPY 235
+#define K_FLEXCOPY 236
+#define K_LINK 237
+#define K_SAVELINK 238
+#define K_JPROC 239
+#define K_SLIDE_1 240
+#define K_SLIDEW_1 241
+#define K_SLIDED_1 242
+#define K_SLIDEF_1 243
+#define K_SLIDEQ_1 244
+#define K_RESULTW 245
+#define K_RESULTD 246
+#define K_RESULTF 247
+#define K_RESULTQ 248
+#define K_RETURN 249
+#define K_LNUM_2 250
+#define K_BREAK_2 251
+
+#define __OPCODES__(o) \
+     o(ILLEGAL, ILLEGAL, "", 0, 1) \
+     o(PUSH_x1, PUSH, "N", -1, 1) \
+     o(PUSH_x1, PUSH, "N", 0, 1) \
+     o(PUSH_x1, PUSH, "N", 1, 1) \
+     o(PUSH_x1, PUSH, "N", 2, 1) \
+     o(PUSH_x1, PUSH, "N", 3, 1) \
+     o(PUSH_x1, PUSH, "N", 4, 1) \
+     o(PUSH_x1, PUSH, "N", 5, 1) \
+     o(PUSH_x1, PUSH, "N", 6, 1) \
+     o(PUSH_1, PUSH, "1", 0, 2) \
+     o(PUSH_2, PUSH, "2", 0, 3) \
+     o(LDKW_1, LDKW, "1", 0, 2) \
+     o(LDKW_2, LDKW, "2", 0, 3) \
+     o(LDKF_1, LDKF, "1", 0, 2) \
+     o(LDKF_2, LDKF, "2", 0, 3) \
+     o(LOCAL_1, LOCAL, "1", 0, 2) \
+     o(LOCAL_2, LOCAL, "2", 0, 3) \
+     o(OFFSET, OFFSET, "", 0, 1) \
+     o(INDEXS, INDEXS, "", 0, 1) \
+     o(INDEXW, INDEXW, "", 0, 1) \
+     o(INDEXD, INDEXD, "", 0, 1) \
+     o(LOADW, LOADW, "", 0, 1) \
+     o(LOADS, LOADS, "", 0, 1) \
+     o(LOADC, LOADC, "", 0, 1) \
+     o(LOADF, LOADF, "", 0, 1) \
+     o(STOREW, STOREW, "", 0, 1) \
+     o(STORES, STORES, "", 0, 1) \
+     o(STOREC, STOREC, "", 0, 1) \
+     o(STOREF, STOREF, "", 0, 1) \
+     o(LDLW_x1, LDLW, "N", -24, 1) \
+     o(LDLW_x1, LDLW, "N", -20, 1) \
+     o(LDLW_x1, LDLW, "N", -16, 1) \
+     o(LDLW_x1, LDLW, "N", -12, 1) \
+     o(LDLW_x1, LDLW, "N", -8, 1) \
+     o(LDLW_x1, LDLW, "N", -4, 1) \
+     o(LDLW_x2, LDLW, "N", 12, 1) \
+     o(LDLW_x2, LDLW, "N", 16, 1) \
+     o(LDLW_x2, LDLW, "N", 20, 1) \
+     o(LDLW_x2, LDLW, "N", 24, 1) \
+     o(LDLW_x2, LDLW, "N", 28, 1) \
+     o(LDLW_x2, LDLW, "N", 32, 1) \
+     o(LDLW_1, LDLW, "1", 0, 2) \
+     o(LDLW_2, LDLW, "2", 0, 3) \
+     o(LDLS_1, LDLS, "1", 0, 2) \
+     o(LDLS_2, LDLS, "2", 0, 3) \
+     o(LDLC_1, LDLC, "1", 0, 2) \
+     o(LDLC_2, LDLC, "2", 0, 3) \
+     o(LDLF_1, LDLF, "1", 0, 2) \
+     o(LDLF_2, LDLF, "2", 0, 3) \
+     o(STLW_x1, STLW, "N", -24, 1) \
+     o(STLW_x1, STLW, "N", -20, 1) \
+     o(STLW_x1, STLW, "N", -16, 1) \
+     o(STLW_x1, STLW, "N", -12, 1) \
+     o(STLW_x1, STLW, "N", -8, 1) \
+     o(STLW_x1, STLW, "N", -4, 1) \
+     o(STLW_x2, STLW, "N", 12, 1) \
+     o(STLW_x2, STLW, "N", 16, 1) \
+     o(STLW_x2, STLW, "N", 20, 1) \
+     o(STLW_x2, STLW, "N", 24, 1) \
+     o(STLW_x2, STLW, "N", 28, 1) \
+     o(STLW_x2, STLW, "N", 32, 1) \
+     o(STLW_1, STLW, "1", 0, 2) \
+     o(STLW_2, STLW, "2", 0, 3) \
+     o(STLS_1, STLS, "1", 0, 2) \
+     o(STLS_2, STLS, "2", 0, 3) \
+     o(STLC_1, STLC, "1", 0, 2) \
+     o(STLC_2, STLC, "2", 0, 3) \
+     o(STLF_1, STLF, "1", 0, 2) \
+     o(STLF_2, STLF, "2", 0, 3) \
+     o(LDGW_K, LDGW, "K", 0, 2) \
+     o(LDGW_L, LDGW, "L", 0, 3) \
+     o(LDGS_K, LDGS, "K", 0, 2) \
+     o(LDGS_L, LDGS, "L", 0, 3) \
+     o(LDGC_K, LDGC, "K", 0, 2) \
+     o(LDGC_L, LDGC, "L", 0, 3) \
+     o(LDGF_K, LDGF, "K", 0, 2) \
+     o(LDGF_L, LDGF, "L", 0, 3) \
+     o(STGW_K, STGW, "K", 0, 2) \
+     o(STGW_L, STGW, "L", 0, 3) \
+     o(STGS_K, STGS, "K", 0, 2) \
+     o(STGS_L, STGS, "L", 0, 3) \
+     o(STGC_K, STGC, "K", 0, 2) \
+     o(STGC_L, STGC, "L", 0, 3) \
+     o(STGF_K, STGF, "K", 0, 2) \
+     o(STGF_L, STGF, "L", 0, 3) \
+     o(LDNW_x1, LDNW, "N", -16, 1) \
+     o(LDNW_x1, LDNW, "N", -12, 1) \
+     o(LDNW_x1, LDNW, "N", -8, 1) \
+     o(LDNW_x1, LDNW, "N", -4, 1) \
+     o(LDNW_x1, LDNW, "N", 0, 1) \
+     o(LDNW_x1, LDNW, "N", 4, 1) \
+     o(LDNW_x1, LDNW, "N", 8, 1) \
+     o(LDNW_x1, LDNW, "N", 12, 1) \
+     o(LDNW_x1, LDNW, "N", 16, 1) \
+     o(LDNW_x1, LDNW, "N", 20, 1) \
+     o(LDNW_x1, LDNW, "N", 24, 1) \
+     o(LDNW_x1, LDNW, "N", 28, 1) \
+     o(LDNW_x1, LDNW, "N", 32, 1) \
+     o(LDNW_x1, LDNW, "N", 36, 1) \
+     o(LDNW_x1, LDNW, "N", 40, 1) \
+     o(LDNW_1, LDNW, "1", 0, 2) \
+     o(LDNW_2, LDNW, "2", 0, 3) \
+     o(STNW_x1, STNW, "N", -16, 1) \
+     o(STNW_x1, STNW, "N", -12, 1) \
+     o(STNW_x1, STNW, "N", -8, 1) \
+     o(STNW_x1, STNW, "N", -4, 1) \
+     o(STNW_x1, STNW, "N", 0, 1) \
+     o(STNW_x1, STNW, "N", 4, 1) \
+     o(STNW_x1, STNW, "N", 8, 1) \
+     o(STNW_x1, STNW, "N", 12, 1) \
+     o(STNW_x1, STNW, "N", 16, 1) \
+     o(STNW_x1, STNW, "N", 20, 1) \
+     o(STNW_1, STNW, "1", 0, 2) \
+     o(STNW_2, STNW, "2", 0, 3) \
+     o(LDIW, LDIW, "", 0, 1) \
+     o(LDIF, LDIF, "", 0, 1) \
+     o(LDIS, LDIS, "", 0, 1) \
+     o(LDIC, LDIC, "", 0, 1) \
+     o(STIW, STIW, "", 0, 1) \
+     o(STIF, STIF, "", 0, 1) \
+     o(STIS, STIS, "", 0, 1) \
+     o(STIC, STIC, "", 0, 1) \
+     o(LDID, LDID, "", 0, 1) \
+     o(STID, STID, "", 0, 1) \
+     o(LDIQ, LDIQ, "", 0, 1) \
+     o(STIQ, STIQ, "", 0, 1) \
+     o(LOADD, LOADD, "", 0, 1) \
+     o(STORED, STORED, "", 0, 1) \
+     o(LDKD_1, LDKD, "1", 0, 2) \
+     o(LDKD_2, LDKD, "2", 0, 3) \
+     o(LOADQ, LOADQ, "", 0, 1) \
+     o(STOREQ, STOREQ, "", 0, 1) \
+     o(LDKQ_1, LDKQ, "1", 0, 2) \
+     o(LDKQ_2, LDKQ, "2", 0, 3) \
+     o(INCL_1, INCL, "1", 0, 2) \
+     o(DECL_1, DECL, "1", 0, 2) \
+     o(DUP, DUP, "N", 0, 1) \
+     o(DUP, DUP, "N", 1, 1) \
+     o(DUP, DUP, "N", 2, 1) \
+     o(SWAP, SWAP, "", 0, 1) \
+     o(POP_1, POP, "1", 0, 2) \
+     o(PLUS, PLUS, "", 0, 1) \
+     o(MINUS, MINUS, "", 0, 1) \
+     o(TIMES, TIMES, "", 0, 1) \
+     o(UMINUS, UMINUS, "", 0, 1) \
+     o(AND, AND, "", 0, 1) \
+     o(OR, OR, "", 0, 1) \
+     o(NOT, NOT, "", 0, 1) \
+     o(INC, INC, "", 0, 1) \
+     o(DEC, DEC, "", 0, 1) \
+     o(BITAND, BITAND, "", 0, 1) \
+     o(BITOR, BITOR, "", 0, 1) \
+     o(BITXOR, BITXOR, "", 0, 1) \
+     o(BITNOT, BITNOT, "", 0, 1) \
+     o(LSL, LSL, "", 0, 1) \
+     o(LSR, LSR, "", 0, 1) \
+     o(ASR, ASR, "", 0, 1) \
+     o(ROR, ROR, "", 0, 1) \
+     o(DIV, DIV, "", 0, 1) \
+     o(MOD, MOD, "", 0, 1) \
+     o(EQ, EQ, "", 0, 1) \
+     o(LT, LT, "", 0, 1) \
+     o(GT, GT, "", 0, 1) \
+     o(LEQ, LEQ, "", 0, 1) \
+     o(GEQ, GEQ, "", 0, 1) \
+     o(NEQ, NEQ, "", 0, 1) \
+     o(JEQ_S, JEQ, "S", 0, 2) \
+     o(JEQ_R, JEQ, "R", 0, 3) \
+     o(JLT_S, JLT, "S", 0, 2) \
+     o(JLT_R, JLT, "R", 0, 3) \
+     o(JGT_S, JGT, "S", 0, 2) \
+     o(JGT_R, JGT, "R", 0, 3) \
+     o(JLEQ_S, JLEQ, "S", 0, 2) \
+     o(JLEQ_R, JLEQ, "R", 0, 3) \
+     o(JGEQ_S, JGEQ, "S", 0, 2) \
+     o(JGEQ_R, JGEQ, "R", 0, 3) \
+     o(JNEQ_S, JNEQ, "S", 0, 2) \
+     o(JNEQ_R, JNEQ, "R", 0, 3) \
+     o(JLTZ_S, JLTZ, "S", 0, 2) \
+     o(JGTZ_S, JGTZ, "S", 0, 2) \
+     o(JLEQZ_S, JLEQZ, "S", 0, 2) \
+     o(JGEQZ_S, JGEQZ, "S", 0, 2) \
+     o(JNEQZ_S, JNEQZ, "S", 0, 2) \
+     o(JNEQZ_R, JNEQZ, "R", 0, 3) \
+     o(JEQZ_S, JEQZ, "S", 0, 2) \
+     o(JEQZ_R, JEQZ, "R", 0, 3) \
+     o(JUMP_S, JUMP, "S", 0, 2) \
+     o(JUMP_R, JUMP, "R", 0, 3) \
+     o(QPLUS, QPLUS, "", 0, 1) \
+     o(QMINUS, QMINUS, "", 0, 1) \
+     o(QTIMES, QTIMES, "", 0, 1) \
+     o(QUMINUS, QUMINUS, "", 0, 1) \
+     o(QDIV, QDIV, "", 0, 1) \
+     o(QMOD, QMOD, "", 0, 1) \
+     o(JCASE_1, JCASE, "1", 0, 2) \
+     o(JRANGE_S, JRANGE, "S", 0, 2) \
+     o(JRANGE_R, JRANGE, "R", 0, 3) \
+     o(TESTGEQ_S, TESTGEQ, "S", 0, 2) \
+     o(TESTGEQ_R, TESTGEQ, "R", 0, 3) \
+     o(FPLUS, FPLUS, "", 0, 1) \
+     o(FMINUS, FMINUS, "", 0, 1) \
+     o(FTIMES, FTIMES, "", 0, 1) \
+     o(FDIV, FDIV, "", 0, 1) \
+     o(FUMINUS, FUMINUS, "", 0, 1) \
+     o(FCMPL, FCMPL, "", 0, 1) \
+     o(FCMPG, FCMPG, "", 0, 1) \
+     o(DPLUS, DPLUS, "", 0, 1) \
+     o(DMINUS, DMINUS, "", 0, 1) \
+     o(DTIMES, DTIMES, "", 0, 1) \
+     o(DDIV, DDIV, "", 0, 1) \
+     o(DUMINUS, DUMINUS, "", 0, 1) \
+     o(DCMPL, DCMPL, "", 0, 1) \
+     o(DCMPG, DCMPG, "", 0, 1) \
+     o(QCMP, QCMP, "", 0, 1) \
+     o(CONVNF, CONVNF, "", 0, 1) \
+     o(CONVND, CONVND, "", 0, 1) \
+     o(CONVFN, CONVFN, "", 0, 1) \
+     o(CONVDN, CONVDN, "", 0, 1) \
+     o(CONVFD, CONVFD, "", 0, 1) \
+     o(CONVDF, CONVDF, "", 0, 1) \
+     o(CONVNC, CONVNC, "", 0, 1) \
+     o(CONVNS, CONVNS, "", 0, 1) \
+     o(CONVNQ, CONVNQ, "", 0, 1) \
+     o(CONVQN, CONVQN, "", 0, 1) \
+     o(CONVQD, CONVQD, "", 0, 1) \
+     o(BOUND_2, BOUND, "2", 0, 3) \
+     o(NCHECK_2, NCHECK, "2", 0, 3) \
+     o(GCHECK_2, GCHECK, "2", 0, 3) \
+     o(ZCHECK_2, ZCHECK, "2", 0, 3) \
+     o(FZCHECK_2, FZCHECK, "2", 0, 3) \
+     o(DZCHECK_2, DZCHECK, "2", 0, 3) \
+     o(QZCHECK_2, QZCHECK, "2", 0, 3) \
+     o(ERROR_12, ERROR, "12", 0, 4) \
+     o(ALIGNC, ALIGNC, "", 0, 1) \
+     o(ALIGNS, ALIGNS, "", 0, 1) \
+     o(FIXCOPY, FIXCOPY, "", 0, 1) \
+     o(FLEXCOPY, FLEXCOPY, "", 0, 1) \
+     o(LINK, LINK, "", 0, 1) \
+     o(SAVELINK, SAVELINK, "", 0, 1) \
+     o(JPROC, JPROC, "", 0, 1) \
+     o(SLIDE_1, SLIDE, "1", 0, 2) \
+     o(SLIDEW_1, SLIDEW, "1", 0, 2) \
+     o(SLIDED_1, SLIDED, "1", 0, 2) \
+     o(SLIDEF_1, SLIDEF, "1", 0, 2) \
+     o(SLIDEQ_1, SLIDEQ, "1", 0, 2) \
+     o(RESULTW, RESULTW, "", 0, 1) \
+     o(RESULTD, RESULTD, "", 0, 1) \
+     o(RESULTF, RESULTF, "", 0, 1) \
+     o(RESULTQ, RESULTQ, "", 0, 1) \
+     o(RETURN, RETURN, "", 0, 1) \
+     o(LNUM_2, LNUM, "2", 0, 3) \
+     o(BREAK_2, BREAK, "2", 0, 3)
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/keiko/template.c	Mon Sep 10 20:34:00 2018 +0100
@@ -0,0 +1,748 @@
+/* Template file -- generated by iset.tcl */
+
+#include "oblink.h"
+#include "keiko.h"
+
+struct _template templates[NTEMPLATES] = {
+{"PUSH",      "N",    -1,  6,  1,  1,  1, K_PUSH_x1, {}},
+{   NULL,     "1",     0,  0,  0,  2,  1, K_PUSH_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_PUSH_2, {}},
+{"LDKW",      "1",     0,  0,  0,  2,  1, K_LDKW_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDKW_2, {}},
+{"LDKF",      "1",     0,  0,  0,  2,  1, K_LDKF_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDKF_2, {}},
+{"LOCAL",     "1",     0,  0,  0,  2,  1, K_LOCAL_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LOCAL_2, {}},
+{"OFFSET",    "",      0,  0,  0,  1,  1, K_OFFSET, {}},
+{"INDEXS",    "",      0,  0,  0,  1,  1, K_INDEXS, {}},
+{"INDEXW",    "",      0,  0,  0,  1,  1, K_INDEXW, {}},
+{"INDEXD",    "",      0,  0,  0,  1,  1, K_INDEXD, {}},
+{"LOADW",     "",      0,  0,  0,  1,  1, K_LOADW, {}},
+{"LOADS",     "",      0,  0,  0,  1,  1, K_LOADS, {}},
+{"LOADC",     "",      0,  0,  0,  1,  1, K_LOADC, {}},
+{"LOADF",     "",      0,  0,  0,  1,  1, K_LOADF, {}},
+{"STOREW",    "",      0,  0,  0,  1,  1, K_STOREW, {}},
+{"STORES",    "",      0,  0,  0,  1,  1, K_STORES, {}},
+{"STOREC",    "",      0,  0,  0,  1,  1, K_STOREC, {}},
+{"STOREF",    "",      0,  0,  0,  1,  1, K_STOREF, {}},
+{"LDLW",      "N",   -24, -4,  4,  1,  1, K_LDLW_x1, {}},
+{   NULL,     "N",    12, 32,  4,  1,  1, K_LDLW_x2, {}},
+{   NULL,     "1",     0,  0,  0,  2,  1, K_LDLW_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDLW_2, {}},
+{"LDLS",      "1",     0,  0,  0,  2,  1, K_LDLS_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDLS_2, {}},
+{"LDLC",      "1",     0,  0,  0,  2,  1, K_LDLC_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDLC_2, {}},
+{"LDLF",      "1",     0,  0,  0,  2,  1, K_LDLF_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDLF_2, {}},
+{"STLW",      "N",   -24, -4,  4,  1,  1, K_STLW_x1, {}},
+{   NULL,     "N",    12, 32,  4,  1,  1, K_STLW_x2, {}},
+{   NULL,     "1",     0,  0,  0,  2,  1, K_STLW_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_STLW_2, {}},
+{"STLS",      "1",     0,  0,  0,  2,  1, K_STLS_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_STLS_2, {}},
+{"STLC",      "1",     0,  0,  0,  2,  1, K_STLC_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_STLC_2, {}},
+{"STLF",      "1",     0,  0,  0,  2,  1, K_STLF_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_STLF_2, {}},
+{"LDGW",      "K",     0,  0,  0,  2,  1, K_LDGW_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_LDGW_L, {}},
+{"LDGS",      "K",     0,  0,  0,  2,  1, K_LDGS_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_LDGS_L, {}},
+{"LDGC",      "K",     0,  0,  0,  2,  1, K_LDGC_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_LDGC_L, {}},
+{"LDGF",      "K",     0,  0,  0,  2,  1, K_LDGF_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_LDGF_L, {}},
+{"STGW",      "K",     0,  0,  0,  2,  1, K_STGW_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_STGW_L, {}},
+{"STGS",      "K",     0,  0,  0,  2,  1, K_STGS_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_STGS_L, {}},
+{"STGC",      "K",     0,  0,  0,  2,  1, K_STGC_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_STGC_L, {}},
+{"STGF",      "K",     0,  0,  0,  2,  1, K_STGF_K, {}},
+{   NULL,     "L",     0,  0,  0,  3,  1, K_STGF_L, {}},
+{"LDNW",      "N",   -16, 40,  4,  1,  1, K_LDNW_x1, {}},
+{   NULL,     "1",     0,  0,  0,  2,  1, K_LDNW_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDNW_2, {}},
+{"STNW",      "N",   -16, 20,  4,  1,  1, K_STNW_x1, {}},
+{   NULL,     "1",     0,  0,  0,  2,  1, K_STNW_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_STNW_2, {}},
+{"LDIW",      "",      0,  0,  0,  1,  1, K_LDIW, {}},
+{"LDIF",      "",      0,  0,  0,  1,  1, K_LDIF, {}},
+{"LDIS",      "",      0,  0,  0,  1,  1, K_LDIS, {}},
+{"LDIC",      "",      0,  0,  0,  1,  1, K_LDIC, {}},
+{"STIW",      "",      0,  0,  0,  1,  1, K_STIW, {}},
+{"STIF",      "",      0,  0,  0,  1,  1, K_STIF, {}},
+{"STIS",      "",      0,  0,  0,  1,  1, K_STIS, {}},
+{"STIC",      "",      0,  0,  0,  1,  1, K_STIC, {}},
+{"LDID",      "",      0,  0,  0,  1,  1, K_LDID, {}},
+{"STID",      "",      0,  0,  0,  1,  1, K_STID, {}},
+{"LDIQ",      "",      0,  0,  0,  1,  1, K_LDIQ, {}},
+{"STIQ",      "",      0,  0,  0,  1,  1, K_STIQ, {}},
+{"LOADD",     "",      0,  0,  0,  1,  1, K_LOADD, {}},
+{"STORED",    "",      0,  0,  0,  1,  1, K_STORED, {}},
+{"LDKD",      "1",     0,  0,  0,  2,  1, K_LDKD_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDKD_2, {}},
+{"LOADQ",     "",      0,  0,  0,  1,  1, K_LOADQ, {}},
+{"STOREQ",    "",      0,  0,  0,  1,  1, K_STOREQ, {}},
+{"LDKQ",      "1",     0,  0,  0,  2,  1, K_LDKQ_1, {}},
+{   NULL,     "2",     0,  0,  0,  3,  1, K_LDKQ_2, {}},
+{"LDLD",      "1",     0,  0,  0,  0,  0, 0, {"LOCAL $a", "LOADD"}},
+{"STLD",      "1",     0,  0,  0,  0,  0, 0, {"LOCAL $a", "STORED"}},
+{"LDGD",      "K",     0,  0,  0,  0,  0, 0, {"LDKW $a", "LOADD"}},
+{"STGD",      "K",     0,  0,  0,  0,  0, 0, {"LDKW $a", "STORED"}},
+{"LDLQ",      "1",     0,  0,  0,  0,  0, 0, {"LOCAL $a", "LOADQ"}},
+{"STLQ",      "1",     0,  0,  0,  0,  0, 0, {"LOCAL $a", "STOREQ"}},
+{"LDGQ",      "K",     0,  0,  0,  0,  0, 0, {"LDKW $a", "LOADQ"}},
+{"STGQ",      "K",     0,  0,  0,  0,  0, 0, {"LDKW $a", "STOREQ"}},
+{"INCL",      "1",     0,  0,  0,  2,  1, K_INCL_1, {}},
+{   NULL,     "2",     0,  0,  0,  0,  0, 0, {"LDLW $a", "INC", "STLW $a"}},
+{"DECL",      "1",     0,  0,  0,  2,  1, K_DECL_1, {}},
+{   NULL,     "2",     0,  0,  0,  0,  0, 0, {"LDLW $a", "DEC", "STLW $a"}},
+{"DUP",       "N",     0,  2,  1,  1,  1, K_DUP, {}},
+{"SWAP",      "",      0,  0,  0,  1,  1, K_SWAP, {}},
+{"POP",       "1",     0,  0,  0,  2,  1, K_POP_1, {}},
+{"PLUS",      "",      0,  0,  0,  1,  1, K_PLUS, {}},
+{"MINUS",     "",      0,  0,  0,  1,  1, K_MINUS, {}},
+{"TIMES",     "",      0,  0,  0,  1,  1, K_TIMES, {}},
+{"UMINUS",    "",      0,  0,  0,  1,  1, K_UMINUS, {}},
+{"AND",       "",      0,  0,  0,  1,  1, K_AND, {}},
+{"OR",        "",      0,  0,  0,  1,  1, K_OR, {}},
+{"NOT",       "",      0,  0,  0,  1,  1, K_NOT, {}},
+{"INC",       "",      0,  0,  0,  1,  1, K_INC, {}},
+{"DEC",       "",      0,  0,  0,  1,  1, K_DEC, {}},
+{"BITAND",    "",      0,  0,  0,  1,  1, K_BITAND, {}},
+{"BITOR",     "",      0,  0,  0,  1,  1, K_BITOR, {}},
+{"BITXOR",    "",      0,  0,  0,  1,  1, K_BITXOR, {}},
+{"BITNOT",    "",      0,  0,  0,  1,  1, K_BITNOT, {}},
+{"LSL",       "",      0,  0,  0,  1,  1, K_LSL, {}},
+{"LSR",       "",      0,  0,  0,  1,  1, K_LSR, {}},
+{"ASR",       "",      0,  0,  0,  1,  1, K_ASR, {}},
+{"ROR",       "",      0,  0,  0,  1,  1, K_ROR, {}},
+{"DIV",       "",      0,  0,  0,  1,  1, K_DIV, {}},
+{"MOD",       "",      0,  0,  0,  1,  1, K_MOD, {}},
+{"EQ",        "",      0,  0,  0,  1,  1, K_EQ, {}},
+{"LT",        "",      0,  0,  0,  1,  1, K_LT, {}},
+{"GT",        "",      0,  0,  0,  1,  1, K_GT, {}},
+{"LEQ",       "",      0,  0,  0,  1,  1, K_LEQ, {}},
+{"GEQ",       "",      0,  0,  0,  1,  1, K_GEQ, {}},
+{"NEQ",       "",      0,  0,  0,  1,  1, K_NEQ, {}},
+{"JEQ",       "S",     0,  0,  0,  2,  1, K_JEQ_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JEQ_R, {}},
+{"JLT",       "S",     0,  0,  0,  2,  1, K_JLT_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JLT_R, {}},
+{"JGT",       "S",     0,  0,  0,  2,  1, K_JGT_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JGT_R, {}},
+{"JLEQ",      "S",     0,  0,  0,  2,  1, K_JLEQ_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JLEQ_R, {}},
+{"JGEQ",      "S",     0,  0,  0,  2,  1, K_JGEQ_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JGEQ_R, {}},
+{"JNEQ",      "S",     0,  0,  0,  2,  1, K_JNEQ_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JNEQ_R, {}},
+{"JLTZ",      "S",     0,  0,  0,  2,  1, K_JLTZ_S, {}},
+{   NULL,     "R",     0,  0,  0,  0,  0, 0, {"PUSH 0", "JLT $a"}},
+{"JGTZ",      "S",     0,  0,  0,  2,  1, K_JGTZ_S, {}},
+{   NULL,     "R",     0,  0,  0,  0,  0, 0, {"PUSH 0", "JGT $a"}},
+{"JLEQZ",     "S",     0,  0,  0,  2,  1, K_JLEQZ_S, {}},
+{   NULL,     "R",     0,  0,  0,  0,  0, 0, {"PUSH 0", "JLEQ $a"}},
+{"JGEQZ",     "S",     0,  0,  0,  2,  1, K_JGEQZ_S, {}},
+{   NULL,     "R",     0,  0,  0,  0,  0, 0, {"PUSH 0", "JGEQ $a"}},
+{"JNEQZ",     "S",     0,  0,  0,  2,  1, K_JNEQZ_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JNEQZ_R, {}},
+{"JEQZ",      "S",     0,  0,  0,  2,  1, K_JEQZ_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JEQZ_R, {}},
+{"JUMP",      "S",     0,  0,  0,  2,  1, K_JUMP_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JUMP_R, {}},
+{"QPLUS",     "",      0,  0,  0,  1,  1, K_QPLUS, {}},
+{"QMINUS",    "",      0,  0,  0,  1,  1, K_QMINUS, {}},
+{"QTIMES",    "",      0,  0,  0,  1,  1, K_QTIMES, {}},
+{"QUMINUS",   "",      0,  0,  0,  1,  1, K_QUMINUS, {}},
+{"QDIV",      "",      0,  0,  0,  1,  1, K_QDIV, {}},
+{"QMOD",      "",      0,  0,  0,  1,  1, K_QMOD, {}},
+{"QINC",      "",      0,  0,  0,  0,  0, 0, {"PUSH 1", "CONVNQ", "QPLUS"}},
+{"QDEC",      "",      0,  0,  0,  0,  0, 0, {"PUSH 1", "CONVNQ", "QMINUS"}},
+{"JCASE",     "1",     0,  0,  0,  2,  1, K_JCASE_1, {}},
+{"CASEL",     "R",     0,  0,  0,  2,  0, 0, {}},
+{"JRANGE",    "S",     0,  0,  0,  2,  1, K_JRANGE_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_JRANGE_R, {}},
+{"TESTGEQ",   "S",     0,  0,  0,  2,  1, K_TESTGEQ_S, {}},
+{   NULL,     "R",     0,  0,  0,  3,  1, K_TESTGEQ_R, {}},
+{"FPLUS",     "",      0,  0,  0,  1,  1, K_FPLUS, {}},
+{"FMINUS",    "",      0,  0,  0,  1,  1, K_FMINUS, {}},
+{"FTIMES",    "",      0,  0,  0,  1,  1, K_FTIMES, {}},
+{"FDIV",      "",      0,  0,  0,  1,  1, K_FDIV, {}},
+{"FUMINUS",   "",      0,  0,  0,  1,  1, K_FUMINUS, {}},
+{"FCMPL",     "",      0,  0,  0,  1,  1, K_FCMPL, {}},
+{"FCMPG",     "",      0,  0,  0,  1,  1, K_FCMPG, {}},
+{"FEQ",       "",      0,  0,  0,  0,  0, 0, {"FCMPL", "PUSH 0", "EQ"}},
+{"FNEQ",      "",      0,  0,  0,  0,  0, 0, {"FCMPL", "PUSH 0", "NEQ"}},
+{"FLT",       "",      0,  0,  0,  0,  0, 0, {"FCMPG", "PUSH 0", "LT"}},
+{"FGT",       "",      0,  0,  0,  0,  0, 0, {"FCMPL", "PUSH 0", "GT"}},
+{"FLEQ",      "",      0,  0,  0,  0,  0, 0, {"FCMPG", "PUSH 0", "LEQ"}},
+{"FGEQ",      "",      0,  0,  0,  0,  0, 0, {"FCMPL", "PUSH 0", "GEQ"}},
+{"FJEQ",      "R",     0,  0,  0,  0,  0, 0, {"FCMPL", "JEQZ $a"}},
+{"FJNEQ",     "R",     0,  0,  0,  0,  0, 0, {"FCMPL", "JNEQZ $a"}},
+{"FJLT",      "R",     0,  0,  0,  0,  0, 0, {"FCMPG", "JLTZ $a"}},
+{"FJGT",      "R",     0,  0,  0,  0,  0, 0, {"FCMPL", "JGTZ $a"}},
+{"FJLEQ",     "R",     0,  0,  0,  0,  0, 0, {"FCMPG", "JLEQZ $a"}},
+{"FJGEQ",     "R",     0,  0,  0,  0,  0, 0, {"FCMPL", "JGEQZ $a"}},
+{"FJNLT",     "R",     0,  0,  0,  0,  0, 0, {"FCMPG", "JGEQZ $a"}},
+{"FJNGT",     "R",     0,  0,  0,  0,  0, 0, {"FCMPL", "JLEQZ $a"}},
+{"FJNLEQ",    "R",     0,  0,  0,  0,  0, 0, {"FCMPG", "JGTZ $a"}},
+{"FJNGEQ",    "R",     0,  0,  0,  0,  0, 0, {"FCMPL", "JLTZ $a"}},
+{"DPLUS",     "",      0,  0,  0,  1,  1, K_DPLUS, {}},
+{"DMINUS",    "",      0,  0,  0,  1,  1, K_DMINUS, {}},
+{"DTIMES",    "",      0,  0,  0,  1,  1, K_DTIMES, {}},
+{"DDIV",      "",      0,  0,  0,  1,  1, K_DDIV, {}},
+{"DUMINUS",   "",      0,  0,  0,  1,  1, K_DUMINUS, {}},
+{"DCMPL",     "",      0,  0,  0,  1,  1, K_DCMPL, {}},
+{"DCMPG",     "",      0,  0,  0,  1,  1, K_DCMPG, {}},
+{"DEQ",       "",      0,  0,  0,  0,  0, 0, {"DCMPL", "PUSH 0", "EQ"}},
+{"DNEQ",      "",      0,  0,  0,  0,  0, 0, {"DCMPL", "PUSH 0", "NE"}},
+{"DLT",       "",      0,  0,  0,  0,  0, 0, {"DCMPG", "PUSH 0", "LT"}},
+{"DGT",       "",      0,  0,  0,  0,  0, 0, {"DCMPL", "PUSH 0", "GT"}},
+{"DLEQ",      "",      0,  0,  0,  0,  0, 0, {"DCMPG", "PUSH 0", "LE"}},
+{"DGEQ",      "",      0,  0,  0,  0,  0, 0, {"DCMPL", "PUSH 0", "GE"}},
+{"DJEQ",      "R",     0,  0,  0,  0,  0, 0, {"DCMPL", "JEQZ $a"}},
+{"DJNEQ",     "R",     0,  0,  0,  0,  0, 0, {"DCMPL", "JNEQZ $a"}},
+{"DJLT",      "R",     0,  0,  0,  0,  0, 0, {"DCMPG", "JLTZ $a"}},
+{"DJGT",      "R",     0,  0,  0,  0,  0, 0, {"DCMPL", "JGTZ $a"}},
+{"DJLEQ",     "R",     0,  0,  0,  0,  0, 0, {"DCMPG", "JLEQZ $a"}},
+{"DJGEQ",     "R",     0,  0,  0,  0,  0, 0, {"DCMPL", "JGEQZ $a"}},
+{"DJNLT",     "R",     0,  0,  0,  0,  0, 0, {"DCMPG", "JGEQZ $a"}},
+{"DJNGT",     "R",     0,  0,  0,  0,  0, 0, {"DCMPL", "JLEQZ $a"}},
+{"DJNLEQ",    "R",     0,  0,  0,  0,  0, 0, {"DCMPG", "JGTZ $a"}},
+{"DJNGEQ",    "R",     0,  0,  0,  0,  0, 0, {"DCMPL", "JLTZ $a"}},
+{"QCMP",      "",      0,  0,  0,  1,  1, K_QCMP, {}},
+{"QEQ",       "",      0,  0,  0,  0,  0, 0, {"QCMP", "PUSH 0", "EQ"}},
+{"QLT",       "",      0,  0,  0,  0,  0, 0, {"QCMP", "PUSH 0", "LT"}},
+{"QGT",       "",      0,  0,  0,  0,  0, 0, {"QCMP", "PUSH 0", "GT"}},
+{"QLEQ",      "",      0,  0,  0,  0,  0, 0, {"QCMP", "PUSH 0", "LEQ"}},
+{"QGEQ",      "",      0,  0,  0,  0,  0, 0, {"QCMP", "PUSH 0", "GEQ"}},
+{"QNEQ",      "",      0,  0,  0,  0,  0, 0, {"QCMP", "PUSH 0", "NEQ"}},
+{"QJEQ",      "R",     0,  0,  0,  0,  0, 0, {"QCMP", "JEQZ $a"}},
+{"QJLT",      "R",     0,  0,  0,  0,  0, 0, {"QCMP", "JLTZ $a"}},
+{"QJGT",      "R",     0,  0,  0,  0,  0, 0, {"QCMP", "JGTZ $a"}},
+{"QJLEQ",     "R",     0,  0,  0,  0,  0, 0, {"QCMP", "JLEQZ $a"}},
+{"QJGEQ",     "R",     0,  0,  0,  0,  0, 0, {"QCMP", "JGEQZ $a"}},
+{"QJNEQ",     "R",     0,  0,  0,  0,  0, 0, {"QCMP", "JNEQZ $a"}},
+{"CONVNF",    "",      0,  0,  0,  1,  1, K_CONVNF, {}},
+{"CONVND",    "",      0,  0,  0,  1,  1, K_CONVND, {}},
+{"CONVFN",    "",      0,  0,  0,  1,  1, K_CONVFN, {}},
+{"CONVDN",    "",      0,  0,  0,  1,  1, K_CONVDN, {}},
+{"CONVFD",    "",      0,  0,  0,  1,  1, K_CONVFD, {}},
+{"CONVDF",    "",      0,  0,  0,  1,  1, K_CONVDF, {}},
+{"CONVNC",    "",      0,  0,  0,  1,  1, K_CONVNC, {}},
+{"CONVNS",    "",      0,  0,  0,  1,  1, K_CONVNS, {}},
+{"CONVNQ",    "",      0,  0,  0,  1,  1, K_CONVNQ, {}},
+{"CONVQN",    "",      0,  0,  0,  1,  1, K_CONVQN, {}},
+{"CONVQD",    "",      0,  0,  0,  1,  1, K_CONVQD, {}},
+{"BOUND",     "2",     0,  0,  0,  3,  1, K_BOUND_2, {}},
+{"NCHECK",    "2",     0,  0,  0,  3,  1, K_NCHECK_2, {}},
+{"GCHECK",    "2",     0,  0,  0,  3,  1, K_GCHECK_2, {}},
+{"ZCHECK",    "2",     0,  0,  0,  3,  1, K_ZCHECK_2, {}},
+{"FZCHECK",   "2",     0,  0,  0,  3,  1, K_FZCHECK_2, {}},
+{"DZCHECK",   "2",     0,  0,  0,  3,  1, K_DZCHECK_2, {}},
+{"QZCHECK",   "2",     0,  0,  0,  3,  1, K_QZCHECK_2, {}},
+{"ERROR",     "12",    0,  0,  0,  4,  1, K_ERROR_12, {}},
+{"EASSERT",   "2",     0,  0,  0,  0,  0, 0, {"RESULTW", "ERROR E_ASSERT $a"}},
+{"ALIGNC",    "",      0,  0,  0,  1,  1, K_ALIGNC, {}},
+{"ALIGNS",    "",      0,  0,  0,  1,  1, K_ALIGNS, {}},
+{"FIXCOPY",   "",      0,  0,  0,  1,  1, K_FIXCOPY, {}},
+{"FLEXCOPY",  "",      0,  0,  0,  1,  1, K_FLEXCOPY, {}},
+{"CALL",      "1",     0,  0,  0,  0,  0, 0, {"JPROC", "SLIDE $a"}},
+{"CALLW",     "1",     0,  0,  0,  0,  0, 0, {"JPROC", "SLIDEW $a"}},
+{"CALLQ",     "1",     0,  0,  0,  0,  0, 0, {"JPROC", "SLIDEQ $a"}},
+{"CALLF",     "1",     0,  0,  0,  0,  0, 0, {"JPROC", "SLIDEF $a"}},
+{"CALLD",     "1",     0,  0,  0,  0,  0, 0, {"JPROC", "SLIDED $a"}},
+{"LINK",      "",      0,  0,  0,  1,  1, K_LINK, {}},
+{"SAVELINK",  "",      0,  0,  0,  1,  1, K_SAVELINK, {}},
+{"JPROC",     "",      0,  0,  0,  1,  1, K_JPROC, {}},
+{"SLIDE",     "1",     0,  0,  0,  2,  1, K_SLIDE_1, {}},
+{"SLIDEW",    "1",     0,  0,  0,  2,  1, K_SLIDEW_1, {}},
+{"SLIDED",    "1",     0,  0,  0,  2,  1, K_SLIDED_1, {}},
+{"SLIDEF",    "1",     0,  0,  0,  2,  1, K_SLIDEF_1, {}},
+{"SLIDEQ",    "1",     0,  0,  0,  2,  1, K_SLIDEQ_1, {}},
+{"RETURNW",   "",      0,  0,  0,  0,  0, 0, {"RESULTW", "RETURN"}},
+{"RETURNF",   "",      0,  0,  0,  0,  0, 0, {"RESULTF", "RETURN"}},
+{"RETURND",   "",      0,  0,  0,  0,  0, 0, {"RESULTD", "RETURN"}},
+{"RETURNQ",   "",      0,  0,  0,  0,  0, 0, {"RESULTQ", "RETURN"}},
+{"RESULTW",   "",      0,  0,  0,  1,  1, K_RESULTW, {}},
+{"RESULTD",   "",      0,  0,  0,  1,  1, K_RESULTD, {}},
+{"RESULTF",   "",      0,  0,  0,  1,  1, K_RESULTF, {}},
+{"RESULTQ",   "",      0,  0,  0,  1,  1, K_RESULTQ, {}},
+{"RETURN",    "",      0,  0,  0,  1,  1, K_RETURN, {}},
+{"LNUM",      "2",     0,  0,  0,  3,  1, K_LNUM_2, {}},
+{"BREAK",     "2",     0,  0,  0,  3,  1, K_BREAK_2, {}},
+{"CONST",     "?",     0,  0,  0, -1,  1, D_CONST, {}},
+{"FCONST",    "?",     0,  0,  0, -1,  1, D_FCONST, {}},
+{"DCONST",    "?",     0,  0,  0, -1,  1, D_DCONST, {}},
+{"QCONST",    "?",     0,  0,  0, -1,  1, D_QCONST, {}},
+{"GLOBAL",    "?",     0,  0,  0, -1,  1, D_GLOBAL, {}},
+{"LABEL",     "?",     0,  0,  0, -1,  1, D_LABEL, {}},
+{"PROC",      "????",  0,  0,  0, -1,  1, D_PROC, {}},
+{"END",       "",      0,  0,  0, -1,  1, D_END, {}},
+{"PRIMDEF",   "???",   0,  0,  0, -1,  1, D_PRIMDEF, {}},
+{"DEFINE",    "?",     0,  0,  0, -1,  1, D_DEFINE, {}},
+{"STRING",    "?",     0,  0,  0, -1,  1, D_STRING, {}},
+{"GLOVAR",    "??",    0,  0,  0, -1,  1, D_GLOVAR, {}},
+{"WORD",      "?",     0,  0,  0, -1,  1, D_WORD, {}},
+{"MODULE",    "???",   0,  0,  0, -1,  1, D_MODULE, {}},
+{"ENDHDR",    "",      0,  0,  0, -1,  1, D_ENDHDR, {}},
+{"IMPORT",    "??",    0,  0,  0, -1,  1, D_IMPORT, {}},
+{"STKMAP",    "?",     0,  0,  0, -1,  1, D_STKMAP, {}},
+{"LINE",      "?",     0,  0,  0, -1,  1, D_LINE, {}},
+{"PCALL",     "?",     0,  0,  0, -1,  1, D_PCALL, {}},
+{"PCALLW",    "?",     0,  0,  0, -1,  1, D_PCALLW, {}},
+};
+
+/*
+[A]  10 [L]   2 [I]   1 [G]  11 [N]  24 [C]   3 --> 242
+ |       |                              [S]   4 --> 243
+ |      [N]  26 [D]   5 --> 102
+ |      [S]  13 [R]   6 --> 113
+[B]  19 [I]  12 [T]  32 [A]  21 [N]  34 [D]   7 --> 107
+ |       |              [N]  25 [O]  16 [T]   8 --> 110
+ |       |              [O]  23 [R]   9 --> 108
+ |       |              [X]  27 [O]  30 [R]  14 --> 109
+ |      [O]  18 [U]  31 [N]  40 [D]  15 --> 233
+ |      [R]  44 [E]  49 [A]  41 [K]  17 --> 269
+[C]  50 [A]  42 [L]  43 [L]  53 --> 246
+ |       |       |              [D]  20 --> 250
+ |       |       |              [F]  22 --> 249
+ |       |       |              [Q]  28 --> 248
+ |       |       |              [W]  29 --> 247
+ |       |      [S]  48 [E]  46 [L]  33 --> 158
+ |      [O]  52 [N]  45 [S]  51 [T]  35 --> 270
+ |                      [V]  68 [D]  54 [F]  36 --> 227
+ |                               |      [N]  37 --> 225
+ |                              [F]  59 [D]  38 --> 226
+ |                               |      [N]  39 --> 224
+ |                              [N]  74 [C]  47 --> 228
+ |                               |      [D]  55 --> 223
+ |                               |      [F]  56 --> 222
+ |                               |      [Q]  57 --> 230
+ |                               |      [S]  58 --> 229
+ |                              [Q]  65 [D]  60 --> 232
+ |                                      [N]  61 --> 231
+[D]  85 [C]  71 [M]  67 [P]  95 [G]  62 --> 192
+ |       |       |              [L]  63 --> 191
+ |       |      [O]  73 [N]  77 [S]  80 [T]  64 --> 272
+ |      [D]  66 [I]  81 [V] 126 --> 189
+ |      [E] 106 [C] 145 --> 106
+ |       |       |      [L] 168 --> 93
+ |       |      [F]  99 [I]  96 [N] 108 [E] 178 --> 279
+ |       |      [Q] 179 --> 193
+ |      [G] 111 [E] 100 [Q] 182 --> 198
+ |       |      [T] 183 --> 196
+ |      [I]  98 [V] 185 --> 115
+ |      [J] 120 [E] 105 [Q] 188 --> 199
+ |       |      [G] 121 [E] 112 [Q] 192 --> 204
+ |       |       |      [T] 194 --> 202
+ |       |      [L] 128 [E] 118 [Q] 200 --> 203
+ |       |       |      [T] 201 --> 201
+ |       |      [N] 133 [E] 122 [Q] 206 --> 200
+ |       |              [G] 138 [E] 127 [Q] 210 --> 208
+ |       |               |      [T] 211 --> 206
+ |       |              [L] 144 [E] 134 [Q] 214 --> 207
+ |       |                      [T] 216 --> 205
+ |      [L] 148 [E] 137 [Q] 219 --> 197
+ |       |      [T] 220 --> 195
+ |      [M] 150 [I] 146 [N] 140 [U] 143 [S] 227 --> 187
+ |      [N] 160 [E] 149 [Q] 231 --> 194
+ |      [P] 157 [L] 151 [U] 152 [S] 234 --> 186
+ |      [T] 164 [I] 161 [M] 170 [E] 158 [S] 240 --> 188
+ |      [U] 165 [M] 171 [I] 169 [N] 163 [U] 166 [S] 243 --> 190
+ |       |      [P] 246 --> 95
+ |      [Z] 184 [C] 180 [H] 181 [E] 186 [C] 187 [K] 254 --> 238
+[E] 190 [A] 173 [S] 174 [S] 189 [E] 177 [R] 176 [T] 261 --> 241
+ |      [N] 195 [D] 264 --> 277
+ |       |              [H] 197 [D] 191 [R] 266 --> 284
+ |      [Q] 267 --> 117
+ |      [R] 193 [R] 198 [O] 196 [R] 269 --> 240
+[F] 212 [C] 205 [M] 207 [P] 222 [G] 270 --> 169
+ |       |       |              [L] 274 --> 168
+ |       |      [O] 213 [N] 217 [S] 215 [T] 276 --> 271
+ |      [D] 221 [I] 209 [V] 301 --> 166
+ |      [E] 223 [Q] 303 --> 170
+ |      [G] 236 [E] 225 [Q] 307 --> 175
+ |       |      [T] 308 --> 173
+ |      [I] 224 [X] 242 [C] 232 [O] 230 [P] 226 [Y] 313 --> 244
+ |      [J] 245 [E] 237 [Q] 317 --> 176
+ |       |      [G] 250 [E] 241 [Q] 324 --> 181
+ |       |       |      [T] 325 --> 179
+ |       |      [L] 257 [E] 247 [Q] 327 --> 180
+ |       |       |      [T] 329 --> 178
+ |       |      [N] 262 [E] 249 [Q] 332 --> 177
+ |       |              [G] 268 [E] 258 [Q] 335 --> 185
+ |       |               |      [T] 340 --> 183
+ |       |              [L] 273 [E] 263 [Q] 343 --> 184
+ |       |                      [T] 345 --> 182
+ |      [L] 277 [E] 272 [Q] 347 --> 174
+ |       |       |      [X] 281 [C] 271 [O] 275 [P] 260 [Y] 351 --> 245
+ |       |      [T] 354 --> 172
+ |      [M] 283 [I] 280 [N] 278 [U] 279 [S] 359 --> 164
+ |      [N] 295 [E] 284 [Q] 366 --> 171
+ |      [P] 291 [L] 285 [U] 286 [S] 368 --> 163
+ |      [T] 298 [I] 296 [M] 305 [E] 289 [S] 375 --> 165
+ |      [U] 299 [M] 304 [I] 300 [N] 294 [U] 297 [S] 381 --> 167
+ |      [Z] 315 [C] 311 [H] 316 [E] 319 [C] 309 [K] 387 --> 237
+[G] 321 [C] 320 [H] 322 [E] 326 [C] 314 [K] 394 --> 235
+ |      [E] 318 [Q] 395 --> 121
+ |      [L] 323 [O] 330 [B] 333 [A] 328 [L] 400 --> 274
+ |       |              [V] 336 [A] 331 [R] 403 --> 281
+ |      [T] 406 --> 119
+[I] 334 [M] 337 [P] 339 [O] 338 [R] 341 [T] 407 --> 285
+ |      [N] 342 [C] 408 --> 105
+ |               |      [L] 414 --> 91
+ |              [D] 346 [E] 344 [X] 353 [D] 419 --> 12
+ |                                      [S] 422 --> 10
+ |                                      [W] 423 --> 11
+[J] 357 [C] 362 [A] 348 [S] 360 [E] 430 --> 157
+ |      [E] 363 [Q] 434 --> 123
+ |       |              [Z] 438 --> 145
+ |      [G] 372 [E] 364 [Q] 443 --> 131
+ |       |       |              [Z] 446 --> 141
+ |       |      [T] 447 --> 127
+ |       |              [Z] 448 --> 137
+ |      [L] 380 [E] 369 [Q] 451 --> 129
+ |       |       |              [Z] 452 --> 139
+ |       |      [T] 453 --> 125
+ |       |              [Z] 454 --> 135
+ |      [N] 386 [E] 376 [Q] 458 --> 133
+ |       |                      [Z] 459 --> 143
+ |      [P] 378 [R] 382 [O] 396 [C] 462 --> 253
+ |      [R] 401 [A] 389 [N] 397 [G] 402 [E] 465 --> 159
+ |      [U] 392 [M] 390 [P] 472 --> 147
+[L] 409 [A] 410 [B] 404 [E] 399 [L] 479 --> 275
+ |      [D] 424 [G] 436 [C] 480 --> 45
+ |       |       |      [D] 481 --> 85
+ |       |       |      [F] 483 --> 47
+ |       |       |      [Q] 485 --> 89
+ |       |       |      [S] 486 --> 43
+ |       |       |      [W] 489 --> 41
+ |       |      [I] 444 [C] 490 --> 66
+ |       |       |      [D] 491 --> 71
+ |       |       |      [F] 494 --> 64
+ |       |       |      [Q] 496 --> 73
+ |       |       |      [S] 498 --> 65
+ |       |       |      [W] 501 --> 63
+ |       |      [K] 439 [D] 505 --> 77
+ |       |       |      [F] 508 --> 5
+ |       |       |      [Q] 510 --> 81
+ |       |       |      [W] 513 --> 3
+ |       |      [L] 468 [C] 515 --> 27
+ |       |       |      [D] 516 --> 83
+ |       |       |      [F] 518 --> 29
+ |       |       |      [Q] 521 --> 87
+ |       |       |      [S] 522 --> 25
+ |       |       |      [W] 528 --> 21
+ |       |      [N] 442 [W] 530 --> 57
+ |      [E] 461 [Q] 532 --> 120
+ |      [I] 456 [N] 470 [E] 540 --> 287
+ |       |              [K] 544 --> 251
+ |      [N] 467 [U] 469 [M] 547 --> 268
+ |      [O] 492 [A] 482 [D] 493 [C] 553 --> 15
+ |       |       |              [D] 554 --> 75
+ |       |       |              [F] 556 --> 16
+ |       |       |              [Q] 558 --> 79
+ |       |       |              [S] 562 --> 14
+ |       |       |              [W] 564 --> 13
+ |       |      [C] 500 [A] 495 [L] 566 --> 7
+ |      [S] 497 [L] 567 --> 111
+ |       |      [R] 568 --> 112
+ |      [T] 569 --> 118
+[M] 499 [I] 503 [N] 502 [U] 487 [S] 575 --> 99
+ |      [O] 509 [D] 582 --> 116
+ |                      [U] 507 [L] 517 [E] 584 --> 283
+[N] 523 [C] 519 [H] 520 [E] 526 [C] 524 [K] 585 --> 234
+ |      [E] 514 [Q] 588 --> 122
+ |      [O] 512 [T] 594 --> 104
+[O] 527 [F] 531 [F] 525 [S] 529 [E] 533 [T] 600 --> 9
+ |      [R] 603 --> 103
+[P] 537 [C] 541 [A] 534 [L] 535 [L] 605 --> 288
+ |       |                              [W] 607 --> 289
+ |      [L] 536 [U] 542 [S] 612 --> 98
+ |      [O] 538 [P] 614 --> 97
+ |      [R] 550 [I] 543 [M] 559 [D] 546 [E] 560 [F] 624 --> 278
+ |       |      [O] 561 [C] 626 --> 276
+ |      [U] 548 [S] 563 [H] 632 --> 0
+[Q] 570 [C] 557 [M] 565 [P] 633 --> 209
+ |       |      [O] 571 [N] 573 [S] 574 [T] 640 --> 273
+ |      [D] 590 [E] 586 [C] 642 --> 156
+ |       |      [I] 576 [V] 651 --> 153
+ |      [E] 580 [Q] 652 --> 210
+ |      [G] 595 [E] 587 [Q] 657 --> 214
+ |       |      [T] 665 --> 212
+ |      [I] 591 [N] 599 [C] 670 --> 155
+ |      [J] 602 [E] 593 [Q] 672 --> 216
+ |       |      [G] 606 [E] 596 [Q] 676 --> 220
+ |       |       |      [T] 681 --> 218
+ |       |      [L] 613 [E] 604 [Q] 683 --> 219
+ |       |       |      [T] 684 --> 217
+ |       |      [N] 617 [E] 608 [Q] 687 --> 221
+ |      [L] 619 [E] 610 [Q] 693 --> 213
+ |       |      [T] 694 --> 211
+ |      [M] 622 [I] 618 [N] 615 [U] 616 [S] 698 --> 150
+ |       |      [O] 634 [D] 704 --> 154
+ |      [N] 636 [E] 625 [Q] 707 --> 215
+ |      [P] 635 [L] 623 [U] 627 [S] 709 --> 149
+ |      [T] 639 [I] 637 [M] 644 [E] 638 [S] 715 --> 151
+ |      [U] 641 [M] 643 [I] 645 [N] 646 [U] 647 [S] 717 --> 152
+ |      [Z] 653 [C] 650 [H] 655 [E] 658 [C] 654 [K] 719 --> 239
+[R] 659 [E] 649 [S] 656 [U] 660 [L] 661 [T] 667 [D] 726 --> 264
+ |       |       |                              [F] 727 --> 265
+ |       |       |                              [Q] 734 --> 266
+ |       |       |                              [W] 739 --> 263
+ |       |      [T] 662 [U] 664 [R] 666 [N] 740 --> 267
+ |       |                                      [D] 742 --> 261
+ |       |                                      [F] 743 --> 260
+ |       |                                      [Q] 749 --> 262
+ |       |                                      [W] 750 --> 259
+ |      [O] 669 [R] 752 --> 114
+[S] 688 [A] 671 [V] 686 [E] 680 [L] 685 [I] 682 [N] 690 [K] 759 --> 252
+ |      [L] 689 [I] 695 [D] 692 [E] 766 --> 254
+ |       |                              [D] 767 --> 256
+ |       |                              [F] 768 --> 257
+ |       |                              [Q] 769 --> 258
+ |       |                              [W] 770 --> 255
+ |      [T] 703 [G] 716 [C] 771 --> 53
+ |       |       |      [D] 773 --> 86
+ |       |       |      [F] 777 --> 55
+ |       |       |      [Q] 780 --> 90
+ |       |       |      [S] 787 --> 51
+ |       |       |      [W] 788 --> 49
+ |       |      [I] 724 [C] 789 --> 70
+ |       |       |      [D] 790 --> 72
+ |       |       |      [F] 793 --> 68
+ |       |       |      [Q] 795 --> 74
+ |       |       |      [S] 796 --> 69
+ |       |       |      [W] 798 --> 67
+ |       |      [K] 723 [M] 736 [A] 722 [P] 804 --> 286
+ |       |      [L] 745 [C] 806 --> 37
+ |       |       |      [D] 809 --> 84
+ |       |       |      [F] 814 --> 39
+ |       |       |      [Q] 816 --> 88
+ |       |       |      [S] 817 --> 35
+ |       |       |      [W] 818 --> 31
+ |       |      [N] 732 [W] 820 --> 60
+ |       |      [O] 741 [R] 753 [E] 763 [C] 824 --> 19
+ |       |       |                      [D] 825 --> 76
+ |       |       |                      [F] 829 --> 20
+ |       |       |                      [Q] 835 --> 80
+ |       |       |                      [S] 837 --> 18
+ |       |       |                      [W] 838 --> 17
+ |       |      [R] 772 [I] 761 [N] 778 [G] 840 --> 280
+ |      [W] 776 [A] 762 [P] 843 --> 96
+[T] 779 [E] 774 [S] 775 [T] 783 [G] 782 [E] 781 [Q] 855 --> 161
+ |      [I] 784 [M] 791 [E] 785 [S] 856 --> 100
+[U] 786 [M] 792 [I] 794 [N] 797 [U] 800 [S] 858 --> 101
+[W] 799 [O] 802 [R] 801 [D] 864 --> 282
+[Z] 803 [C] 805 [H] 807 [E] 808 [C] 810 [K] 866 --> 236
+*/
+
+short templ_trie[NTRIE] = {
+   0,    0,    0,  242,  243,  102,  113,  107,  110,  108, 
+   0,    0,    0,    0,  109,  233,    0,  269,    0,    0, 
+ 250,    0,  249,    0,    0,    0,    0,    0,  248,  247, 
+   0,    0,    0,  158,    0,  270,  227,  225,  226,  224, 
+   0,    0,    0,    0,    0,    0,    0,  228,    0,    0, 
+   0,    0,    0,  246,    0,  223,  222,  230,  229,    0, 
+ 232,  231,  192,  191,  272,   10,   19,   50,   85,  190, 
+ 212,  321,   11,  334,  357,    1,  409,  499,  523,  527, 
+ 537,  570,  659,  688,  779,  786,    2,  799,   26,   24, 
+ 803,    3,   12,   13,    5,    6,   32,   21,   18,   34, 
+   8,   44,    7,   31,   16,    9,   30,    4,   15,   40, 
+  25,   23,   14,   49,   41,   42,   17,   46,   43,   53, 
+  27,   20,   33,   22,   36,   48,  189,   38,   51,   52, 
+  45,   68,   37,   60,   28,   35,   54,   39,   59,   81, 
+  29,   47,   55,   61,   56,  106,   74,   95,   67,   65, 
+  73,   77,   71,   66,  106,   57,  111,   58,   98,  120, 
+  80,  148,  150,  160,   64,  157,   62,  126,   93,  164, 
+ 165,   63,   96,  145,  108,  184,   99,  178,  279,  193, 
+ 100,  182,  198,  196,  185,  115,  188,  179,  199,  105, 
+ 112,  121,  204,  192,  202,  183,  128,  118,  133,  200, 
+ 203,  201,  122,  206,  138,  194,  200,  127,  210,  144, 
+ 208,  206,  201,  134,  207,  214,  205,  137,  219,  197, 
+ 195,  168,  211,  146,  140,  143,  227,  187,  216,  149, 
+ 231,  194,  220,  151,  186,  234,  152,  161,  170,  158, 
+ 188,  240,  171,  190,  169,  246,   95,  163,  166,  243, 
+ 186,  180,  181,  187,  238,  173,  174,  189,  177,  176, 
+ 261,  241,  254,  264,  277,  191,  284,  117,  195,  240, 
+ 169,  267,  193,  266,  168,  198,  271,  196,  269,  205, 
+ 221,  223,  207,  236,  213,  224,  245,  222,  277,  283, 
+ 295,  217,  291,  270,  209,  301,  298,  299,  274,  276, 
+ 215,  166,  315,  170,  303,  225,  307,  175,  173,  232, 
+ 226,  230,  242,  244,  237,  313,  250,  176,  317,  241, 
+ 308,  257,  324,  262,  181,  179,  247,  180,  327,  178, 
+ 332,  249,  177,  268,  325,  185,  197,  258,  273,  335, 
+ 183,  329,  263,  184,  343,  182,  272,  174,  271,  351, 
+ 275,  245,  340,  347,  172,  260,  280,  345,  278,  164, 
+ 281,  354,  359,  279,  284,  366,  171,  285,  163,  368, 
+ 286,  296,  375,  305,  289,  165,  304,  300,  294,  297, 
+ 381,  167,  311,  316,  387,  319,  309,  237,  320,  394, 
+ 318,  326,  322,  314,  235,  121,  333,  323,  328,  395, 
+ 274,  331,  330,  281,  400,  406,  119,  285,  105,  408, 
+ 346,  337,  342,  403,   91,  344,  336,  339,  338,   12, 
+ 341,  419,   10,   11,  362,  407,  363,  348,  372,  430, 
+ 157,  360,  353,  380,  123,  386,  422,  378,  145,  401, 
+ 423,  364,  392,  131,  434,  443,  141,  127,  137,  369, 
+ 451,  129,  139,  125,  135,  376,  447,  458,  133,  143, 
+ 382,  396,  253,  462,  453,  159,  389,  397,  402,  390, 
+ 472,  465,  147,  399,  410,  479,  404,  424,  461,  275, 
+  45,   85,  456,   47,  414,   89,   43,  467,  492,   41, 
+  66,   71,  497,  569,   64,  436,   73,  444,   65,  439, 
+ 468,   63,  442,  480,  481,   77,  483,  505,    5,  508, 
+  81,  490,  491,    3,  494,   27,   83,  485,   29,  486, 
+ 510,   87,   25,  489,  438,  496,  513,  498,   21,  530, 
+  57,  501,  120,  446,  470,  515,  516,  448,  518,  540, 
+ 287,  452,  532,  454,  251,  544,  547,  268,  459,  521, 
+ 493,  522,  469,   15,   75,  528,   16,  482,   79,  500, 
+ 553,  554,   14,  556,   13,  495,    7,  111,  112,  118, 
+ 575,  566,  503,  567,  558,   99,  562,  582,  509,  568, 
+ 564,  502,  116,  517,  283,  234,  584,  487,  122,  526, 
+ 519,  520,  514,  524,  104,  588,  594,  531,  533,  585, 
+   9,  525,  512,  103,  541,  288,  534,  289,  529,  603, 
+ 535,  605,   98,  536,   97,  560,  538,  600,  614,  550, 
+ 559,  542,  548,  543,  278,  612,  276,  546,  626,  561, 
+ 624,  563,    0,  209,  565,  632,  571,  557,  590,  580, 
+ 273,  595,  156,  591,  602,  633,  619,  622,  636,  573, 
+ 635,  153,  210,  642,  639,  641,  574,  214,  640,  586, 
+ 653,  652,  651,  576,  587,  212,  670,  507,  657,  599, 
+ 155,  593,  216,  606,  672,  596,  220,  676,  613,  665, 
+ 617,  218,  604,  219,  217,  683,  608,  221,  610,  687, 
+ 681,  693,  607,  213,  211,  618,  615,  684,  150,  698, 
+ 616,  634,  704,  694,  154,  625,  707,  215,  627,  149, 
+ 709,  623,  637,  638,  644,  151,  645,  152,  643,  239, 
+ 650,  715,  655,  646,  658,  654,  264,  265,  649,  719, 
+ 717,  647,  656,  662,  266,  726,  661,  727,  669,  263, 
+ 267,  660,  261,  260,  740,  667,  666,  664,  734,  262, 
+ 259,  752,  114,  671,  739,  680,  685,  686,  682,  252, 
+ 690,  766,  695,  692,  689,  759,  254,  256,  257,  258, 
+ 255,   53,  703,   86,  716,  776,  724,   55,  723,  745, 
+  90,  732,  741,  771,  773,  772,  777,   51,   49,   70, 
+  72,  789,  790,   68,  793,   74,   69,  780,   67,  787, 
+ 736,  722,  804,  788,  286,  795,   37,  796,  742,   84, 
+ 743,  798,  806,  809,   39,  814,   88,   35,   31,  820, 
+  60,  749,  763,  753,   19,   76,  816,  750,  817,   20, 
+ 824,  825,  818,  829,  767,   80,  768,   18,   17,  778, 
+ 280,  762,  843,   96,  835,  761,  837,  769,  774,  840, 
+ 838,  781,  784,  770,  782,  161,  100,  775,  101,  783, 
+ 785,  791,  855,  792,  282,  794,  236,    0,  856,  864, 
+ 805,    0,  797,    0,    0,  810,  808,  807,  802,    0, 
+   0,    0,  800,  858,  801,  866,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+   0,    0,    0,    0,    0, 
+};
+
+uchar templ_check[NTRIE] = {
+ 128,  128,  128,    0,    0,    0,    0,    0,    0,    0, 
+ 128,  128,  128,  128,    0,    0,  128,    0,  128,  128, 
+   0,  128,    0,  128,  128,  128,  128,  128,    0,    0, 
+ 128,  128,  128,    0,  128,    0,    0,    0,    0,    0, 
+ 128,  128,  128,  128,  128,  128,  128,    0,  128,  128, 
+ 128,  128,  128,    0,  128,    0,    0,    0,    0,  128, 
+   0,    0,    0,    0,    0,  'A',  'B',  'C',  'D',  'E', 
+ 'F',  'G',  'G',  'I',  'J',  'I',  'L',  'M',  'N',  'O', 
+ 'P',  'Q',  'R',  'S',  'T',  'U',  'L',  'W',  'N',  'N', 
+ 'Z',  'C',  'I',  'S',  'D',  'R',  'T',  'A',  'O',  'N', 
+ 'T',  'R',  'D',  'U',  'O',  'R',  'O',  'S',  'D',  'N', 
+ 'N',  'O',  'R',  'E',  'A',  'A',  'K',  'E',  'L',  'L', 
+ 'X',  'D',  'L',  'F',  'F',  'S',    0,  'D',  'S',  'O', 
+ 'N',  'V',  'N',  'D',  'Q',  'T',  'D',  'N',  'F',  'I', 
+ 'W',  'C',  'D',  'N',  'F',    0,  'N',  'P',  'M',  'Q', 
+ 'O',  'N',  'C',  'D',  'E',  'Q',  'G',  'S',  'I',  'J', 
+ 'S',  'L',  'M',  'N',  'T',  'P',  'G',  'V',    0,  'T', 
+ 'U',  'L',  'I',  'C',  'N',  'Z',  'F',  'E',    0,    0, 
+ 'E',  'Q',    0,    0,  'V',    0,  'Q',  'Q',    0,  'E', 
+ 'E',  'G',    0,  'Q',    0,  'T',  'L',  'E',  'N',  'Q', 
+   0,    0,  'E',  'Q',  'G',  'T',    0,  'E',  'Q',  'L', 
+   0,    0,  'T',  'E',    0,  'Q',    0,  'E',  'Q',    0, 
+   0,  'L',  'T',  'I',  'N',  'U',  'S',    0,  'T',  'E', 
+ 'Q',    0,  'T',  'L',    0,  'S',  'U',  'I',  'M',  'E', 
+   0,  'S',  'M',    0,  'I',  'P',    0,  'N',  'U',  'S', 
+ 'E',  'C',  'H',  'C',    0,  'A',  'S',  'S',  'E',  'R', 
+ 'T',    0,  'K',  'D',    0,  'D',    0,    0,  'N',    0, 
+   0,  'Q',  'R',  'R',    0,  'R',    0,  'O',  'R',  'C', 
+ 'D',  'E',  'M',  'G',  'O',  'I',  'J',  'P',  'L',  'M', 
+ 'N',  'N',  'P',  'G',  'I',  'V',  'T',  'U',  'L',  'T', 
+ 'S',    0,  'Z',    0,  'Q',  'E',  'Q',    0,    0,  'C', 
+ 'P',  'O',  'X',    0,  'E',  'Y',  'G',    0,  'Q',  'E', 
+ 'T',  'L',  'Q',  'N',    0,    0,  'E',    0,  'Q',    0, 
+ 'Q',  'E',    0,  'G',  'T',    0,  'H',  'E',  'L',  'Q', 
+   0,  'T',  'E',    0,  'Q',    0,  'E',    0,  'C',  'Y', 
+ 'O',    0,  'T',  'Q',    0,  'P',  'I',  'T',  'N',    0, 
+ 'X',  'T',  'S',  'U',  'E',  'Q',    0,  'L',    0,  'S', 
+ 'U',  'I',  'S',  'M',  'E',    0,  'M',  'I',  'N',  'U', 
+ 'S',    0,  'C',  'H',  'K',  'E',  'C',    0,  'C',  'K', 
+ 'E',  'E',  'H',  'C',    0,    0,  'B',  'L',  'A',  'Q', 
+   0,  'A',  'O',    0,  'L',  'T',    0,    0,    0,  'C', 
+ 'D',  'M',  'N',  'R',    0,  'E',  'V',  'P',  'O',    0, 
+ 'R',  'D',    0,    0,  'C',  'T',  'E',  'A',  'G',  'E', 
+   0,  'S',  'X',  'L',    0,  'N',  'S',  'P',    0,  'R', 
+ 'W',  'E',  'U',    0,  'Q',  'Q',    0,    0,    0,  'E', 
+ 'Q',    0,    0,    0,    0,  'E',  'T',  'Q',    0,    0, 
+ 'R',  'O',    0,  'C',  'T',    0,  'A',  'N',  'G',  'M', 
+ 'P',  'E',    0,  'E',  'A',  'L',  'B',  'D',  'E',    0, 
+   0,    0,  'I',    0,  'L',    0,    0,  'N',  'O',    0, 
+   0,    0,  'S',  'T',    0,  'G',    0,  'I',    0,  'K', 
+ 'L',    0,  'N',  'C',  'D',    0,  'F',  'D',    0,  'F', 
+   0,  'C',  'D',    0,  'F',    0,    0,  'Q',    0,  'S', 
+ 'Q',    0,    0,  'W',  'Z',  'Q',  'W',  'S',    0,  'W', 
+   0,  'W',    0,  'Z',  'N',  'C',  'D',  'Z',  'F',  'E', 
+   0,  'Z',  'Q',  'Z',    0,  'K',  'M',    0,  'Z',  'Q', 
+ 'D',  'S',  'U',    0,    0,  'W',    0,  'A',    0,  'C', 
+ 'C',  'D',    0,  'F',    0,  'A',    0,    0,    0,    0, 
+ 'S',  'L',  'I',  'L',  'Q',    0,  'S',  'D',  'O',  'R', 
+ 'W',  'N',    0,  'L',    0,    0,  'E',  'U',    0,  'E', 
+ 'C',  'H',  'E',  'C',    0,  'Q',  'T',  'F',  'E',  'K', 
+   0,  'F',  'O',    0,  'C',    0,  'A',    0,  'S',  'R', 
+ 'L',  'L',    0,  'L',    0,  'E',  'O',  'T',  'P',  'R', 
+ 'M',  'U',  'U',  'I',    0,  'S',    0,  'D',  'C',  'O', 
+ 'F',  'S',    0,    0,  'M',  'H',  'O',  'C',  'D',  'E', 
+   0,  'G',    0,  'I',  'J',  'P',  'L',  'M',  'N',  'N', 
+ 'P',    0,    0,  'C',  'T',  'U',  'S',    0,  'T',  'E', 
+ 'Z',  'Q',  'V',  'I',  'E',    0,  'C',  'U',  'Q',  'N', 
+   0,  'E',    0,  'G',  'Q',  'E',    0,  'Q',  'L',  'T', 
+ 'N',    0,  'E',    0,    0,  'Q',  'E',    0,  'E',  'Q', 
+ 'T',  'Q',  'W',    0,    0,  'I',  'N',  'T',    0,  'S', 
+ 'U',  'O',  'D',  'T',    0,  'E',  'Q',    0,  'U',    0, 
+ 'S',  'L',  'I',  'E',  'M',    0,  'I',    0,  'M',    0, 
+ 'C',  'S',  'H',  'N',  'E',  'C',    0,    0,  'E',  'K', 
+ 'S',  'U',  'S',  'T',    0,  'D',  'L',  'F',  'O',    0, 
+   0,  'U',    0,    0,  'N',  'T',  'R',  'U',  'Q',    0, 
+   0,  'R',    0,  'A',  'W',  'E',  'L',  'V',  'I',    0, 
+ 'N',  'E',  'I',  'D',  'L',  'K',    0,    0,    0,    0, 
+   0,    0,  'T',    0,  'G',  'W',  'I',    0,  'K',  'L', 
+   0,  'N',  'O',  'C',  'D',  'R',  'F',    0,    0,    0, 
+   0,  'C',  'D',    0,  'F',    0,    0,  'Q',    0,  'S', 
+ 'M',  'A',  'P',  'W',    0,  'Q',    0,  'S',  'D',    0, 
+ 'F',  'W',  'C',  'D',    0,  'F',    0,    0,    0,  'W', 
+   0,  'Q',  'E',  'R',    0,    0,  'Q',  'W',  'S',    0, 
+ 'C',  'D',  'W',  'F',  'D',    0,  'F',    0,    0,  'N', 
+   0,  'A',  'P',    0,  'Q',  'I',  'S',  'Q',  'E',  'G', 
+ 'W',  'E',  'I',  'W',  'G',    0,    0,  'S',    0,  'T', 
+ 'E',  'M',  'Q',  'M',    0,  'I',    0,  128,  'S',  'D', 
+ 'C',  128,  'N',  128,  128,  'C',  'E',  'H',  'O',  128, 
+ 128,  128,  'U',  'S',  'R',  'K',  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128,  128,  128,  128,  128,  128, 
+ 128,  128,  128,  128,  128, 
+};