/*
  Print with:
  enscript -2rGC -T 2 -f Courier6 -o z80.ps z80.md
*/

/*
	Notes:

		Variadic functions *MUST* have a prototype for the arguments
		to be passed on the stack.

		sizeof(char)      == 1
		sizeof(short)     == 1
		sizeof(int)       == 2
		sizeof(long)      == 4
		sizeof(long long) == 4
		sizeof(float)     == 4

		Using unsigned values is always more efficient.

		Comparing values for (un)equality is always the most
		efficient.

		When using 8-bit arithmetics, use short instead of char.
*/

/* Macro to make code generation easier to isolate in the file */
#define GENERATE________

#define NBREG_8		6

#ifdef GAMEBOY
#define NBREG_16	3
#else
#define NBREG_16	5
#endif

#define NBREG_32	8

enum {
  B_=0,
  D_=1,
  H_=2,
  _C=3,
  _E=4,
  _L=5
};

enum {
  BC=0,
  DE=1,
  HL=2,
#ifdef GAMEBOY
#else
  IX=3,
  IY=4
#endif
};

#include "c.h"
#define NODEPTR_TYPE Node
#define OP_LABEL(p) ((p)->op)
#define LEFT_CHILD(p) ((p)->kids[0])
#define RIGHT_CHILD(p) ((p)->kids[1])
#define LEFT_X_CHILD(p) ((p)->x.kids[0])
#define RIGHT_X_CHILD(p) ((p)->x.kids[1])
#define STATE_LABEL(p) ((p)->x.state)

static void address(Symbol, Symbol, long);
static void blkfetch(int, int, int, int);
static void blkloop(int, int, int, int, int, int[]);
static void blkstore(int, int, int, int);
static void defaddress(Symbol);
static void defconst(int, int, Value);
static void defstring(int, char *);
static void defsymbol(Symbol);
static void doarg(Node);
static void emit2(Node);
static void export(Symbol);
static void clobber(Node);
static void function(Symbol, Symbol [], Symbol [], int);
static void global(Symbol);
static void import(Symbol);
static void local(Symbol);
static void progbeg(int, char **);
static void progend(void);
static void segment(int);
static void space(int);
static void target(Node);
static int ckstack(Node, int);
static int memop(Node);
static int sametree(Node, Node);
static void stabinit(char *, int, char *[]);
static void stabline(Coordinate *);

#ifdef GAMEBOY
#else
static Symbol argreg(Symbol, int, int, int);
#endif

static void debug_node(Node);
static int move_r(Node);
static int save(int);
static int restore(int);
static void offsetsp(int);
#ifdef GAMEBOY
static void offsethl(int);
#endif
static void load_32(Node);
static void store_32(Node);
static int const_val(Node);
static int tmp8(int);
static int tmp16(int);

#define STR str_alloc
/* #define STR stringf */

static char *currentfile;
static int currentline;
static FILE *srcfp;
static int srcpos;

static Symbol reg8[32], reg16[32], reg32[32];
static Symbol reg8w, reg16w, reg32w;

static unsigned freereg = 0;

/* Long registers */
static char *xreg[] = {
  ".lreg0",
  ".lreg1",
  ".lreg2",
  ".lreg3",
  ".lreg4",
  ".lreg5",
  ".lreg6",
  ".lreg7"
};

/* Word registers */
static char *wreg[] = {
  "BC",
  "DE",
  "HL",
#ifdef GAMEBOY
#else
  "IX",
  "IY"
#endif
};

/* High-byte registers */
static char *hreg[] = {
  "B",
  "D",
  "H"
};

/* Low-byte registers */
static char *lreg[] = {
  "C",
  "E",
  "L"
};

/* Byte registers */
static char *breg[] = {
  "B",
  "D",
  "H",
  "C",
  "E",
  "L"
};

static int cseg;
static int debug;
static int optimize;
static int comments;
static char rom_bank_str[32];
static char ram_bank_str[32];
static int argstack;

#include "opt.c"

/*
generated at Sun Feb 07 11:09:52 1999
by $Id: lburg.c,v 1.1.1.1 1998/10/01 16:08:34 felber Exp $
*/
static void _kids(NODEPTR_TYPE, int, NODEPTR_TYPE[]);
static void _label(NODEPTR_TYPE);
static int _rule(void*, int);

#define _stmt_NT 1
#define _reg_NT 2
#define _con_NT 3
#define _con8_NT 4
#define _stk_NT 5
#define _base_NT 6
#define _addr_NT 7
#define _mem_NT 8
#define _rc_NT 9
#define _mr_NT 10
#define _mrc_NT 11
#define _rc8_NT 12
#define _addrj_NT 13
#define _memf_NT 14
#define _miaf_NT 15
#define _mrf_NT 16
#define _maf_NT 17

static char *_ntname[] = {
	0,
	"stmt",
	"reg",
	"con",
	"con8",
	"stk",
	"base",
	"addr",
	"mem",
	"rc",
	"mr",
	"mrc",
	"rc8",
	"addrj",
	"memf",
	"miaf",
	"mrf",
	"maf",
	0
};

struct _state {
	short cost[18];
	struct {
		unsigned int _stmt:8;
		unsigned int _reg:8;
		unsigned int _con:3;
		unsigned int _con8:3;
		unsigned int _stk:2;
		unsigned int _base:2;
		unsigned int _addr:2;
		unsigned int _mem:2;
		unsigned int _rc:2;
		unsigned int _mr:2;
		unsigned int _mrc:2;
		unsigned int _rc8:2;
		unsigned int _addrj:2;
		unsigned int _memf:2;
		unsigned int _miaf:2;
		unsigned int _mrf:2;
		unsigned int _maf:2;
	} rule;
};

static short _nts_0[] = { 0 };
static short _nts_1[] = { _reg_NT, 0 };
static short _nts_2[] = { _con_NT, 0 };
static short _nts_3[] = { _base_NT, 0 };
static short _nts_4[] = { _stk_NT, 0 };
static short _nts_5[] = { _addr_NT, 0 };
static short _nts_6[] = { _mem_NT, 0 };
static short _nts_7[] = { _rc_NT, 0 };
static short _nts_8[] = { _mrc_NT, 0 };
static short _nts_9[] = { _reg_NT, _mrc_NT, 0 };
static short _nts_10[] = { _reg_NT, _rc_NT, 0 };
static short _nts_11[] = { _mr_NT, 0 };
static short _nts_12[] = { _con8_NT, 0 };
static short _nts_13[] = { _reg_NT, _rc8_NT, 0 };
static short _nts_14[] = { _reg_NT, _reg_NT, 0 };
static short _nts_15[] = { _addr_NT, _mem_NT, _rc_NT, 0 };
static short _nts_16[] = { _addr_NT, _mem_NT, 0 };
static short _nts_17[] = { _addr_NT, _mem_NT, _con8_NT, 0 };
static short _nts_18[] = { _addr_NT, _rc_NT, 0 };
static short _nts_19[] = { _stk_NT, _rc_NT, 0 };
static short _nts_20[] = { _addrj_NT, 0 };
static short _nts_21[] = { _mem_NT, _con_NT, 0 };
static short _nts_22[] = { _memf_NT, 0 };
static short _nts_23[] = { _miaf_NT, 0 };
static short _nts_24[] = { _addr_NT, _mrf_NT, 0 };
static short _nts_25[] = { _maf_NT, 0 };
static short _nts_26[] = { _maf_NT, _maf_NT, 0 };
static short _nts_27[] = { _addr_NT, _maf_NT, 0 };
static short _nts_28[] = { _addr_NT, _maf_NT, _maf_NT, 0 };

static short *_nts[] = {
	0,	/* 0 */
	_nts_0,	/* 1 */
	_nts_0,	/* 2 */
	_nts_0,	/* 3 */
	_nts_0,	/* 4 */
	_nts_0,	/* 5 */
	_nts_1,	/* 6 */
	_nts_1,	/* 7 */
	_nts_1,	/* 8 */
	_nts_1,	/* 9 */
	_nts_1,	/* 10 */
	_nts_0,	/* 11 */
	_nts_0,	/* 12 */
	_nts_0,	/* 13 */
	_nts_0,	/* 14 */
	_nts_0,	/* 15 */
	_nts_0,	/* 16 */
	_nts_0,	/* 17 */
	_nts_0,	/* 18 */
	_nts_0,	/* 19 */
	_nts_0,	/* 20 */
	_nts_1,	/* 21 */
	_nts_0,	/* 22 */
	_nts_0,	/* 23 */
	_nts_0,	/* 24 */
	_nts_0,	/* 25 */
	_nts_0,	/* 26 */
	_nts_2,	/* 27 */
	_nts_1,	/* 28 */
	_nts_3,	/* 29 */
	_nts_4,	/* 30 */
	_nts_5,	/* 31 */
	_nts_5,	/* 32 */
	_nts_2,	/* 33 */
	_nts_1,	/* 34 */
	_nts_6,	/* 35 */
	_nts_1,	/* 36 */
	_nts_6,	/* 37 */
	_nts_7,	/* 38 */
	_nts_5,	/* 39 */
	_nts_8,	/* 40 */
	_nts_5,	/* 41 */
	_nts_5,	/* 42 */
	_nts_5,	/* 43 */
	_nts_5,	/* 44 */
	_nts_5,	/* 45 */
	_nts_7,	/* 46 */
	_nts_7,	/* 47 */
	_nts_7,	/* 48 */
	_nts_7,	/* 49 */
	_nts_7,	/* 50 */
	_nts_9,	/* 51 */
	_nts_9,	/* 52 */
	_nts_10,	/* 53 */
	_nts_10,	/* 54 */
	_nts_10,	/* 55 */
	_nts_9,	/* 56 */
	_nts_9,	/* 57 */
	_nts_10,	/* 58 */
	_nts_10,	/* 59 */
	_nts_10,	/* 60 */
	_nts_9,	/* 61 */
	_nts_9,	/* 62 */
	_nts_10,	/* 63 */
	_nts_10,	/* 64 */
	_nts_9,	/* 65 */
	_nts_9,	/* 66 */
	_nts_10,	/* 67 */
	_nts_10,	/* 68 */
	_nts_9,	/* 69 */
	_nts_9,	/* 70 */
	_nts_10,	/* 71 */
	_nts_10,	/* 72 */
	_nts_11,	/* 73 */
	_nts_11,	/* 74 */
	_nts_1,	/* 75 */
	_nts_1,	/* 76 */
	_nts_11,	/* 77 */
	_nts_1,	/* 78 */
	_nts_12,	/* 79 */
	_nts_1,	/* 80 */
	_nts_13,	/* 81 */
	_nts_13,	/* 82 */
	_nts_13,	/* 83 */
	_nts_13,	/* 84 */
	_nts_13,	/* 85 */
	_nts_13,	/* 86 */
	_nts_13,	/* 87 */
	_nts_13,	/* 88 */
	_nts_14,	/* 89 */
	_nts_14,	/* 90 */
	_nts_14,	/* 91 */
	_nts_14,	/* 92 */
	_nts_14,	/* 93 */
	_nts_14,	/* 94 */
	_nts_14,	/* 95 */
	_nts_14,	/* 96 */
	_nts_14,	/* 97 */
	_nts_14,	/* 98 */
	_nts_14,	/* 99 */
	_nts_14,	/* 100 */
	_nts_15,	/* 101 */
	_nts_15,	/* 102 */
	_nts_15,	/* 103 */
	_nts_15,	/* 104 */
	_nts_15,	/* 105 */
	_nts_15,	/* 106 */
	_nts_15,	/* 107 */
	_nts_15,	/* 108 */
	_nts_15,	/* 109 */
	_nts_15,	/* 110 */
	_nts_16,	/* 111 */
	_nts_16,	/* 112 */
	_nts_16,	/* 113 */
	_nts_17,	/* 114 */
	_nts_17,	/* 115 */
	_nts_17,	/* 116 */
	_nts_17,	/* 117 */
	_nts_1,	/* 118 */
	_nts_1,	/* 119 */
	_nts_1,	/* 120 */
	_nts_1,	/* 121 */
	_nts_1,	/* 122 */
	_nts_1,	/* 123 */
	_nts_1,	/* 124 */
	_nts_1,	/* 125 */
	_nts_1,	/* 126 */
	_nts_1,	/* 127 */
	_nts_18,	/* 128 */
	_nts_18,	/* 129 */
	_nts_18,	/* 130 */
	_nts_18,	/* 131 */
	_nts_18,	/* 132 */
	_nts_19,	/* 133 */
	_nts_19,	/* 134 */
	_nts_19,	/* 135 */
	_nts_19,	/* 136 */
	_nts_19,	/* 137 */
	_nts_8,	/* 138 */
	_nts_8,	/* 139 */
	_nts_1,	/* 140 */
	_nts_1,	/* 141 */
	_nts_1,	/* 142 */
	_nts_14,	/* 143 */
	_nts_1,	/* 144 */
	_nts_0,	/* 145 */
	_nts_1,	/* 146 */
	_nts_20,	/* 147 */
	_nts_0,	/* 148 */
	_nts_9,	/* 149 */
	_nts_9,	/* 150 */
	_nts_9,	/* 151 */
	_nts_9,	/* 152 */
	_nts_9,	/* 153 */
	_nts_9,	/* 154 */
	_nts_9,	/* 155 */
	_nts_9,	/* 156 */
	_nts_9,	/* 157 */
	_nts_9,	/* 158 */
	_nts_9,	/* 159 */
	_nts_9,	/* 160 */
	_nts_21,	/* 161 */
	_nts_21,	/* 162 */
	_nts_21,	/* 163 */
	_nts_21,	/* 164 */
	_nts_21,	/* 165 */
	_nts_21,	/* 166 */
	_nts_21,	/* 167 */
	_nts_21,	/* 168 */
	_nts_21,	/* 169 */
	_nts_21,	/* 170 */
	_nts_21,	/* 171 */
	_nts_21,	/* 172 */
	_nts_10,	/* 173 */
	_nts_10,	/* 174 */
	_nts_10,	/* 175 */
	_nts_10,	/* 176 */
	_nts_10,	/* 177 */
	_nts_10,	/* 178 */
	_nts_10,	/* 179 */
	_nts_10,	/* 180 */
	_nts_10,	/* 181 */
	_nts_10,	/* 182 */
	_nts_10,	/* 183 */
	_nts_10,	/* 184 */
	_nts_20,	/* 185 */
	_nts_20,	/* 186 */
	_nts_20,	/* 187 */
	_nts_20,	/* 188 */
	_nts_20,	/* 189 */
	_nts_20,	/* 190 */
	_nts_1,	/* 191 */
	_nts_1,	/* 192 */
	_nts_1,	/* 193 */
	_nts_1,	/* 194 */
	_nts_1,	/* 195 */
	_nts_1,	/* 196 */
	_nts_0,	/* 197 */
	_nts_0,	/* 198 */
	_nts_0,	/* 199 */
	_nts_1,	/* 200 */
	_nts_1,	/* 201 */
	_nts_1,	/* 202 */
	_nts_5,	/* 203 */
	_nts_5,	/* 204 */
	_nts_5,	/* 205 */
	_nts_0,	/* 206 */
	_nts_0,	/* 207 */
	_nts_0,	/* 208 */
	_nts_5,	/* 209 */
	_nts_5,	/* 210 */
	_nts_5,	/* 211 */
	_nts_22,	/* 212 */
	_nts_1,	/* 213 */
	_nts_22,	/* 214 */
	_nts_23,	/* 215 */
	_nts_24,	/* 216 */
	_nts_24,	/* 217 */
	_nts_24,	/* 218 */
	_nts_25,	/* 219 */
	_nts_25,	/* 220 */
	_nts_25,	/* 221 */
	_nts_25,	/* 222 */
	_nts_25,	/* 223 */
	_nts_25,	/* 224 */
	_nts_25,	/* 225 */
	_nts_1,	/* 226 */
	_nts_1,	/* 227 */
	_nts_1,	/* 228 */
	_nts_1,	/* 229 */
	_nts_1,	/* 230 */
	_nts_1,	/* 231 */
	_nts_25,	/* 232 */
	_nts_25,	/* 233 */
	_nts_25,	/* 234 */
	_nts_25,	/* 235 */
	_nts_13,	/* 236 */
	_nts_13,	/* 237 */
	_nts_13,	/* 238 */
	_nts_13,	/* 239 */
	_nts_26,	/* 240 */
	_nts_26,	/* 241 */
	_nts_26,	/* 242 */
	_nts_26,	/* 243 */
	_nts_26,	/* 244 */
	_nts_26,	/* 245 */
	_nts_26,	/* 246 */
	_nts_26,	/* 247 */
	_nts_26,	/* 248 */
	_nts_26,	/* 249 */
	_nts_26,	/* 250 */
	_nts_26,	/* 251 */
	_nts_26,	/* 252 */
	_nts_26,	/* 253 */
	_nts_26,	/* 254 */
	_nts_26,	/* 255 */
	_nts_26,	/* 256 */
	_nts_26,	/* 257 */
	_nts_26,	/* 258 */
	_nts_26,	/* 259 */
	_nts_27,	/* 260 */
	_nts_27,	/* 261 */
	_nts_27,	/* 262 */
	_nts_27,	/* 263 */
	_nts_28,	/* 264 */
	_nts_28,	/* 265 */
	_nts_28,	/* 266 */
	_nts_28,	/* 267 */
	_nts_28,	/* 268 */
	_nts_28,	/* 269 */
	_nts_28,	/* 270 */
	_nts_28,	/* 271 */
	_nts_28,	/* 272 */
	_nts_28,	/* 273 */
	_nts_28,	/* 274 */
	_nts_28,	/* 275 */
	_nts_28,	/* 276 */
	_nts_28,	/* 277 */
	_nts_28,	/* 278 */
	_nts_28,	/* 279 */
	_nts_28,	/* 280 */
	_nts_28,	/* 281 */
	_nts_28,	/* 282 */
	_nts_28,	/* 283 */
	_nts_26,	/* 284 */
	_nts_26,	/* 285 */
	_nts_26,	/* 286 */
	_nts_26,	/* 287 */
	_nts_26,	/* 288 */
	_nts_26,	/* 289 */
	_nts_26,	/* 290 */
	_nts_26,	/* 291 */
	_nts_26,	/* 292 */
	_nts_26,	/* 293 */
	_nts_26,	/* 294 */
	_nts_26,	/* 295 */
	_nts_26,	/* 296 */
	_nts_26,	/* 297 */
	_nts_26,	/* 298 */
	_nts_26,	/* 299 */
	_nts_26,	/* 300 */
	_nts_26,	/* 301 */
	_nts_20,	/* 302 */
	_nts_20,	/* 303 */
	_nts_20,	/* 304 */
	_nts_1,	/* 305 */
	_nts_1,	/* 306 */
	_nts_1,	/* 307 */
};

static char *_templates[] = {
/* 0 */	0,
/* 1 */	"# INDIRI1\n",	/* reg: INDIRI1(VREGP) */
/* 2 */	"# INDIRU1\n",	/* reg: INDIRU1(VREGP) */
/* 3 */	"# INDIRI2\n",	/* reg: INDIRI2(VREGP) */
/* 4 */	"# INDIRU2\n",	/* reg: INDIRU2(VREGP) */
/* 5 */	"# INDIRP2\n",	/* reg: INDIRP2(VREGP) */
/* 6 */	"# ASGNI1\n",	/* stmt: ASGNI1(VREGP,reg) */
/* 7 */	"# ASGNU1\n",	/* stmt: ASGNU1(VREGP,reg) */
/* 8 */	"# ASGNI2\n",	/* stmt: ASGNI2(VREGP,reg) */
/* 9 */	"# ASGNU2\n",	/* stmt: ASGNU2(VREGP,reg) */
/* 10 */	"# ASGNP2\n",	/* stmt: ASGNP2(VREGP,reg) */
/* 11 */	"%#%a",	/* con: CNSTI1 */
/* 12 */	"%#%a",	/* con: CNSTU1 */
/* 13 */	"%#%a",	/* con: CNSTI2 */
/* 14 */	"%#%a",	/* con: CNSTU2 */
/* 15 */	"%#%a",	/* con: CNSTP2 */
/* 16 */	"%#%a",	/* con: ADDRGP2 */
/* 17 */	"%#%a",	/* con8: CNSTI1 */
/* 18 */	"%#%a",	/* con8: CNSTU1 */
/* 19 */	"%#%a",	/* con8: CNSTI2 */
/* 20 */	"%#%a",	/* con8: CNSTU2 */
/* 21 */	"",	/* stmt: reg */
/* 22 */	"# ADDRGP2\n",	/* reg: ADDRGP2 */
/* 23 */	"# ADDRFP2\n",	/* reg: ADDRFP2 */
/* 24 */	"# ADDRLP2\n",	/* reg: ADDRLP2 */
/* 25 */	"%a+%F(SP)",	/* stk: ADDRFP2 */
/* 26 */	"%a+%F(SP)",	/* stk: ADDRLP2 */
/* 27 */	"%0",	/* base: con */
/* 28 */	"%0",	/* base: reg */
/* 29 */	"%0",	/* addr: base */
/* 30 */	"%0",	/* addr: stk */
/* 31 */	"# INDIRI1",	/* mem: INDIRI1(addr) */
/* 32 */	"# INDIRU1",	/* mem: INDIRU1(addr) */
/* 33 */	"%0",	/* rc: con */
/* 34 */	"%0",	/* rc: reg */
/* 35 */	"%0",	/* mr: mem */
/* 36 */	"%0",	/* mr: reg */
/* 37 */	"%0",	/* mrc: mem */
/* 38 */	"%0",	/* mrc: rc */
/* 39 */	"# addr\n",	/* reg: addr */
/* 40 */	"# mrc\n",	/* reg: mrc */
/* 41 */	"# INDIRI1\n",	/* reg: INDIRI1(addr) */
/* 42 */	"# INDIRU1\n",	/* reg: INDIRU1(addr) */
/* 43 */	"# INDIRI2\n",	/* reg: INDIRI2(addr) */
/* 44 */	"# INDIRU2\n",	/* reg: INDIRU2(addr) */
/* 45 */	"# INDIRP2\n",	/* reg: INDIRP2(addr) */
/* 46 */	"# LOADI1\n",	/* reg: LOADI1(rc) */
/* 47 */	"# LOADU1\n",	/* reg: LOADU1(rc) */
/* 48 */	"# LOADI2\n",	/* reg: LOADI2(rc) */
/* 49 */	"# LOADU2\n",	/* reg: LOADU2(rc) */
/* 50 */	"# LOADP2\n",	/* reg: LOADP2(rc) */
/* 51 */	"# ADDI1\n",	/* reg: ADDI1(reg,mrc) */
/* 52 */	"# ADDU1\n",	/* reg: ADDU1(reg,mrc) */
/* 53 */	"# ADDI2\n",	/* reg: ADDI2(reg,rc) */
/* 54 */	"# ADDU2\n",	/* reg: ADDU2(reg,rc) */
/* 55 */	"# ADDP2\n",	/* reg: ADDP2(reg,rc) */
/* 56 */	"# SUBI1\n",	/* reg: SUBI1(reg,mrc) */
/* 57 */	"# SUBU1\n",	/* reg: SUBU1(reg,mrc) */
/* 58 */	"# SUBI2\n",	/* reg: SUBI2(reg,rc) */
/* 59 */	"# SUBU2\n",	/* reg: SUBU2(reg,rc) */
/* 60 */	"# SUBP2\n",	/* reg: SUBP2(reg,rc) */
/* 61 */	"# BANDI1\n",	/* reg: BANDI1(reg,mrc) */
/* 62 */	"# BANDU1\n",	/* reg: BANDU1(reg,mrc) */
/* 63 */	"# BANDI2\n",	/* reg: BANDI2(reg,rc) */
/* 64 */	"# BANDU2\n",	/* reg: BANDU2(reg,rc) */
/* 65 */	"# BORI1\n",	/* reg: BORI1(reg,mrc) */
/* 66 */	"# BORU1\n",	/* reg: BORU1(reg,mrc) */
/* 67 */	"# BORI2\n",	/* reg: BORI2(reg,rc) */
/* 68 */	"# BORU2\n",	/* reg: BORU2(reg,rc) */
/* 69 */	"# BXORI1\n",	/* reg: BXORI1(reg,mrc) */
/* 70 */	"# BXORU1\n",	/* reg: BXORU1(reg,mrc) */
/* 71 */	"# BXORI2\n",	/* reg: BXORI2(reg,rc) */
/* 72 */	"# BXORU2\n",	/* reg: BXORU2(reg,rc) */
/* 73 */	"# BCOMI1\n",	/* reg: BCOMI1(mr) */
/* 74 */	"# BCOMU1\n",	/* reg: BCOMU1(mr) */
/* 75 */	"# BCOMI2\n",	/* reg: BCOMI2(reg) */
/* 76 */	"# BCOMU2\n",	/* reg: BCOMU2(reg) */
/* 77 */	"# NEGI1\n",	/* reg: NEGI1(mr) */
/* 78 */	"# NEGI2\n",	/* reg: NEGI2(reg) */
/* 79 */	"%0",	/* rc8: con8 */
/* 80 */	"%0",	/* rc8: reg */
/* 81 */	"# LSHI1\n",	/* reg: LSHI1(reg,rc8) */
/* 82 */	"# LSHI2\n",	/* reg: LSHI2(reg,rc8) */
/* 83 */	"# LSHU1\n",	/* reg: LSHU1(reg,rc8) */
/* 84 */	"# LSHU2\n",	/* reg: LSHU2(reg,rc8) */
/* 85 */	"# RSHI1\n",	/* reg: RSHI1(reg,rc8) */
/* 86 */	"# RSHI2\n",	/* reg: RSHI2(reg,rc8) */
/* 87 */	"# RSHU1\n",	/* reg: RSHU1(reg,rc8) */
/* 88 */	"# RSHU2\n",	/* reg: RSHU2(reg,rc8) */
/* 89 */	"# MULI1\n",	/* reg: MULI1(reg,reg) */
/* 90 */	"# MULI2\n",	/* reg: MULI2(reg,reg) */
/* 91 */	"# MULU1\n",	/* reg: MULU1(reg,reg) */
/* 92 */	"# MULU2\n",	/* reg: MULU2(reg,reg) */
/* 93 */	"# DIVI1\n",	/* reg: DIVI1(reg,reg) */
/* 94 */	"# DIVI2\n",	/* reg: DIVI2(reg,reg) */
/* 95 */	"# DIVU1\n",	/* reg: DIVU1(reg,reg) */
/* 96 */	"# DIVU2\n",	/* reg: DIVU2(reg,reg) */
/* 97 */	"# MODI1\n",	/* reg: MODI1(reg,reg) */
/* 98 */	"# MODI2\n",	/* reg: MODI2(reg,reg) */
/* 99 */	"# MODU1\n",	/* reg: MODU1(reg,reg) */
/* 100 */	"# MODU2\n",	/* reg: MODU2(reg,reg) */
/* 101 */	"# ADDI1\n",	/* stmt: ASGNI1(addr,ADDI1(mem,rc)) */
/* 102 */	"# ADDU1\n",	/* stmt: ASGNU1(addr,ADDU1(mem,rc)) */
/* 103 */	"# SUBI1\n",	/* stmt: ASGNI1(addr,SUBI1(mem,rc)) */
/* 104 */	"# SUBU1\n",	/* stmt: ASGNU1(addr,SUBU1(mem,rc)) */
/* 105 */	"# BANDI1\n",	/* stmt: ASGNI1(addr,BANDI1(mem,rc)) */
/* 106 */	"# BANDU1\n",	/* stmt: ASGNU1(addr,BANDU1(mem,rc)) */
/* 107 */	"# BORI1\n",	/* stmt: ASGNI1(addr,BORI1(mem,rc)) */
/* 108 */	"# BORU1\n",	/* stmt: ASGNU1(addr,BORU1(mem,rc)) */
/* 109 */	"# BXORI1\n",	/* stmt: ASGNI1(addr,BXORI1(mem,rc)) */
/* 110 */	"# BXORU1\n",	/* stmt: ASGNU1(addr,BXORU1(mem,rc)) */
/* 111 */	"# BCOMI1\n",	/* stmt: ASGNI1(addr,BCOMI1(mem)) */
/* 112 */	"# BCOMU1\n",	/* stmt: ASGNU1(addr,BCOMU1(mem)) */
/* 113 */	"# NEGI1\n",	/* stmt: ASGNI1(addr,NEGI1(mem)) */
/* 114 */	"# LSHI1\n",	/* stmt: ASGNI1(addr,LSHI1(mem,con8)) */
/* 115 */	"# LSHU1\n",	/* stmt: ASGNU1(addr,LSHU1(mem,con8)) */
/* 116 */	"# RSHI1\n",	/* stmt: ASGNI1(addr,RSHI1(mem,con8)) */
/* 117 */	"# RSHU1\n",	/* stmt: ASGNU1(addr,RSHU1(mem,con8)) */
/* 118 */	"# CVII1\n",	/* reg: CVII1(reg) */
/* 119 */	"# CVIU1\n",	/* reg: CVIU1(reg) */
/* 120 */	"# CVUI1\n",	/* reg: CVUI1(reg) */
/* 121 */	"# CVUU1\n",	/* reg: CVUU1(reg) */
/* 122 */	"# CVII2\n",	/* reg: CVII2(reg) */
/* 123 */	"# CVIU2\n",	/* reg: CVIU2(reg) */
/* 124 */	"# CVUI2\n",	/* reg: CVUI2(reg) */
/* 125 */	"# CVUU2\n",	/* reg: CVUU2(reg) */
/* 126 */	"# CVUP2\n",	/* reg: CVUP2(reg) */
/* 127 */	"# CVPU2\n",	/* reg: CVPU2(reg) */
/* 128 */	"# ASGNI1\n",	/* stmt: ASGNI1(addr,rc) */
/* 129 */	"# ASGNU1\n",	/* stmt: ASGNU1(addr,rc) */
/* 130 */	"# ASGNI2\n",	/* stmt: ASGNI2(addr,rc) */
/* 131 */	"# ASGNU2\n",	/* stmt: ASGNU2(addr,rc) */
/* 132 */	"# ASGNP2\n",	/* stmt: ASGNP2(addr,rc) */
/* 133 */	"# ASGNI1\n",	/* stmt: ASGNI1(stk,rc) */
/* 134 */	"# ASGNU1\n",	/* stmt: ASGNU1(stk,rc) */
/* 135 */	"# ASGNI2\n",	/* stmt: ASGNI2(stk,rc) */
/* 136 */	"# ASGNU2\n",	/* stmt: ASGNU2(stk,rc) */
/* 137 */	"# ASGNP2\n",	/* stmt: ASGNP2(stk,rc) */
/* 138 */	"# ARGI1\n",	/* stmt: ARGI1(mrc) */
/* 139 */	"# ARGU1\n",	/* stmt: ARGU1(mrc) */
/* 140 */	"# ARGI2\n",	/* stmt: ARGI2(reg) */
/* 141 */	"# ARGU2\n",	/* stmt: ARGU2(reg) */
/* 142 */	"# ARGP2\n",	/* stmt: ARGP2(reg) */
/* 143 */	"# ASGNB\n",	/* stmt: ASGNB(reg,INDIRB(reg)) */
/* 144 */	"# ARGB\n",	/* stmt: ARGB(INDIRB(reg)) */
/* 145 */	"%a",	/* addrj: ADDRGP2 */
/* 146 */	"(%0)",	/* addrj: reg */
/* 147 */	"# JUMPV\n",	/* stmt: JUMPV(addrj) */
/* 148 */	"# LABELV\n",	/* stmt: LABELV */
/* 149 */	"# EQI1\n",	/* stmt: EQI1(reg,mrc) */
/* 150 */	"# EQU1\n",	/* stmt: EQU1(reg,mrc) */
/* 151 */	"# NEI1\n",	/* stmt: NEI1(reg,mrc) */
/* 152 */	"# NEU1\n",	/* stmt: NEU1(reg,mrc) */
/* 153 */	"# GEI1\n",	/* stmt: GEI1(reg,mrc) */
/* 154 */	"# GEU1\n",	/* stmt: GEU1(reg,mrc) */
/* 155 */	"# LTI1\n",	/* stmt: LTI1(reg,mrc) */
/* 156 */	"# LTU1\n",	/* stmt: LTU1(reg,mrc) */
/* 157 */	"# GTI1\n",	/* stmt: GTI1(reg,mrc) */
/* 158 */	"# GTU1\n",	/* stmt: GTU1(reg,mrc) */
/* 159 */	"# LEI1\n",	/* stmt: LEI1(reg,mrc) */
/* 160 */	"# LEU1\n",	/* stmt: LEU1(reg,mrc) */
/* 161 */	"# EQI1\n",	/* stmt: EQI1(mem,con) */
/* 162 */	"# EQU1\n",	/* stmt: EQU1(mem,con) */
/* 163 */	"# NEI1\n",	/* stmt: NEI1(mem,con) */
/* 164 */	"# NEU1\n",	/* stmt: NEU1(mem,con) */
/* 165 */	"# GEI1\n",	/* stmt: GEI1(mem,con) */
/* 166 */	"# GEU1\n",	/* stmt: GEU1(mem,con) */
/* 167 */	"# LTI1\n",	/* stmt: LTI1(mem,con) */
/* 168 */	"# LTU1\n",	/* stmt: LTU1(mem,con) */
/* 169 */	"# GTI1\n",	/* stmt: GTI1(mem,con) */
/* 170 */	"# GTU1\n",	/* stmt: GTU1(mem,con) */
/* 171 */	"# LEI1\n",	/* stmt: LEI1(mem,con) */
/* 172 */	"# LEU1\n",	/* stmt: LEU1(mem,con) */
/* 173 */	"# EQI2\n",	/* stmt: EQI2(reg,rc) */
/* 174 */	"# EQU2\n",	/* stmt: EQU2(reg,rc) */
/* 175 */	"# NEI2\n",	/* stmt: NEI2(reg,rc) */
/* 176 */	"# NEU2\n",	/* stmt: NEU2(reg,rc) */
/* 177 */	"# GEI2\n",	/* stmt: GEI2(reg,rc) */
/* 178 */	"# GEU2\n",	/* stmt: GEU2(reg,rc) */
/* 179 */	"# LTI2\n",	/* stmt: LTI2(reg,rc) */
/* 180 */	"# LTU2\n",	/* stmt: LTU2(reg,rc) */
/* 181 */	"# GTI2\n",	/* stmt: GTI2(reg,rc) */
/* 182 */	"# GTU2\n",	/* stmt: GTU2(reg,rc) */
/* 183 */	"# LEI2\n",	/* stmt: LEI2(reg,rc) */
/* 184 */	"# LEU2\n",	/* stmt: LEU2(reg,rc) */
/* 185 */	"# CALLI1\n",	/* reg: CALLI1(addrj) */
/* 186 */	"# CALLU1\n",	/* reg: CALLU1(addrj) */
/* 187 */	"# CALLI2\n",	/* reg: CALLI2(addrj) */
/* 188 */	"# CALLU2\n",	/* reg: CALLU2(addrj) */
/* 189 */	"# CALLP2\n",	/* reg: CALLP2(addrj) */
/* 190 */	"# CALLV\n",	/* stmt: CALLV(addrj) */
/* 191 */	"# RETI1\n",	/* stmt: RETI1(reg) */
/* 192 */	"# RETU1\n",	/* stmt: RETU1(reg) */
/* 193 */	"# RETI2\n",	/* stmt: RETI2(reg) */
/* 194 */	"# RETU2\n",	/* stmt: RETU2(reg) */
/* 195 */	"# RETP2\n",	/* stmt: RETP2(reg) */
/* 196 */	"# RETV\n",	/* stmt: RETV(reg) */
/* 197 */	"# INDIRI4\n",	/* reg: INDIRI4(VREGP) */
/* 198 */	"# INDIRU4\n",	/* reg: INDIRU4(VREGP) */
/* 199 */	"# INDIRF4\n",	/* reg: INDIRF4(VREGP) */
/* 200 */	"# ASGNI4\n",	/* stmt: ASGNI4(VREGP,reg) */
/* 201 */	"# ASGNU4\n",	/* stmt: ASGNU4(VREGP,reg) */
/* 202 */	"# ASGNF4\n",	/* stmt: ASGNF4(VREGP,reg) */
/* 203 */	"# INDIRI4\n",	/* reg: INDIRI4(addr) */
/* 204 */	"# INDIRU4\n",	/* reg: INDIRU4(addr) */
/* 205 */	"# INDIRF4\n",	/* reg: INDIRF4(addr) */
/* 206 */	"# INDIRI4",	/* memf: INDIRI4(ADDRGP2) */
/* 207 */	"# INDIRU4",	/* memf: INDIRU4(ADDRGP2) */
/* 208 */	"# INDIRF4",	/* memf: INDIRF4(ADDRGP2) */
/* 209 */	"# INDIRI4",	/* miaf: INDIRI4(addr) */
/* 210 */	"# INDIRU4",	/* miaf: INDIRU4(addr) */
/* 211 */	"# INDIRF4",	/* miaf: INDIRF4(addr) */
/* 212 */	"%0",	/* mrf: memf */
/* 213 */	"%0",	/* mrf: reg */
/* 214 */	"%0",	/* maf: memf */
/* 215 */	"%0",	/* maf: miaf */
/* 216 */	"# ASGNI4\n",	/* stmt: ASGNI4(addr,mrf) */
/* 217 */	"# ASGNU4\n",	/* stmt: ASGNU4(addr,mrf) */
/* 218 */	"# ASGNF4\n",	/* stmt: ASGNF4(addr,mrf) */
/* 219 */	"# ARGI4\n",	/* stmt: ARGI4(maf) */
/* 220 */	"# ARGU4\n",	/* stmt: ARGU4(maf) */
/* 221 */	"# ARGF4\n",	/* stmt: ARGF4(maf) */
/* 222 */	"# CVFF4\n",	/* reg: CVFF4(maf) */
/* 223 */	"# CVFI1\n",	/* reg: CVFI1(maf) */
/* 224 */	"# CVFI2\n",	/* reg: CVFI2(maf) */
/* 225 */	"# CVFI4\n",	/* reg: CVFI4(maf) */
/* 226 */	"# CVIF4\n",	/* reg: CVIF4(reg) */
/* 227 */	"# CVII4\n",	/* reg: CVII4(reg) */
/* 228 */	"# CVIU4\n",	/* reg: CVIU4(reg) */
/* 229 */	"# CVUI4\n",	/* reg: CVUI4(reg) */
/* 230 */	"# CVUU4\n",	/* reg: CVUU4(reg) */
/* 231 */	"# CVPU4\n",	/* reg: CVPU4(reg) */
/* 232 */	"# NEGI4\n",	/* reg: NEGI4(maf) */
/* 233 */	"# NEGF4\n",	/* reg: NEGF4(maf) */
/* 234 */	"# BCOMI4\n",	/* reg: BCOMI4(maf) */
/* 235 */	"# BCOMU4\n",	/* reg: BCOMU4(maf) */
/* 236 */	"# LSHI4\n",	/* reg: LSHI4(reg,rc8) */
/* 237 */	"# LSHU4\n",	/* reg: LSHU4(reg,rc8) */
/* 238 */	"# RSHI4\n",	/* reg: RSHI4(reg,rc8) */
/* 239 */	"# RSHU4\n",	/* reg: RSHU4(reg,rc8) */
/* 240 */	"# MODI4\n",	/* reg: MODI4(maf,maf) */
/* 241 */	"# MODU4\n",	/* reg: MODU4(maf,maf) */
/* 242 */	"# BANDI4\n",	/* reg: BANDI4(maf,maf) */
/* 243 */	"# BANDU4\n",	/* reg: BANDU4(maf,maf) */
/* 244 */	"# BORI4\n",	/* reg: BORI4(maf,maf) */
/* 245 */	"# BORU4\n",	/* reg: BORU4(maf,maf) */
/* 246 */	"# BXORI4\n",	/* reg: BXORI4(maf,maf) */
/* 247 */	"# BXORU4\n",	/* reg: BXORU4(maf,maf) */
/* 248 */	"# ADDI4\n",	/* reg: ADDI4(maf,maf) */
/* 249 */	"# ADDU4\n",	/* reg: ADDU4(maf,maf) */
/* 250 */	"# ADDF4\n",	/* reg: ADDF4(maf,maf) */
/* 251 */	"# SUBI4\n",	/* reg: SUBI4(maf,maf) */
/* 252 */	"# SUBU4\n",	/* reg: SUBU4(maf,maf) */
/* 253 */	"# SUBF4\n",	/* reg: SUBF4(maf,maf) */
/* 254 */	"# MULI4\n",	/* reg: MULI4(maf,maf) */
/* 255 */	"# MULU4\n",	/* reg: MULU4(maf,maf) */
/* 256 */	"# MULF4\n",	/* reg: MULF4(maf,maf) */
/* 257 */	"# DIVI4\n",	/* reg: DIVI4(maf,maf) */
/* 258 */	"# DIVU4\n",	/* reg: DIVU4(maf,maf) */
/* 259 */	"# DIVF4\n",	/* reg: DIVF4(maf,maf) */
/* 260 */	"# NEGI4\n",	/* stmt: ASGNI4(addr,NEGI4(maf)) */
/* 261 */	"# NEGF4\n",	/* stmt: ASGNF4(addr,NEGF4(maf)) */
/* 262 */	"# BCOMI4\n",	/* stmt: ASGNI4(addr,BCOMI4(maf)) */
/* 263 */	"# BCOMU4\n",	/* stmt: ASGNF4(addr,BCOMU4(maf)) */
/* 264 */	"# ADDI4\n",	/* stmt: ASGNI4(addr,ADDI4(maf,maf)) */
/* 265 */	"# ADDU4\n",	/* stmt: ASGNU4(addr,ADDU4(maf,maf)) */
/* 266 */	"# ADDF4\n",	/* stmt: ASGNF4(addr,ADDF4(maf,maf)) */
/* 267 */	"# SUBI4\n",	/* stmt: ASGNI4(addr,SUBI4(maf,maf)) */
/* 268 */	"# SUBU4\n",	/* stmt: ASGNU4(addr,SUBU4(maf,maf)) */
/* 269 */	"# SUBF4\n",	/* stmt: ASGNF4(addr,SUBF4(maf,maf)) */
/* 270 */	"# MULI4\n",	/* stmt: ASGNI4(addr,MULI4(maf,maf)) */
/* 271 */	"# MULU4\n",	/* stmt: ASGNU4(addr,MULU4(maf,maf)) */
/* 272 */	"# MULF4\n",	/* stmt: ASGNF4(addr,MULF4(maf,maf)) */
/* 273 */	"# DIVI4\n",	/* stmt: ASGNI4(addr,DIVI4(maf,maf)) */
/* 274 */	"# DIVU4\n",	/* stmt: ASGNU4(addr,DIVU4(maf,maf)) */
/* 275 */	"# DIVF4\n",	/* stmt: ASGNF4(addr,DIVF4(maf,maf)) */
/* 276 */	"# MODI4\n",	/* stmt: ASGNI4(addr,MODI4(maf,maf)) */
/* 277 */	"# MODU4\n",	/* stmt: ASGNU4(addr,MODU4(maf,maf)) */
/* 278 */	"# BANDI4\n",	/* stmt: ASGNI4(addr,BANDI4(maf,maf)) */
/* 279 */	"# BANDU4\n",	/* stmt: ASGNU4(addr,BANDU4(maf,maf)) */
/* 280 */	"# BORI4\n",	/* stmt: ASGNI4(addr,BORI4(maf,maf)) */
/* 281 */	"# BORU4\n",	/* stmt: ASGNU4(addr,BORU4(maf,maf)) */
/* 282 */	"# BXORI4\n",	/* stmt: ASGNI4(addr,BXORI4(maf,maf)) */
/* 283 */	"# BXORU4\n",	/* stmt: ASGNU4(addr,BXORU4(maf,maf)) */
/* 284 */	"# EQI4\n",	/* stmt: EQI4(maf,maf) */
/* 285 */	"# EQU4\n",	/* stmt: EQU4(maf,maf) */
/* 286 */	"# EQF4\n",	/* stmt: EQF4(maf,maf) */
/* 287 */	"# NEI4\n",	/* stmt: NEI4(maf,maf) */
/* 288 */	"# NEU4\n",	/* stmt: NEU4(maf,maf) */
/* 289 */	"# NEF4\n",	/* stmt: NEF4(maf,maf) */
/* 290 */	"# GEI4\n",	/* stmt: GEI4(maf,maf) */
/* 291 */	"# GEU4\n",	/* stmt: GEU4(maf,maf) */
/* 292 */	"# GEF4\n",	/* stmt: GEF4(maf,maf) */
/* 293 */	"# GTI4\n",	/* stmt: GTI4(maf,maf) */
/* 294 */	"# GTU4\n",	/* stmt: GTU4(maf,maf) */
/* 295 */	"# GTF4\n",	/* stmt: GTF4(maf,maf) */
/* 296 */	"# LEI4\n",	/* stmt: LEI4(maf,maf) */
/* 297 */	"# LEU4\n",	/* stmt: LEU4(maf,maf) */
/* 298 */	"# LEF4\n",	/* stmt: LEF4(maf,maf) */
/* 299 */	"# LTI4\n",	/* stmt: LTI4(maf,maf) */
/* 300 */	"# LTU4\n",	/* stmt: LTU4(maf,maf) */
/* 301 */	"# LTF4\n",	/* stmt: LTF4(maf,maf) */
/* 302 */	"# CALLI4\n",	/* reg: CALLI4(addrj) */
/* 303 */	"# CALLU4\n",	/* reg: CALLU4(addrj) */
/* 304 */	"# CALLF4\n",	/* reg: CALLF4(addrj) */
/* 305 */	"# RETI4\n",	/* stmt: RETI4(reg) */
/* 306 */	"# RETU4\n",	/* stmt: RETU4(reg) */
/* 307 */	"# RETF4\n",	/* stmt: RETF4(reg) */
};

static char _isinstruction[] = {
/* 0 */	0,
/* 1 */	1,	/* # INDIRI1\n */
/* 2 */	1,	/* # INDIRU1\n */
/* 3 */	1,	/* # INDIRI2\n */
/* 4 */	1,	/* # INDIRU2\n */
/* 5 */	1,	/* # INDIRP2\n */
/* 6 */	1,	/* # ASGNI1\n */
/* 7 */	1,	/* # ASGNU1\n */
/* 8 */	1,	/* # ASGNI2\n */
/* 9 */	1,	/* # ASGNU2\n */
/* 10 */	1,	/* # ASGNP2\n */
/* 11 */	0,	/* %#%a */
/* 12 */	0,	/* %#%a */
/* 13 */	0,	/* %#%a */
/* 14 */	0,	/* %#%a */
/* 15 */	0,	/* %#%a */
/* 16 */	0,	/* %#%a */
/* 17 */	0,	/* %#%a */
/* 18 */	0,	/* %#%a */
/* 19 */	0,	/* %#%a */
/* 20 */	0,	/* %#%a */
/* 21 */	0,	/*  */
/* 22 */	1,	/* # ADDRGP2\n */
/* 23 */	1,	/* # ADDRFP2\n */
/* 24 */	1,	/* # ADDRLP2\n */
/* 25 */	0,	/* %a+%F(SP) */
/* 26 */	0,	/* %a+%F(SP) */
/* 27 */	0,	/* %0 */
/* 28 */	0,	/* %0 */
/* 29 */	0,	/* %0 */
/* 30 */	0,	/* %0 */
/* 31 */	0,	/* # INDIRI1 */
/* 32 */	0,	/* # INDIRU1 */
/* 33 */	0,	/* %0 */
/* 34 */	0,	/* %0 */
/* 35 */	0,	/* %0 */
/* 36 */	0,	/* %0 */
/* 37 */	0,	/* %0 */
/* 38 */	0,	/* %0 */
/* 39 */	1,	/* # addr\n */
/* 40 */	1,	/* # mrc\n */
/* 41 */	1,	/* # INDIRI1\n */
/* 42 */	1,	/* # INDIRU1\n */
/* 43 */	1,	/* # INDIRI2\n */
/* 44 */	1,	/* # INDIRU2\n */
/* 45 */	1,	/* # INDIRP2\n */
/* 46 */	1,	/* # LOADI1\n */
/* 47 */	1,	/* # LOADU1\n */
/* 48 */	1,	/* # LOADI2\n */
/* 49 */	1,	/* # LOADU2\n */
/* 50 */	1,	/* # LOADP2\n */
/* 51 */	1,	/* # ADDI1\n */
/* 52 */	1,	/* # ADDU1\n */
/* 53 */	1,	/* # ADDI2\n */
/* 54 */	1,	/* # ADDU2\n */
/* 55 */	1,	/* # ADDP2\n */
/* 56 */	1,	/* # SUBI1\n */
/* 57 */	1,	/* # SUBU1\n */
/* 58 */	1,	/* # SUBI2\n */
/* 59 */	1,	/* # SUBU2\n */
/* 60 */	1,	/* # SUBP2\n */
/* 61 */	1,	/* # BANDI1\n */
/* 62 */	1,	/* # BANDU1\n */
/* 63 */	1,	/* # BANDI2\n */
/* 64 */	1,	/* # BANDU2\n */
/* 65 */	1,	/* # BORI1\n */
/* 66 */	1,	/* # BORU1\n */
/* 67 */	1,	/* # BORI2\n */
/* 68 */	1,	/* # BORU2\n */
/* 69 */	1,	/* # BXORI1\n */
/* 70 */	1,	/* # BXORU1\n */
/* 71 */	1,	/* # BXORI2\n */
/* 72 */	1,	/* # BXORU2\n */
/* 73 */	1,	/* # BCOMI1\n */
/* 74 */	1,	/* # BCOMU1\n */
/* 75 */	1,	/* # BCOMI2\n */
/* 76 */	1,	/* # BCOMU2\n */
/* 77 */	1,	/* # NEGI1\n */
/* 78 */	1,	/* # NEGI2\n */
/* 79 */	0,	/* %0 */
/* 80 */	0,	/* %0 */
/* 81 */	1,	/* # LSHI1\n */
/* 82 */	1,	/* # LSHI2\n */
/* 83 */	1,	/* # LSHU1\n */
/* 84 */	1,	/* # LSHU2\n */
/* 85 */	1,	/* # RSHI1\n */
/* 86 */	1,	/* # RSHI2\n */
/* 87 */	1,	/* # RSHU1\n */
/* 88 */	1,	/* # RSHU2\n */
/* 89 */	1,	/* # MULI1\n */
/* 90 */	1,	/* # MULI2\n */
/* 91 */	1,	/* # MULU1\n */
/* 92 */	1,	/* # MULU2\n */
/* 93 */	1,	/* # DIVI1\n */
/* 94 */	1,	/* # DIVI2\n */
/* 95 */	1,	/* # DIVU1\n */
/* 96 */	1,	/* # DIVU2\n */
/* 97 */	1,	/* # MODI1\n */
/* 98 */	1,	/* # MODI2\n */
/* 99 */	1,	/* # MODU1\n */
/* 100 */	1,	/* # MODU2\n */
/* 101 */	1,	/* # ADDI1\n */
/* 102 */	1,	/* # ADDU1\n */
/* 103 */	1,	/* # SUBI1\n */
/* 104 */	1,	/* # SUBU1\n */
/* 105 */	1,	/* # BANDI1\n */
/* 106 */	1,	/* # BANDU1\n */
/* 107 */	1,	/* # BORI1\n */
/* 108 */	1,	/* # BORU1\n */
/* 109 */	1,	/* # BXORI1\n */
/* 110 */	1,	/* # BXORU1\n */
/* 111 */	1,	/* # BCOMI1\n */
/* 112 */	1,	/* # BCOMU1\n */
/* 113 */	1,	/* # NEGI1\n */
/* 114 */	1,	/* # LSHI1\n */
/* 115 */	1,	/* # LSHU1\n */
/* 116 */	1,	/* # RSHI1\n */
/* 117 */	1,	/* # RSHU1\n */
/* 118 */	1,	/* # CVII1\n */
/* 119 */	1,	/* # CVIU1\n */
/* 120 */	1,	/* # CVUI1\n */
/* 121 */	1,	/* # CVUU1\n */
/* 122 */	1,	/* # CVII2\n */
/* 123 */	1,	/* # CVIU2\n */
/* 124 */	1,	/* # CVUI2\n */
/* 125 */	1,	/* # CVUU2\n */
/* 126 */	1,	/* # CVUP2\n */
/* 127 */	1,	/* # CVPU2\n */
/* 128 */	1,	/* # ASGNI1\n */
/* 129 */	1,	/* # ASGNU1\n */
/* 130 */	1,	/* # ASGNI2\n */
/* 131 */	1,	/* # ASGNU2\n */
/* 132 */	1,	/* # ASGNP2\n */
/* 133 */	1,	/* # ASGNI1\n */
/* 134 */	1,	/* # ASGNU1\n */
/* 135 */	1,	/* # ASGNI2\n */
/* 136 */	1,	/* # ASGNU2\n */
/* 137 */	1,	/* # ASGNP2\n */
/* 138 */	1,	/* # ARGI1\n */
/* 139 */	1,	/* # ARGU1\n */
/* 140 */	1,	/* # ARGI2\n */
/* 141 */	1,	/* # ARGU2\n */
/* 142 */	1,	/* # ARGP2\n */
/* 143 */	1,	/* # ASGNB\n */
/* 144 */	1,	/* # ARGB\n */
/* 145 */	0,	/* %a */
/* 146 */	0,	/* (%0) */
/* 147 */	1,	/* # JUMPV\n */
/* 148 */	1,	/* # LABELV\n */
/* 149 */	1,	/* # EQI1\n */
/* 150 */	1,	/* # EQU1\n */
/* 151 */	1,	/* # NEI1\n */
/* 152 */	1,	/* # NEU1\n */
/* 153 */	1,	/* # GEI1\n */
/* 154 */	1,	/* # GEU1\n */
/* 155 */	1,	/* # LTI1\n */
/* 156 */	1,	/* # LTU1\n */
/* 157 */	1,	/* # GTI1\n */
/* 158 */	1,	/* # GTU1\n */
/* 159 */	1,	/* # LEI1\n */
/* 160 */	1,	/* # LEU1\n */
/* 161 */	1,	/* # EQI1\n */
/* 162 */	1,	/* # EQU1\n */
/* 163 */	1,	/* # NEI1\n */
/* 164 */	1,	/* # NEU1\n */
/* 165 */	1,	/* # GEI1\n */
/* 166 */	1,	/* # GEU1\n */
/* 167 */	1,	/* # LTI1\n */
/* 168 */	1,	/* # LTU1\n */
/* 169 */	1,	/* # GTI1\n */
/* 170 */	1,	/* # GTU1\n */
/* 171 */	1,	/* # LEI1\n */
/* 172 */	1,	/* # LEU1\n */
/* 173 */	1,	/* # EQI2\n */
/* 174 */	1,	/* # EQU2\n */
/* 175 */	1,	/* # NEI2\n */
/* 176 */	1,	/* # NEU2\n */
/* 177 */	1,	/* # GEI2\n */
/* 178 */	1,	/* # GEU2\n */
/* 179 */	1,	/* # LTI2\n */
/* 180 */	1,	/* # LTU2\n */
/* 181 */	1,	/* # GTI2\n */
/* 182 */	1,	/* # GTU2\n */
/* 183 */	1,	/* # LEI2\n */
/* 184 */	1,	/* # LEU2\n */
/* 185 */	1,	/* # CALLI1\n */
/* 186 */	1,	/* # CALLU1\n */
/* 187 */	1,	/* # CALLI2\n */
/* 188 */	1,	/* # CALLU2\n */
/* 189 */	1,	/* # CALLP2\n */
/* 190 */	1,	/* # CALLV\n */
/* 191 */	1,	/* # RETI1\n */
/* 192 */	1,	/* # RETU1\n */
/* 193 */	1,	/* # RETI2\n */
/* 194 */	1,	/* # RETU2\n */
/* 195 */	1,	/* # RETP2\n */
/* 196 */	1,	/* # RETV\n */
/* 197 */	1,	/* # INDIRI4\n */
/* 198 */	1,	/* # INDIRU4\n */
/* 199 */	1,	/* # INDIRF4\n */
/* 200 */	1,	/* # ASGNI4\n */
/* 201 */	1,	/* # ASGNU4\n */
/* 202 */	1,	/* # ASGNF4\n */
/* 203 */	1,	/* # INDIRI4\n */
/* 204 */	1,	/* # INDIRU4\n */
/* 205 */	1,	/* # INDIRF4\n */
/* 206 */	0,	/* # INDIRI4 */
/* 207 */	0,	/* # INDIRU4 */
/* 208 */	0,	/* # INDIRF4 */
/* 209 */	0,	/* # INDIRI4 */
/* 210 */	0,	/* # INDIRU4 */
/* 211 */	0,	/* # INDIRF4 */
/* 212 */	0,	/* %0 */
/* 213 */	0,	/* %0 */
/* 214 */	0,	/* %0 */
/* 215 */	0,	/* %0 */
/* 216 */	1,	/* # ASGNI4\n */
/* 217 */	1,	/* # ASGNU4\n */
/* 218 */	1,	/* # ASGNF4\n */
/* 219 */	1,	/* # ARGI4\n */
/* 220 */	1,	/* # ARGU4\n */
/* 221 */	1,	/* # ARGF4\n */
/* 222 */	1,	/* # CVFF4\n */
/* 223 */	1,	/* # CVFI1\n */
/* 224 */	1,	/* # CVFI2\n */
/* 225 */	1,	/* # CVFI4\n */
/* 226 */	1,	/* # CVIF4\n */
/* 227 */	1,	/* # CVII4\n */
/* 228 */	1,	/* # CVIU4\n */
/* 229 */	1,	/* # CVUI4\n */
/* 230 */	1,	/* # CVUU4\n */
/* 231 */	1,	/* # CVPU4\n */
/* 232 */	1,	/* # NEGI4\n */
/* 233 */	1,	/* # NEGF4\n */
/* 234 */	1,	/* # BCOMI4\n */
/* 235 */	1,	/* # BCOMU4\n */
/* 236 */	1,	/* # LSHI4\n */
/* 237 */	1,	/* # LSHU4\n */
/* 238 */	1,	/* # RSHI4\n */
/* 239 */	1,	/* # RSHU4\n */
/* 240 */	1,	/* # MODI4\n */
/* 241 */	1,	/* # MODU4\n */
/* 242 */	1,	/* # BANDI4\n */
/* 243 */	1,	/* # BANDU4\n */
/* 244 */	1,	/* # BORI4\n */
/* 245 */	1,	/* # BORU4\n */
/* 246 */	1,	/* # BXORI4\n */
/* 247 */	1,	/* # BXORU4\n */
/* 248 */	1,	/* # ADDI4\n */
/* 249 */	1,	/* # ADDU4\n */
/* 250 */	1,	/* # ADDF4\n */
/* 251 */	1,	/* # SUBI4\n */
/* 252 */	1,	/* # SUBU4\n */
/* 253 */	1,	/* # SUBF4\n */
/* 254 */	1,	/* # MULI4\n */
/* 255 */	1,	/* # MULU4\n */
/* 256 */	1,	/* # MULF4\n */
/* 257 */	1,	/* # DIVI4\n */
/* 258 */	1,	/* # DIVU4\n */
/* 259 */	1,	/* # DIVF4\n */
/* 260 */	1,	/* # NEGI4\n */
/* 261 */	1,	/* # NEGF4\n */
/* 262 */	1,	/* # BCOMI4\n */
/* 263 */	1,	/* # BCOMU4\n */
/* 264 */	1,	/* # ADDI4\n */
/* 265 */	1,	/* # ADDU4\n */
/* 266 */	1,	/* # ADDF4\n */
/* 267 */	1,	/* # SUBI4\n */
/* 268 */	1,	/* # SUBU4\n */
/* 269 */	1,	/* # SUBF4\n */
/* 270 */	1,	/* # MULI4\n */
/* 271 */	1,	/* # MULU4\n */
/* 272 */	1,	/* # MULF4\n */
/* 273 */	1,	/* # DIVI4\n */
/* 274 */	1,	/* # DIVU4\n */
/* 275 */	1,	/* # DIVF4\n */
/* 276 */	1,	/* # MODI4\n */
/* 277 */	1,	/* # MODU4\n */
/* 278 */	1,	/* # BANDI4\n */
/* 279 */	1,	/* # BANDU4\n */
/* 280 */	1,	/* # BORI4\n */
/* 281 */	1,	/* # BORU4\n */
/* 282 */	1,	/* # BXORI4\n */
/* 283 */	1,	/* # BXORU4\n */
/* 284 */	1,	/* # EQI4\n */
/* 285 */	1,	/* # EQU4\n */
/* 286 */	1,	/* # EQF4\n */
/* 287 */	1,	/* # NEI4\n */
/* 288 */	1,	/* # NEU4\n */
/* 289 */	1,	/* # NEF4\n */
/* 290 */	1,	/* # GEI4\n */
/* 291 */	1,	/* # GEU4\n */
/* 292 */	1,	/* # GEF4\n */
/* 293 */	1,	/* # GTI4\n */
/* 294 */	1,	/* # GTU4\n */
/* 295 */	1,	/* # GTF4\n */
/* 296 */	1,	/* # LEI4\n */
/* 297 */	1,	/* # LEU4\n */
/* 298 */	1,	/* # LEF4\n */
/* 299 */	1,	/* # LTI4\n */
/* 300 */	1,	/* # LTU4\n */
/* 301 */	1,	/* # LTF4\n */
/* 302 */	1,	/* # CALLI4\n */
/* 303 */	1,	/* # CALLU4\n */
/* 304 */	1,	/* # CALLF4\n */
/* 305 */	1,	/* # RETI4\n */
/* 306 */	1,	/* # RETU4\n */
/* 307 */	1,	/* # RETF4\n */
};

static char *_string[] = {
/* 0 */	0,
/* 1 */	"reg: INDIRI1(VREGP)",
/* 2 */	"reg: INDIRU1(VREGP)",
/* 3 */	"reg: INDIRI2(VREGP)",
/* 4 */	"reg: INDIRU2(VREGP)",
/* 5 */	"reg: INDIRP2(VREGP)",
/* 6 */	"stmt: ASGNI1(VREGP,reg)",
/* 7 */	"stmt: ASGNU1(VREGP,reg)",
/* 8 */	"stmt: ASGNI2(VREGP,reg)",
/* 9 */	"stmt: ASGNU2(VREGP,reg)",
/* 10 */	"stmt: ASGNP2(VREGP,reg)",
/* 11 */	"con: CNSTI1",
/* 12 */	"con: CNSTU1",
/* 13 */	"con: CNSTI2",
/* 14 */	"con: CNSTU2",
/* 15 */	"con: CNSTP2",
/* 16 */	"con: ADDRGP2",
/* 17 */	"con8: CNSTI1",
/* 18 */	"con8: CNSTU1",
/* 19 */	"con8: CNSTI2",
/* 20 */	"con8: CNSTU2",
/* 21 */	"stmt: reg",
/* 22 */	"reg: ADDRGP2",
/* 23 */	"reg: ADDRFP2",
/* 24 */	"reg: ADDRLP2",
/* 25 */	"stk: ADDRFP2",
/* 26 */	"stk: ADDRLP2",
/* 27 */	"base: con",
/* 28 */	"base: reg",
/* 29 */	"addr: base",
/* 30 */	"addr: stk",
/* 31 */	"mem: INDIRI1(addr)",
/* 32 */	"mem: INDIRU1(addr)",
/* 33 */	"rc: con",
/* 34 */	"rc: reg",
/* 35 */	"mr: mem",
/* 36 */	"mr: reg",
/* 37 */	"mrc: mem",
/* 38 */	"mrc: rc",
/* 39 */	"reg: addr",
/* 40 */	"reg: mrc",
/* 41 */	"reg: INDIRI1(addr)",
/* 42 */	"reg: INDIRU1(addr)",
/* 43 */	"reg: INDIRI2(addr)",
/* 44 */	"reg: INDIRU2(addr)",
/* 45 */	"reg: INDIRP2(addr)",
/* 46 */	"reg: LOADI1(rc)",
/* 47 */	"reg: LOADU1(rc)",
/* 48 */	"reg: LOADI2(rc)",
/* 49 */	"reg: LOADU2(rc)",
/* 50 */	"reg: LOADP2(rc)",
/* 51 */	"reg: ADDI1(reg,mrc)",
/* 52 */	"reg: ADDU1(reg,mrc)",
/* 53 */	"reg: ADDI2(reg,rc)",
/* 54 */	"reg: ADDU2(reg,rc)",
/* 55 */	"reg: ADDP2(reg,rc)",
/* 56 */	"reg: SUBI1(reg,mrc)",
/* 57 */	"reg: SUBU1(reg,mrc)",
/* 58 */	"reg: SUBI2(reg,rc)",
/* 59 */	"reg: SUBU2(reg,rc)",
/* 60 */	"reg: SUBP2(reg,rc)",
/* 61 */	"reg: BANDI1(reg,mrc)",
/* 62 */	"reg: BANDU1(reg,mrc)",
/* 63 */	"reg: BANDI2(reg,rc)",
/* 64 */	"reg: BANDU2(reg,rc)",
/* 65 */	"reg: BORI1(reg,mrc)",
/* 66 */	"reg: BORU1(reg,mrc)",
/* 67 */	"reg: BORI2(reg,rc)",
/* 68 */	"reg: BORU2(reg,rc)",
/* 69 */	"reg: BXORI1(reg,mrc)",
/* 70 */	"reg: BXORU1(reg,mrc)",
/* 71 */	"reg: BXORI2(reg,rc)",
/* 72 */	"reg: BXORU2(reg,rc)",
/* 73 */	"reg: BCOMI1(mr)",
/* 74 */	"reg: BCOMU1(mr)",
/* 75 */	"reg: BCOMI2(reg)",
/* 76 */	"reg: BCOMU2(reg)",
/* 77 */	"reg: NEGI1(mr)",
/* 78 */	"reg: NEGI2(reg)",
/* 79 */	"rc8: con8",
/* 80 */	"rc8: reg",
/* 81 */	"reg: LSHI1(reg,rc8)",
/* 82 */	"reg: LSHI2(reg,rc8)",
/* 83 */	"reg: LSHU1(reg,rc8)",
/* 84 */	"reg: LSHU2(reg,rc8)",
/* 85 */	"reg: RSHI1(reg,rc8)",
/* 86 */	"reg: RSHI2(reg,rc8)",
/* 87 */	"reg: RSHU1(reg,rc8)",
/* 88 */	"reg: RSHU2(reg,rc8)",
/* 89 */	"reg: MULI1(reg,reg)",
/* 90 */	"reg: MULI2(reg,reg)",
/* 91 */	"reg: MULU1(reg,reg)",
/* 92 */	"reg: MULU2(reg,reg)",
/* 93 */	"reg: DIVI1(reg,reg)",
/* 94 */	"reg: DIVI2(reg,reg)",
/* 95 */	"reg: DIVU1(reg,reg)",
/* 96 */	"reg: DIVU2(reg,reg)",
/* 97 */	"reg: MODI1(reg,reg)",
/* 98 */	"reg: MODI2(reg,reg)",
/* 99 */	"reg: MODU1(reg,reg)",
/* 100 */	"reg: MODU2(reg,reg)",
/* 101 */	"stmt: ASGNI1(addr,ADDI1(mem,rc))",
/* 102 */	"stmt: ASGNU1(addr,ADDU1(mem,rc))",
/* 103 */	"stmt: ASGNI1(addr,SUBI1(mem,rc))",
/* 104 */	"stmt: ASGNU1(addr,SUBU1(mem,rc))",
/* 105 */	"stmt: ASGNI1(addr,BANDI1(mem,rc))",
/* 106 */	"stmt: ASGNU1(addr,BANDU1(mem,rc))",
/* 107 */	"stmt: ASGNI1(addr,BORI1(mem,rc))",
/* 108 */	"stmt: ASGNU1(addr,BORU1(mem,rc))",
/* 109 */	"stmt: ASGNI1(addr,BXORI1(mem,rc))",
/* 110 */	"stmt: ASGNU1(addr,BXORU1(mem,rc))",
/* 111 */	"stmt: ASGNI1(addr,BCOMI1(mem))",
/* 112 */	"stmt: ASGNU1(addr,BCOMU1(mem))",
/* 113 */	"stmt: ASGNI1(addr,NEGI1(mem))",
/* 114 */	"stmt: ASGNI1(addr,LSHI1(mem,con8))",
/* 115 */	"stmt: ASGNU1(addr,LSHU1(mem,con8))",
/* 116 */	"stmt: ASGNI1(addr,RSHI1(mem,con8))",
/* 117 */	"stmt: ASGNU1(addr,RSHU1(mem,con8))",
/* 118 */	"reg: CVII1(reg)",
/* 119 */	"reg: CVIU1(reg)",
/* 120 */	"reg: CVUI1(reg)",
/* 121 */	"reg: CVUU1(reg)",
/* 122 */	"reg: CVII2(reg)",
/* 123 */	"reg: CVIU2(reg)",
/* 124 */	"reg: CVUI2(reg)",
/* 125 */	"reg: CVUU2(reg)",
/* 126 */	"reg: CVUP2(reg)",
/* 127 */	"reg: CVPU2(reg)",
/* 128 */	"stmt: ASGNI1(addr,rc)",
/* 129 */	"stmt: ASGNU1(addr,rc)",
/* 130 */	"stmt: ASGNI2(addr,rc)",
/* 131 */	"stmt: ASGNU2(addr,rc)",
/* 132 */	"stmt: ASGNP2(addr,rc)",
/* 133 */	"stmt: ASGNI1(stk,rc)",
/* 134 */	"stmt: ASGNU1(stk,rc)",
/* 135 */	"stmt: ASGNI2(stk,rc)",
/* 136 */	"stmt: ASGNU2(stk,rc)",
/* 137 */	"stmt: ASGNP2(stk,rc)",
/* 138 */	"stmt: ARGI1(mrc)",
/* 139 */	"stmt: ARGU1(mrc)",
/* 140 */	"stmt: ARGI2(reg)",
/* 141 */	"stmt: ARGU2(reg)",
/* 142 */	"stmt: ARGP2(reg)",
/* 143 */	"stmt: ASGNB(reg,INDIRB(reg))",
/* 144 */	"stmt: ARGB(INDIRB(reg))",
/* 145 */	"addrj: ADDRGP2",
/* 146 */	"addrj: reg",
/* 147 */	"stmt: JUMPV(addrj)",
/* 148 */	"stmt: LABELV",
/* 149 */	"stmt: EQI1(reg,mrc)",
/* 150 */	"stmt: EQU1(reg,mrc)",
/* 151 */	"stmt: NEI1(reg,mrc)",
/* 152 */	"stmt: NEU1(reg,mrc)",
/* 153 */	"stmt: GEI1(reg,mrc)",
/* 154 */	"stmt: GEU1(reg,mrc)",
/* 155 */	"stmt: LTI1(reg,mrc)",
/* 156 */	"stmt: LTU1(reg,mrc)",
/* 157 */	"stmt: GTI1(reg,mrc)",
/* 158 */	"stmt: GTU1(reg,mrc)",
/* 159 */	"stmt: LEI1(reg,mrc)",
/* 160 */	"stmt: LEU1(reg,mrc)",
/* 161 */	"stmt: EQI1(mem,con)",
/* 162 */	"stmt: EQU1(mem,con)",
/* 163 */	"stmt: NEI1(mem,con)",
/* 164 */	"stmt: NEU1(mem,con)",
/* 165 */	"stmt: GEI1(mem,con)",
/* 166 */	"stmt: GEU1(mem,con)",
/* 167 */	"stmt: LTI1(mem,con)",
/* 168 */	"stmt: LTU1(mem,con)",
/* 169 */	"stmt: GTI1(mem,con)",
/* 170 */	"stmt: GTU1(mem,con)",
/* 171 */	"stmt: LEI1(mem,con)",
/* 172 */	"stmt: LEU1(mem,con)",
/* 173 */	"stmt: EQI2(reg,rc)",
/* 174 */	"stmt: EQU2(reg,rc)",
/* 175 */	"stmt: NEI2(reg,rc)",
/* 176 */	"stmt: NEU2(reg,rc)",
/* 177 */	"stmt: GEI2(reg,rc)",
/* 178 */	"stmt: GEU2(reg,rc)",
/* 179 */	"stmt: LTI2(reg,rc)",
/* 180 */	"stmt: LTU2(reg,rc)",
/* 181 */	"stmt: GTI2(reg,rc)",
/* 182 */	"stmt: GTU2(reg,rc)",
/* 183 */	"stmt: LEI2(reg,rc)",
/* 184 */	"stmt: LEU2(reg,rc)",
/* 185 */	"reg: CALLI1(addrj)",
/* 186 */	"reg: CALLU1(addrj)",
/* 187 */	"reg: CALLI2(addrj)",
/* 188 */	"reg: CALLU2(addrj)",
/* 189 */	"reg: CALLP2(addrj)",
/* 190 */	"stmt: CALLV(addrj)",
/* 191 */	"stmt: RETI1(reg)",
/* 192 */	"stmt: RETU1(reg)",
/* 193 */	"stmt: RETI2(reg)",
/* 194 */	"stmt: RETU2(reg)",
/* 195 */	"stmt: RETP2(reg)",
/* 196 */	"stmt: RETV(reg)",
/* 197 */	"reg: INDIRI4(VREGP)",
/* 198 */	"reg: INDIRU4(VREGP)",
/* 199 */	"reg: INDIRF4(VREGP)",
/* 200 */	"stmt: ASGNI4(VREGP,reg)",
/* 201 */	"stmt: ASGNU4(VREGP,reg)",
/* 202 */	"stmt: ASGNF4(VREGP,reg)",
/* 203 */	"reg: INDIRI4(addr)",
/* 204 */	"reg: INDIRU4(addr)",
/* 205 */	"reg: INDIRF4(addr)",
/* 206 */	"memf: INDIRI4(ADDRGP2)",
/* 207 */	"memf: INDIRU4(ADDRGP2)",
/* 208 */	"memf: INDIRF4(ADDRGP2)",
/* 209 */	"miaf: INDIRI4(addr)",
/* 210 */	"miaf: INDIRU4(addr)",
/* 211 */	"miaf: INDIRF4(addr)",
/* 212 */	"mrf: memf",
/* 213 */	"mrf: reg",
/* 214 */	"maf: memf",
/* 215 */	"maf: miaf",
/* 216 */	"stmt: ASGNI4(addr,mrf)",
/* 217 */	"stmt: ASGNU4(addr,mrf)",
/* 218 */	"stmt: ASGNF4(addr,mrf)",
/* 219 */	"stmt: ARGI4(maf)",
/* 220 */	"stmt: ARGU4(maf)",
/* 221 */	"stmt: ARGF4(maf)",
/* 222 */	"reg: CVFF4(maf)",
/* 223 */	"reg: CVFI1(maf)",
/* 224 */	"reg: CVFI2(maf)",
/* 225 */	"reg: CVFI4(maf)",
/* 226 */	"reg: CVIF4(reg)",
/* 227 */	"reg: CVII4(reg)",
/* 228 */	"reg: CVIU4(reg)",
/* 229 */	"reg: CVUI4(reg)",
/* 230 */	"reg: CVUU4(reg)",
/* 231 */	"reg: CVPU4(reg)",
/* 232 */	"reg: NEGI4(maf)",
/* 233 */	"reg: NEGF4(maf)",
/* 234 */	"reg: BCOMI4(maf)",
/* 235 */	"reg: BCOMU4(maf)",
/* 236 */	"reg: LSHI4(reg,rc8)",
/* 237 */	"reg: LSHU4(reg,rc8)",
/* 238 */	"reg: RSHI4(reg,rc8)",
/* 239 */	"reg: RSHU4(reg,rc8)",
/* 240 */	"reg: MODI4(maf,maf)",
/* 241 */	"reg: MODU4(maf,maf)",
/* 242 */	"reg: BANDI4(maf,maf)",
/* 243 */	"reg: BANDU4(maf,maf)",
/* 244 */	"reg: BORI4(maf,maf)",
/* 245 */	"reg: BORU4(maf,maf)",
/* 246 */	"reg: BXORI4(maf,maf)",
/* 247 */	"reg: BXORU4(maf,maf)",
/* 248 */	"reg: ADDI4(maf,maf)",
/* 249 */	"reg: ADDU4(maf,maf)",
/* 250 */	"reg: ADDF4(maf,maf)",
/* 251 */	"reg: SUBI4(maf,maf)",
/* 252 */	"reg: SUBU4(maf,maf)",
/* 253 */	"reg: SUBF4(maf,maf)",
/* 254 */	"reg: MULI4(maf,maf)",
/* 255 */	"reg: MULU4(maf,maf)",
/* 256 */	"reg: MULF4(maf,maf)",
/* 257 */	"reg: DIVI4(maf,maf)",
/* 258 */	"reg: DIVU4(maf,maf)",
/* 259 */	"reg: DIVF4(maf,maf)",
/* 260 */	"stmt: ASGNI4(addr,NEGI4(maf))",
/* 261 */	"stmt: ASGNF4(addr,NEGF4(maf))",
/* 262 */	"stmt: ASGNI4(addr,BCOMI4(maf))",
/* 263 */	"stmt: ASGNF4(addr,BCOMU4(maf))",
/* 264 */	"stmt: ASGNI4(addr,ADDI4(maf,maf))",
/* 265 */	"stmt: ASGNU4(addr,ADDU4(maf,maf))",
/* 266 */	"stmt: ASGNF4(addr,ADDF4(maf,maf))",
/* 267 */	"stmt: ASGNI4(addr,SUBI4(maf,maf))",
/* 268 */	"stmt: ASGNU4(addr,SUBU4(maf,maf))",
/* 269 */	"stmt: ASGNF4(addr,SUBF4(maf,maf))",
/* 270 */	"stmt: ASGNI4(addr,MULI4(maf,maf))",
/* 271 */	"stmt: ASGNU4(addr,MULU4(maf,maf))",
/* 272 */	"stmt: ASGNF4(addr,MULF4(maf,maf))",
/* 273 */	"stmt: ASGNI4(addr,DIVI4(maf,maf))",
/* 274 */	"stmt: ASGNU4(addr,DIVU4(maf,maf))",
/* 275 */	"stmt: ASGNF4(addr,DIVF4(maf,maf))",
/* 276 */	"stmt: ASGNI4(addr,MODI4(maf,maf))",
/* 277 */	"stmt: ASGNU4(addr,MODU4(maf,maf))",
/* 278 */	"stmt: ASGNI4(addr,BANDI4(maf,maf))",
/* 279 */	"stmt: ASGNU4(addr,BANDU4(maf,maf))",
/* 280 */	"stmt: ASGNI4(addr,BORI4(maf,maf))",
/* 281 */	"stmt: ASGNU4(addr,BORU4(maf,maf))",
/* 282 */	"stmt: ASGNI4(addr,BXORI4(maf,maf))",
/* 283 */	"stmt: ASGNU4(addr,BXORU4(maf,maf))",
/* 284 */	"stmt: EQI4(maf,maf)",
/* 285 */	"stmt: EQU4(maf,maf)",
/* 286 */	"stmt: EQF4(maf,maf)",
/* 287 */	"stmt: NEI4(maf,maf)",
/* 288 */	"stmt: NEU4(maf,maf)",
/* 289 */	"stmt: NEF4(maf,maf)",
/* 290 */	"stmt: GEI4(maf,maf)",
/* 291 */	"stmt: GEU4(maf,maf)",
/* 292 */	"stmt: GEF4(maf,maf)",
/* 293 */	"stmt: GTI4(maf,maf)",
/* 294 */	"stmt: GTU4(maf,maf)",
/* 295 */	"stmt: GTF4(maf,maf)",
/* 296 */	"stmt: LEI4(maf,maf)",
/* 297 */	"stmt: LEU4(maf,maf)",
/* 298 */	"stmt: LEF4(maf,maf)",
/* 299 */	"stmt: LTI4(maf,maf)",
/* 300 */	"stmt: LTU4(maf,maf)",
/* 301 */	"stmt: LTF4(maf,maf)",
/* 302 */	"reg: CALLI4(addrj)",
/* 303 */	"reg: CALLU4(addrj)",
/* 304 */	"reg: CALLF4(addrj)",
/* 305 */	"stmt: RETI4(reg)",
/* 306 */	"stmt: RETU4(reg)",
/* 307 */	"stmt: RETF4(reg)",
};

static short _decode_stmt[] = {
	0,
	6,
	7,
	8,
	9,
	10,
	21,
	101,
	102,
	103,
	104,
	105,
	106,
	107,
	108,
	109,
	110,
	111,
	112,
	113,
	114,
	115,
	116,
	117,
	128,
	129,
	130,
	131,
	132,
	133,
	134,
	135,
	136,
	137,
	138,
	139,
	140,
	141,
	142,
	143,
	144,
	147,
	148,
	149,
	150,
	151,
	152,
	153,
	154,
	155,
	156,
	157,
	158,
	159,
	160,
	161,
	162,
	163,
	164,
	165,
	166,
	167,
	168,
	169,
	170,
	171,
	172,
	173,
	174,
	175,
	176,
	177,
	178,
	179,
	180,
	181,
	182,
	183,
	184,
	190,
	191,
	192,
	193,
	194,
	195,
	196,
	200,
	201,
	202,
	216,
	217,
	218,
	219,
	220,
	221,
	260,
	261,
	262,
	263,
	264,
	265,
	266,
	267,
	268,
	269,
	270,
	271,
	272,
	273,
	274,
	275,
	276,
	277,
	278,
	279,
	280,
	281,
	282,
	283,
	284,
	285,
	286,
	287,
	288,
	289,
	290,
	291,
	292,
	293,
	294,
	295,
	296,
	297,
	298,
	299,
	300,
	301,
	305,
	306,
	307,
};

static short _decode_reg[] = {
	0,
	1,
	2,
	3,
	4,
	5,
	22,
	23,
	24,
	39,
	40,
	41,
	42,
	43,
	44,
	45,
	46,
	47,
	48,
	49,
	50,
	51,
	52,
	53,
	54,
	55,
	56,
	57,
	58,
	59,
	60,
	61,
	62,
	63,
	64,
	65,
	66,
	67,
	68,
	69,
	70,
	71,
	72,
	73,
	74,
	75,
	76,
	77,
	78,
	81,
	82,
	83,
	84,
	85,
	86,
	87,
	88,
	89,
	90,
	91,
	92,
	93,
	94,
	95,
	96,
	97,
	98,
	99,
	100,
	118,
	119,
	120,
	121,
	122,
	123,
	124,
	125,
	126,
	127,
	185,
	186,
	187,
	188,
	189,
	197,
	198,
	199,
	203,
	204,
	205,
	222,
	223,
	224,
	225,
	226,
	227,
	228,
	229,
	230,
	231,
	232,
	233,
	234,
	235,
	236,
	237,
	238,
	239,
	240,
	241,
	242,
	243,
	244,
	245,
	246,
	247,
	248,
	249,
	250,
	251,
	252,
	253,
	254,
	255,
	256,
	257,
	258,
	259,
	302,
	303,
	304,
};

static short _decode_con[] = {
	0,
	11,
	12,
	13,
	14,
	15,
	16,
};

static short _decode_con8[] = {
	0,
	17,
	18,
	19,
	20,
};

static short _decode_stk[] = {
	0,
	25,
	26,
};

static short _decode_base[] = {
	0,
	27,
	28,
};

static short _decode_addr[] = {
	0,
	29,
	30,
};

static short _decode_mem[] = {
	0,
	31,
	32,
};

static short _decode_rc[] = {
	0,
	33,
	34,
};

static short _decode_mr[] = {
	0,
	35,
	36,
};

static short _decode_mrc[] = {
	0,
	37,
	38,
};

static short _decode_rc8[] = {
	0,
	79,
	80,
};

static short _decode_addrj[] = {
	0,
	145,
	146,
};

static short _decode_memf[] = {
	0,
	206,
	207,
	208,
};

static short _decode_miaf[] = {
	0,
	209,
	210,
	211,
};

static short _decode_mrf[] = {
	0,
	212,
	213,
};

static short _decode_maf[] = {
	0,
	214,
	215,
};

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 17)
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
	if (!state)
		return 0;
	switch (goalnt) {
	case _stmt_NT:	return _decode_stmt[((struct _state *)state)->rule._stmt];
	case _reg_NT:	return _decode_reg[((struct _state *)state)->rule._reg];
	case _con_NT:	return _decode_con[((struct _state *)state)->rule._con];
	case _con8_NT:	return _decode_con8[((struct _state *)state)->rule._con8];
	case _stk_NT:	return _decode_stk[((struct _state *)state)->rule._stk];
	case _base_NT:	return _decode_base[((struct _state *)state)->rule._base];
	case _addr_NT:	return _decode_addr[((struct _state *)state)->rule._addr];
	case _mem_NT:	return _decode_mem[((struct _state *)state)->rule._mem];
	case _rc_NT:	return _decode_rc[((struct _state *)state)->rule._rc];
	case _mr_NT:	return _decode_mr[((struct _state *)state)->rule._mr];
	case _mrc_NT:	return _decode_mrc[((struct _state *)state)->rule._mrc];
	case _rc8_NT:	return _decode_rc8[((struct _state *)state)->rule._rc8];
	case _addrj_NT:	return _decode_addrj[((struct _state *)state)->rule._addrj];
	case _memf_NT:	return _decode_memf[((struct _state *)state)->rule._memf];
	case _miaf_NT:	return _decode_miaf[((struct _state *)state)->rule._miaf];
	case _mrf_NT:	return _decode_mrf[((struct _state *)state)->rule._mrf];
	case _maf_NT:	return _decode_maf[((struct _state *)state)->rule._maf];
	default:
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
		return 0;
	}
}

static void _closure_reg(NODEPTR_TYPE, int);
static void _closure_con(NODEPTR_TYPE, int);
static void _closure_con8(NODEPTR_TYPE, int);
static void _closure_stk(NODEPTR_TYPE, int);
static void _closure_base(NODEPTR_TYPE, int);
static void _closure_addr(NODEPTR_TYPE, int);
static void _closure_mem(NODEPTR_TYPE, int);
static void _closure_rc(NODEPTR_TYPE, int);
static void _closure_mrc(NODEPTR_TYPE, int);
static void _closure_memf(NODEPTR_TYPE, int);
static void _closure_miaf(NODEPTR_TYPE, int);

static void _closure_reg(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_mrf_NT]) {
		p->cost[_mrf_NT] = c + 0;
		p->rule._mrf = 2;
	}
	if (c + 2 < p->cost[_addrj_NT]) {
		p->cost[_addrj_NT] = c + 2;
		p->rule._addrj = 2;
	}
	if (c + 5 < p->cost[_rc8_NT]) {
		p->cost[_rc8_NT] = c + 5;
		p->rule._rc8 = 2;
	}
	if (c + 0 < p->cost[_mr_NT]) {
		p->cost[_mr_NT] = c + 0;
		p->rule._mr = 2;
	}
	if (c + 0 < p->cost[_rc_NT]) {
		p->cost[_rc_NT] = c + 0;
		p->rule._rc = 2;
		_closure_rc(a, c + 0);
	}
	if (c + 3 < p->cost[_base_NT]) {
		p->cost[_base_NT] = c + 3;
		p->rule._base = 2;
		_closure_base(a, c + 3);
	}
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 6;
	}
}

static void _closure_con(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_rc_NT]) {
		p->cost[_rc_NT] = c + 0;
		p->rule._rc = 1;
		_closure_rc(a, c + 0);
	}
	if (c + 0 < p->cost[_base_NT]) {
		p->cost[_base_NT] = c + 0;
		p->rule._base = 1;
		_closure_base(a, c + 0);
	}
}

static void _closure_con8(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_rc8_NT]) {
		p->cost[_rc8_NT] = c + 0;
		p->rule._rc8 = 1;
	}
}

static void _closure_stk(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_addr_NT]) {
		p->cost[_addr_NT] = c + 0;
		p->rule._addr = 2;
		_closure_addr(a, c + 0);
	}
}

static void _closure_base(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_addr_NT]) {
		p->cost[_addr_NT] = c + 0;
		p->rule._addr = 1;
		_closure_addr(a, c + 0);
	}
}

static void _closure_addr(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_reg_NT]) {
		p->cost[_reg_NT] = c + 1;
		p->rule._reg = 9;
		_closure_reg(a, c + 1);
	}
}

static void _closure_mem(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 3 < p->cost[_mrc_NT]) {
		p->cost[_mrc_NT] = c + 3;
		p->rule._mrc = 1;
		_closure_mrc(a, c + 3);
	}
	if (c + 3 < p->cost[_mr_NT]) {
		p->cost[_mr_NT] = c + 3;
		p->rule._mr = 1;
	}
}

static void _closure_rc(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_mrc_NT]) {
		p->cost[_mrc_NT] = c + 0;
		p->rule._mrc = 2;
		_closure_mrc(a, c + 0);
	}
}

static void _closure_mrc(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_reg_NT]) {
		p->cost[_reg_NT] = c + 1;
		p->rule._reg = 10;
		_closure_reg(a, c + 1);
	}
}

static void _closure_memf(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 3 < p->cost[_maf_NT]) {
		p->cost[_maf_NT] = c + 3;
		p->rule._maf = 1;
	}
	if (c + 3 < p->cost[_mrf_NT]) {
		p->cost[_mrf_NT] = c + 3;
		p->rule._mrf = 1;
	}
}

static void _closure_miaf(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 3 < p->cost[_maf_NT]) {
		p->cost[_maf_NT] = c + 3;
		p->rule._maf = 2;
	}
}

static void _label(NODEPTR_TYPE a) {
	int c;
	struct _state *p;

	if (!a)
		fatal("_label", "Null tree\n", 0);
	STATE_LABEL(a) = p = allocate(sizeof *p, FUNC);
	p->rule._stmt = 0;
	p->cost[1] =
	p->cost[2] =
	p->cost[3] =
	p->cost[4] =
	p->cost[5] =
	p->cost[6] =
	p->cost[7] =
	p->cost[8] =
	p->cost[9] =
	p->cost[10] =
	p->cost[11] =
	p->cost[12] =
	p->cost[13] =
	p->cost[14] =
	p->cost[15] =
	p->cost[16] =
	p->cost[17] =
		0x7fff;
	switch (OP_LABEL(a)) {
	case 41: /* ARGB */
		_label(LEFT_CHILD(a));
		if (	/* stmt: ARGB(INDIRB(reg)) */
			LEFT_CHILD(a)->op == 73 /* INDIRB */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 40;
			}
		}
		break;
	case 57: /* ASGNB */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNB(reg,INDIRB(reg)) */
			RIGHT_CHILD(a)->op == 73 /* INDIRB */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 39;
			}
		}
		break;
	case 73: /* INDIRB */
		_label(LEFT_CHILD(a));
		break;
	case 216: /* CALLV */
		_label(LEFT_CHILD(a));
		/* stmt: CALLV(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 79;
		}
		break;
	case 217: /* CALLB */
		break;
	case 233: /* LOADB */
		break;
	case 248: /* RETV */
		_label(LEFT_CHILD(a));
		/* stmt: RETV(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 85;
		}
		break;
	case 584: /* JUMPV */
		_label(LEFT_CHILD(a));
		/* stmt: JUMPV(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 41;
		}
		break;
	case 600: /* LABELV */
		/* stmt: LABELV */
		if (0 + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = 0 + 0;
			p->rule._stmt = 42;
		}
		break;
	case 711: /* VREGP */
		break;
	case 1045: /* CNSTI1 */
		/* con: CNSTI1 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 1;
			_closure_con(a, 0 + 0);
		}
		/* con8: CNSTI1 */
		c = (range(a, 0, 255));
		if (c + 0 < p->cost[_con8_NT]) {
			p->cost[_con8_NT] = c + 0;
			p->rule._con8 = 1;
			_closure_con8(a, c + 0);
		}
		break;
	case 1046: /* CNSTU1 */
		/* con: CNSTU1 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 2;
			_closure_con(a, 0 + 0);
		}
		/* con8: CNSTU1 */
		c = (range(a, 0, 255));
		if (c + 0 < p->cost[_con8_NT]) {
			p->cost[_con8_NT] = c + 0;
			p->rule._con8 = 2;
			_closure_con8(a, c + 0);
		}
		break;
	case 1061: /* ARGI1 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGI1(mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 34;
		}
		break;
	case 1062: /* ARGU1 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGU1(mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 35;
		}
		break;
	case 1077: /* ASGNI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNI1(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 1;
			}
		}
		if (	/* stmt: ASGNI1(addr,ADDI1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1333 /* ADDI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 7;
			}
		}
		if (	/* stmt: ASGNI1(addr,SUBI1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1349 /* SUBI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 9;
			}
		}
		if (	/* stmt: ASGNI1(addr,BANDI1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1413 /* BANDI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 11;
			}
		}
		if (	/* stmt: ASGNI1(addr,BORI1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1445 /* BORI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 13;
			}
		}
		if (	/* stmt: ASGNI1(addr,BXORI1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1461 /* BXORI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 15;
			}
		}
		if (	/* stmt: ASGNI1(addr,BCOMI1(mem)) */
			RIGHT_CHILD(a)->op == 1429 /* BCOMI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 17;
			}
		}
		if (	/* stmt: ASGNI1(addr,NEGI1(mem)) */
			RIGHT_CHILD(a)->op == 1221 /* NEGI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 19;
			}
		}
		if (	/* stmt: ASGNI1(addr,LSHI1(mem,con8)) */
			RIGHT_CHILD(a)->op == 1365 /* LSHI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_con8_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 20;
			}
		}
		if (	/* stmt: ASGNI1(addr,RSHI1(mem,con8)) */
			RIGHT_CHILD(a)->op == 1397 /* RSHI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_con8_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 22;
			}
		}
		/* stmt: ASGNI1(addr,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 24;
		}
		/* stmt: ASGNI1(stk,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 29;
		}
		break;
	case 1078: /* ASGNU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNU1(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 2;
			}
		}
		if (	/* stmt: ASGNU1(addr,ADDU1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1334 /* ADDU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 8;
			}
		}
		if (	/* stmt: ASGNU1(addr,SUBU1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1350 /* SUBU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 10;
			}
		}
		if (	/* stmt: ASGNU1(addr,BANDU1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1414 /* BANDU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 12;
			}
		}
		if (	/* stmt: ASGNU1(addr,BORU1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1446 /* BORU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 14;
			}
		}
		if (	/* stmt: ASGNU1(addr,BXORU1(mem,rc)) */
			RIGHT_CHILD(a)->op == 1462 /* BXORU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_rc_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 16;
			}
		}
		if (	/* stmt: ASGNU1(addr,BCOMU1(mem)) */
			RIGHT_CHILD(a)->op == 1430 /* BCOMU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 18;
			}
		}
		if (	/* stmt: ASGNU1(addr,LSHU1(mem,con8)) */
			RIGHT_CHILD(a)->op == 1366 /* LSHU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_con8_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 21;
			}
		}
		if (	/* stmt: ASGNU1(addr,RSHU1(mem,con8)) */
			RIGHT_CHILD(a)->op == 1398 /* RSHU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_con8_NT] + (memop(a));
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 23;
			}
		}
		/* stmt: ASGNU1(addr,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 25;
		}
		/* stmt: ASGNU1(stk,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 30;
		}
		break;
	case 1093: /* INDIRI1 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRI1(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 1;
				_closure_reg(a, c + 0);
			}
		}
		/* mem: INDIRI1(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0;
		if (c + 0 < p->cost[_mem_NT]) {
			p->cost[_mem_NT] = c + 0;
			p->rule._mem = 1;
			_closure_mem(a, c + 0);
		}
		/* reg: INDIRI1(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 11;
			_closure_reg(a, c + 0);
		}
		break;
	case 1094: /* INDIRU1 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRU1(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 2;
				_closure_reg(a, c + 0);
			}
		}
		/* mem: INDIRU1(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0;
		if (c + 0 < p->cost[_mem_NT]) {
			p->cost[_mem_NT] = c + 0;
			p->rule._mem = 2;
			_closure_mem(a, c + 0);
		}
		/* reg: INDIRU1(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 12;
			_closure_reg(a, c + 0);
		}
		break;
	case 1141: /* CVFI1 */
		_label(LEFT_CHILD(a));
		/* reg: CVFI1(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 91;
			_closure_reg(a, c + 0);
		}
		break;
	case 1157: /* CVII1 */
		_label(LEFT_CHILD(a));
		/* reg: CVII1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 69;
			_closure_reg(a, c + 0);
		}
		break;
	case 1158: /* CVIU1 */
		_label(LEFT_CHILD(a));
		/* reg: CVIU1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 70;
			_closure_reg(a, c + 0);
		}
		break;
	case 1205: /* CVUI1 */
		_label(LEFT_CHILD(a));
		/* reg: CVUI1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 71;
			_closure_reg(a, c + 0);
		}
		break;
	case 1206: /* CVUU1 */
		_label(LEFT_CHILD(a));
		/* reg: CVUU1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 72;
			_closure_reg(a, c + 0);
		}
		break;
	case 1221: /* NEGI1 */
		_label(LEFT_CHILD(a));
		/* reg: NEGI1(mr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 47;
			_closure_reg(a, c + 0);
		}
		break;
	case 1237: /* CALLI1 */
		_label(LEFT_CHILD(a));
		/* reg: CALLI1(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 79;
			_closure_reg(a, c + 0);
		}
		break;
	case 1238: /* CALLU1 */
		_label(LEFT_CHILD(a));
		/* reg: CALLU1(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 80;
			_closure_reg(a, c + 0);
		}
		break;
	case 1253: /* LOADI1 */
		_label(LEFT_CHILD(a));
		/* reg: LOADI1(rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_rc_NT] + (move_r(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 16;
			_closure_reg(a, c + 0);
		}
		break;
	case 1254: /* LOADU1 */
		_label(LEFT_CHILD(a));
		/* reg: LOADU1(rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_rc_NT] + (move_r(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 17;
			_closure_reg(a, c + 0);
		}
		break;
	case 1269: /* RETI1 */
		_label(LEFT_CHILD(a));
		/* stmt: RETI1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 80;
		}
		break;
	case 1270: /* RETU1 */
		_label(LEFT_CHILD(a));
		/* stmt: RETU1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 81;
		}
		break;
	case 1333: /* ADDI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 21;
			_closure_reg(a, c + 0);
		}
		break;
	case 1334: /* ADDU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 22;
			_closure_reg(a, c + 0);
		}
		break;
	case 1349: /* SUBI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 26;
			_closure_reg(a, c + 0);
		}
		break;
	case 1350: /* SUBU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 27;
			_closure_reg(a, c + 0);
		}
		break;
	case 1365: /* LSHI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHI1(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 49;
			_closure_reg(a, c + 0);
		}
		break;
	case 1366: /* LSHU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHU1(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 51;
			_closure_reg(a, c + 0);
		}
		break;
	case 1381: /* MODI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODI1(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 65;
			_closure_reg(a, c + 0);
		}
		break;
	case 1382: /* MODU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODU1(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 67;
			_closure_reg(a, c + 0);
		}
		break;
	case 1397: /* RSHI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHI1(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 53;
			_closure_reg(a, c + 0);
		}
		break;
	case 1398: /* RSHU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHU1(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 55;
			_closure_reg(a, c + 0);
		}
		break;
	case 1413: /* BANDI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 31;
			_closure_reg(a, c + 0);
		}
		break;
	case 1414: /* BANDU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 32;
			_closure_reg(a, c + 0);
		}
		break;
	case 1429: /* BCOMI1 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMI1(mr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 43;
			_closure_reg(a, c + 0);
		}
		break;
	case 1430: /* BCOMU1 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMU1(mr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 44;
			_closure_reg(a, c + 0);
		}
		break;
	case 1445: /* BORI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 35;
			_closure_reg(a, c + 0);
		}
		break;
	case 1446: /* BORU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 36;
			_closure_reg(a, c + 0);
		}
		break;
	case 1461: /* BXORI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 39;
			_closure_reg(a, c + 0);
		}
		break;
	case 1462: /* BXORU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 40;
			_closure_reg(a, c + 0);
		}
		break;
	case 1477: /* DIVI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVI1(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 61;
			_closure_reg(a, c + 0);
		}
		break;
	case 1478: /* DIVU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVU1(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 63;
			_closure_reg(a, c + 0);
		}
		break;
	case 1493: /* MULI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULI1(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 57;
			_closure_reg(a, c + 0);
		}
		break;
	case 1494: /* MULU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULU1(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 59;
			_closure_reg(a, c + 0);
		}
		break;
	case 1509: /* EQI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 43;
		}
		/* stmt: EQI1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 55;
		}
		break;
	case 1510: /* EQU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 44;
		}
		/* stmt: EQU1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 56;
		}
		break;
	case 1525: /* GEI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 47;
		}
		/* stmt: GEI1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 59;
		}
		break;
	case 1526: /* GEU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 48;
		}
		/* stmt: GEU1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 60;
		}
		break;
	case 1541: /* GTI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 5;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 51;
		}
		/* stmt: GTI1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 63;
		}
		break;
	case 1542: /* GTU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 5;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 52;
		}
		/* stmt: GTU1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 64;
		}
		break;
	case 1557: /* LEI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 5;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 53;
		}
		/* stmt: LEI1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 65;
		}
		break;
	case 1558: /* LEU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 5;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 54;
		}
		/* stmt: LEU1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 66;
		}
		break;
	case 1573: /* LTI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 49;
		}
		/* stmt: LTI1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 61;
		}
		break;
	case 1574: /* LTU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 50;
		}
		/* stmt: LTU1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 62;
		}
		break;
	case 1589: /* NEI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEI1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 45;
		}
		/* stmt: NEI1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 57;
		}
		break;
	case 1590: /* NEU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEU1(reg,mrc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 46;
		}
		/* stmt: NEU1(mem,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_mem_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 58;
		}
		break;
	case 2069: /* CNSTI2 */
		/* con: CNSTI2 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 3;
			_closure_con(a, 0 + 0);
		}
		/* con8: CNSTI2 */
		c = (range(a, 0, 255));
		if (c + 0 < p->cost[_con8_NT]) {
			p->cost[_con8_NT] = c + 0;
			p->rule._con8 = 3;
			_closure_con8(a, c + 0);
		}
		break;
	case 2070: /* CNSTU2 */
		/* con: CNSTU2 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 4;
			_closure_con(a, 0 + 0);
		}
		/* con8: CNSTU2 */
		c = (range(a, 0, 255));
		if (c + 0 < p->cost[_con8_NT]) {
			p->cost[_con8_NT] = c + 0;
			p->rule._con8 = 4;
			_closure_con8(a, c + 0);
		}
		break;
	case 2071: /* CNSTP2 */
		/* con: CNSTP2 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 5;
			_closure_con(a, 0 + 0);
		}
		break;
	case 2085: /* ARGI2 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGI2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 36;
		}
		break;
	case 2086: /* ARGU2 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGU2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 37;
		}
		break;
	case 2087: /* ARGP2 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGP2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 38;
		}
		break;
	case 2101: /* ASGNI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNI2(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 3;
			}
		}
		/* stmt: ASGNI2(addr,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 26;
		}
		/* stmt: ASGNI2(stk,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 31;
		}
		break;
	case 2102: /* ASGNU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNU2(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 4;
			}
		}
		/* stmt: ASGNU2(addr,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 27;
		}
		/* stmt: ASGNU2(stk,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 32;
		}
		break;
	case 2103: /* ASGNP2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNP2(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 5;
			}
		}
		/* stmt: ASGNP2(addr,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 28;
		}
		/* stmt: ASGNP2(stk,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 33;
		}
		break;
	case 2117: /* INDIRI2 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRI2(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 3;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRI2(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 13;
			_closure_reg(a, c + 0);
		}
		break;
	case 2118: /* INDIRU2 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRU2(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 4;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRU2(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 14;
			_closure_reg(a, c + 0);
		}
		break;
	case 2119: /* INDIRP2 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRP2(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 5;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRP2(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 15;
			_closure_reg(a, c + 0);
		}
		break;
	case 2165: /* CVFI2 */
		_label(LEFT_CHILD(a));
		/* reg: CVFI2(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 92;
			_closure_reg(a, c + 0);
		}
		break;
	case 2181: /* CVII2 */
		_label(LEFT_CHILD(a));
		/* reg: CVII2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 73;
			_closure_reg(a, c + 0);
		}
		break;
	case 2182: /* CVIU2 */
		_label(LEFT_CHILD(a));
		/* reg: CVIU2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 74;
			_closure_reg(a, c + 0);
		}
		break;
	case 2198: /* CVPU2 */
		_label(LEFT_CHILD(a));
		/* reg: CVPU2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 78;
			_closure_reg(a, c + 0);
		}
		break;
	case 2229: /* CVUI2 */
		_label(LEFT_CHILD(a));
		/* reg: CVUI2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 75;
			_closure_reg(a, c + 0);
		}
		break;
	case 2230: /* CVUU2 */
		_label(LEFT_CHILD(a));
		/* reg: CVUU2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 76;
			_closure_reg(a, c + 0);
		}
		break;
	case 2231: /* CVUP2 */
		_label(LEFT_CHILD(a));
		/* reg: CVUP2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 77;
			_closure_reg(a, c + 0);
		}
		break;
	case 2245: /* NEGI2 */
		_label(LEFT_CHILD(a));
		/* reg: NEGI2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 48;
			_closure_reg(a, c + 0);
		}
		break;
	case 2261: /* CALLI2 */
		_label(LEFT_CHILD(a));
		/* reg: CALLI2(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 81;
			_closure_reg(a, c + 0);
		}
		break;
	case 2262: /* CALLU2 */
		_label(LEFT_CHILD(a));
		/* reg: CALLU2(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 82;
			_closure_reg(a, c + 0);
		}
		break;
	case 2263: /* CALLP2 */
		_label(LEFT_CHILD(a));
		/* reg: CALLP2(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 83;
			_closure_reg(a, c + 0);
		}
		break;
	case 2277: /* LOADI2 */
		_label(LEFT_CHILD(a));
		/* reg: LOADI2(rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_rc_NT] + (move_r(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 18;
			_closure_reg(a, c + 0);
		}
		break;
	case 2278: /* LOADU2 */
		_label(LEFT_CHILD(a));
		/* reg: LOADU2(rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_rc_NT] + (move_r(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 19;
			_closure_reg(a, c + 0);
		}
		break;
	case 2279: /* LOADP2 */
		_label(LEFT_CHILD(a));
		/* reg: LOADP2(rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_rc_NT] + (move_r(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 20;
			_closure_reg(a, c + 0);
		}
		break;
	case 2293: /* RETI2 */
		_label(LEFT_CHILD(a));
		/* stmt: RETI2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 82;
		}
		break;
	case 2294: /* RETU2 */
		_label(LEFT_CHILD(a));
		/* stmt: RETU2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 83;
		}
		break;
	case 2295: /* RETP2 */
		_label(LEFT_CHILD(a));
		/* stmt: RETP2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 84;
		}
		break;
	case 2311: /* ADDRGP2 */
		/* con: ADDRGP2 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 6;
			_closure_con(a, 0 + 0);
		}
		/* reg: ADDRGP2 */
		if (1 + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = 1 + 0;
			p->rule._reg = 6;
			_closure_reg(a, 1 + 0);
		}
		/* addrj: ADDRGP2 */
		if (0 + 0 < p->cost[_addrj_NT]) {
			p->cost[_addrj_NT] = 0 + 0;
			p->rule._addrj = 1;
		}
		break;
	case 2327: /* ADDRFP2 */
		/* reg: ADDRFP2 */
		if (3 + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = 3 + 0;
			p->rule._reg = 7;
			_closure_reg(a, 3 + 0);
		}
		/* stk: ADDRFP2 */
		if (0 + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = 0 + 0;
			p->rule._stk = 1;
			_closure_stk(a, 0 + 0);
		}
		break;
	case 2343: /* ADDRLP2 */
		/* reg: ADDRLP2 */
		if (3 + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = 3 + 0;
			p->rule._reg = 8;
			_closure_reg(a, 3 + 0);
		}
		/* stk: ADDRLP2 */
		if (0 + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = 0 + 0;
			p->rule._stk = 2;
			_closure_stk(a, 0 + 0);
		}
		break;
	case 2357: /* ADDI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 23;
			_closure_reg(a, c + 0);
		}
		break;
	case 2358: /* ADDU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 24;
			_closure_reg(a, c + 0);
		}
		break;
	case 2359: /* ADDP2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDP2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 25;
			_closure_reg(a, c + 0);
		}
		break;
	case 2373: /* SUBI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 28;
			_closure_reg(a, c + 0);
		}
		break;
	case 2374: /* SUBU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 29;
			_closure_reg(a, c + 0);
		}
		break;
	case 2375: /* SUBP2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBP2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 30;
			_closure_reg(a, c + 0);
		}
		break;
	case 2389: /* LSHI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHI2(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 50;
			_closure_reg(a, c + 0);
		}
		break;
	case 2390: /* LSHU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHU2(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 52;
			_closure_reg(a, c + 0);
		}
		break;
	case 2405: /* MODI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODI2(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 66;
			_closure_reg(a, c + 0);
		}
		break;
	case 2406: /* MODU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODU2(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 68;
			_closure_reg(a, c + 0);
		}
		break;
	case 2421: /* RSHI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHI2(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 54;
			_closure_reg(a, c + 0);
		}
		break;
	case 2422: /* RSHU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHU2(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 56;
			_closure_reg(a, c + 0);
		}
		break;
	case 2437: /* BANDI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 33;
			_closure_reg(a, c + 0);
		}
		break;
	case 2438: /* BANDU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 34;
			_closure_reg(a, c + 0);
		}
		break;
	case 2453: /* BCOMI2 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMI2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 45;
			_closure_reg(a, c + 0);
		}
		break;
	case 2454: /* BCOMU2 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMU2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 46;
			_closure_reg(a, c + 0);
		}
		break;
	case 2469: /* BORI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 37;
			_closure_reg(a, c + 0);
		}
		break;
	case 2470: /* BORU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 38;
			_closure_reg(a, c + 0);
		}
		break;
	case 2485: /* BXORI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 41;
			_closure_reg(a, c + 0);
		}
		break;
	case 2486: /* BXORU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 42;
			_closure_reg(a, c + 0);
		}
		break;
	case 2501: /* DIVI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVI2(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 62;
			_closure_reg(a, c + 0);
		}
		break;
	case 2502: /* DIVU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVU2(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 64;
			_closure_reg(a, c + 0);
		}
		break;
	case 2517: /* MULI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULI2(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 58;
			_closure_reg(a, c + 0);
		}
		break;
	case 2518: /* MULU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULU2(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 60;
			_closure_reg(a, c + 0);
		}
		break;
	case 2533: /* EQI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 67;
		}
		break;
	case 2534: /* EQU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 68;
		}
		break;
	case 2549: /* GEI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 7;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 71;
		}
		break;
	case 2550: /* GEU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 7;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 72;
		}
		break;
	case 2565: /* GTI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 75;
		}
		break;
	case 2566: /* GTU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 76;
		}
		break;
	case 2581: /* LEI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 77;
		}
		break;
	case 2582: /* LEU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 78;
		}
		break;
	case 2597: /* LTI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 7;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 73;
		}
		break;
	case 2598: /* LTU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 7;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 74;
		}
		break;
	case 2613: /* NEI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEI2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 69;
		}
		break;
	case 2614: /* NEU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEU2(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 70;
		}
		break;
	case 4113: /* CNSTF4 */
		break;
	case 4117: /* CNSTI4 */
		break;
	case 4118: /* CNSTU4 */
		break;
	case 4129: /* ARGF4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGF4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 94;
		}
		break;
	case 4133: /* ARGI4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGI4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 92;
		}
		break;
	case 4134: /* ARGU4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGU4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 93;
		}
		break;
	case 4145: /* ASGNF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNF4(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 88;
			}
		}
		/* stmt: ASGNF4(addr,mrf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 91;
		}
		if (	/* stmt: ASGNF4(addr,NEGF4(maf)) */
			RIGHT_CHILD(a)->op == 4289 /* NEGF4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 96;
			}
		}
		if (	/* stmt: ASGNF4(addr,BCOMU4(maf)) */
			RIGHT_CHILD(a)->op == 4502 /* BCOMU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 98;
			}
		}
		if (	/* stmt: ASGNF4(addr,ADDF4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4401 /* ADDF4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 101;
			}
		}
		if (	/* stmt: ASGNF4(addr,SUBF4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4417 /* SUBF4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 104;
			}
		}
		if (	/* stmt: ASGNF4(addr,MULF4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4561 /* MULF4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 107;
			}
		}
		if (	/* stmt: ASGNF4(addr,DIVF4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4545 /* DIVF4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 110;
			}
		}
		break;
	case 4149: /* ASGNI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNI4(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 86;
			}
		}
		/* stmt: ASGNI4(addr,mrf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 89;
		}
		if (	/* stmt: ASGNI4(addr,NEGI4(maf)) */
			RIGHT_CHILD(a)->op == 4293 /* NEGI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 95;
			}
		}
		if (	/* stmt: ASGNI4(addr,BCOMI4(maf)) */
			RIGHT_CHILD(a)->op == 4501 /* BCOMI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 97;
			}
		}
		if (	/* stmt: ASGNI4(addr,ADDI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4405 /* ADDI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 99;
			}
		}
		if (	/* stmt: ASGNI4(addr,SUBI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4421 /* SUBI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 102;
			}
		}
		if (	/* stmt: ASGNI4(addr,MULI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4565 /* MULI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 105;
			}
		}
		if (	/* stmt: ASGNI4(addr,DIVI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4549 /* DIVI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 108;
			}
		}
		if (	/* stmt: ASGNI4(addr,MODI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4453 /* MODI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 111;
			}
		}
		if (	/* stmt: ASGNI4(addr,BANDI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4485 /* BANDI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 113;
			}
		}
		if (	/* stmt: ASGNI4(addr,BORI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4517 /* BORI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 115;
			}
		}
		if (	/* stmt: ASGNI4(addr,BXORI4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4533 /* BXORI4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 117;
			}
		}
		break;
	case 4150: /* ASGNU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNU4(VREGP,reg) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 87;
			}
		}
		/* stmt: ASGNU4(addr,mrf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mrf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 90;
		}
		if (	/* stmt: ASGNU4(addr,ADDU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4406 /* ADDU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 100;
			}
		}
		if (	/* stmt: ASGNU4(addr,SUBU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4422 /* SUBU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 103;
			}
		}
		if (	/* stmt: ASGNU4(addr,MULU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4566 /* MULU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 106;
			}
		}
		if (	/* stmt: ASGNU4(addr,DIVU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4550 /* DIVU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 109;
			}
		}
		if (	/* stmt: ASGNU4(addr,MODU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4454 /* MODU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 112;
			}
		}
		if (	/* stmt: ASGNU4(addr,BANDU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4486 /* BANDU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 114;
			}
		}
		if (	/* stmt: ASGNU4(addr,BORU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4518 /* BORU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 116;
			}
		}
		if (	/* stmt: ASGNU4(addr,BXORU4(maf,maf)) */
			RIGHT_CHILD(a)->op == 4534 /* BXORU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_maf_NT] + 16;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 118;
			}
		}
		break;
	case 4161: /* INDIRF4 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRF4(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 86;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRF4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 89;
			_closure_reg(a, c + 0);
		}
		if (	/* memf: INDIRF4(ADDRGP2) */
			LEFT_CHILD(a)->op == 2311 /* ADDRGP2 */
		) {
			c = 0;
			if (c + 0 < p->cost[_memf_NT]) {
				p->cost[_memf_NT] = c + 0;
				p->rule._memf = 3;
				_closure_memf(a, c + 0);
			}
		}
		/* miaf: INDIRF4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0;
		if (c + 0 < p->cost[_miaf_NT]) {
			p->cost[_miaf_NT] = c + 0;
			p->rule._miaf = 3;
			_closure_miaf(a, c + 0);
		}
		break;
	case 4165: /* INDIRI4 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRI4(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 84;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRI4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 87;
			_closure_reg(a, c + 0);
		}
		if (	/* memf: INDIRI4(ADDRGP2) */
			LEFT_CHILD(a)->op == 2311 /* ADDRGP2 */
		) {
			c = 0;
			if (c + 0 < p->cost[_memf_NT]) {
				p->cost[_memf_NT] = c + 0;
				p->rule._memf = 1;
				_closure_memf(a, c + 0);
			}
		}
		/* miaf: INDIRI4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0;
		if (c + 0 < p->cost[_miaf_NT]) {
			p->cost[_miaf_NT] = c + 0;
			p->rule._miaf = 1;
			_closure_miaf(a, c + 0);
		}
		break;
	case 4166: /* INDIRU4 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRU4(VREGP) */
			LEFT_CHILD(a)->op == 711 /* VREGP */
		) {
			if (mayrecalc(a)) {
				struct _state *q = a->syms[RX]->u.t.cse->x.state;
				if (q->cost[_stmt_NT] == 0) {
					p->cost[_stmt_NT] = 0;
					p->rule._stmt = q->rule._stmt;
				}
				if (q->cost[_reg_NT] == 0) {
					p->cost[_reg_NT] = 0;
					p->rule._reg = q->rule._reg;
				}
				if (q->cost[_con_NT] == 0) {
					p->cost[_con_NT] = 0;
					p->rule._con = q->rule._con;
				}
				if (q->cost[_con8_NT] == 0) {
					p->cost[_con8_NT] = 0;
					p->rule._con8 = q->rule._con8;
				}
				if (q->cost[_stk_NT] == 0) {
					p->cost[_stk_NT] = 0;
					p->rule._stk = q->rule._stk;
				}
				if (q->cost[_base_NT] == 0) {
					p->cost[_base_NT] = 0;
					p->rule._base = q->rule._base;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_mem_NT] == 0) {
					p->cost[_mem_NT] = 0;
					p->rule._mem = q->rule._mem;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_mr_NT] == 0) {
					p->cost[_mr_NT] = 0;
					p->rule._mr = q->rule._mr;
				}
				if (q->cost[_mrc_NT] == 0) {
					p->cost[_mrc_NT] = 0;
					p->rule._mrc = q->rule._mrc;
				}
				if (q->cost[_rc8_NT] == 0) {
					p->cost[_rc8_NT] = 0;
					p->rule._rc8 = q->rule._rc8;
				}
				if (q->cost[_addrj_NT] == 0) {
					p->cost[_addrj_NT] = 0;
					p->rule._addrj = q->rule._addrj;
				}
				if (q->cost[_memf_NT] == 0) {
					p->cost[_memf_NT] = 0;
					p->rule._memf = q->rule._memf;
				}
				if (q->cost[_miaf_NT] == 0) {
					p->cost[_miaf_NT] = 0;
					p->rule._miaf = q->rule._miaf;
				}
				if (q->cost[_mrf_NT] == 0) {
					p->cost[_mrf_NT] = 0;
					p->rule._mrf = q->rule._mrf;
				}
				if (q->cost[_maf_NT] == 0) {
					p->cost[_maf_NT] = 0;
					p->rule._maf = q->rule._maf;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 85;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRU4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 88;
			_closure_reg(a, c + 0);
		}
		if (	/* memf: INDIRU4(ADDRGP2) */
			LEFT_CHILD(a)->op == 2311 /* ADDRGP2 */
		) {
			c = 0;
			if (c + 0 < p->cost[_memf_NT]) {
				p->cost[_memf_NT] = c + 0;
				p->rule._memf = 2;
				_closure_memf(a, c + 0);
			}
		}
		/* miaf: INDIRU4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 0;
		if (c + 0 < p->cost[_miaf_NT]) {
			p->cost[_miaf_NT] = c + 0;
			p->rule._miaf = 2;
			_closure_miaf(a, c + 0);
		}
		break;
	case 4209: /* CVFF4 */
		_label(LEFT_CHILD(a));
		/* reg: CVFF4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 90;
			_closure_reg(a, c + 0);
		}
		break;
	case 4213: /* CVFI4 */
		_label(LEFT_CHILD(a));
		/* reg: CVFI4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 93;
			_closure_reg(a, c + 0);
		}
		break;
	case 4225: /* CVIF4 */
		_label(LEFT_CHILD(a));
		/* reg: CVIF4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 94;
			_closure_reg(a, c + 0);
		}
		break;
	case 4229: /* CVII4 */
		_label(LEFT_CHILD(a));
		/* reg: CVII4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 12;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 95;
			_closure_reg(a, c + 0);
		}
		break;
	case 4230: /* CVIU4 */
		_label(LEFT_CHILD(a));
		/* reg: CVIU4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 12;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 96;
			_closure_reg(a, c + 0);
		}
		break;
	case 4246: /* CVPU4 */
		_label(LEFT_CHILD(a));
		/* reg: CVPU4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 12;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 99;
			_closure_reg(a, c + 0);
		}
		break;
	case 4277: /* CVUI4 */
		_label(LEFT_CHILD(a));
		/* reg: CVUI4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 12;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 97;
			_closure_reg(a, c + 0);
		}
		break;
	case 4278: /* CVUU4 */
		_label(LEFT_CHILD(a));
		/* reg: CVUU4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 12;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 98;
			_closure_reg(a, c + 0);
		}
		break;
	case 4289: /* NEGF4 */
		_label(LEFT_CHILD(a));
		/* reg: NEGF4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 101;
			_closure_reg(a, c + 0);
		}
		break;
	case 4293: /* NEGI4 */
		_label(LEFT_CHILD(a));
		/* reg: NEGI4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 100;
			_closure_reg(a, c + 0);
		}
		break;
	case 4305: /* CALLF4 */
		_label(LEFT_CHILD(a));
		/* reg: CALLF4(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 130;
			_closure_reg(a, c + 0);
		}
		break;
	case 4309: /* CALLI4 */
		_label(LEFT_CHILD(a));
		/* reg: CALLI4(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 128;
			_closure_reg(a, c + 0);
		}
		break;
	case 4310: /* CALLU4 */
		_label(LEFT_CHILD(a));
		/* reg: CALLU4(addrj) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrj_NT] + 0;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 129;
			_closure_reg(a, c + 0);
		}
		break;
	case 4321: /* LOADF4 */
		break;
	case 4325: /* LOADI4 */
		break;
	case 4326: /* LOADU4 */
		break;
	case 4337: /* RETF4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETF4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 139;
		}
		break;
	case 4341: /* RETI4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETI4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 137;
		}
		break;
	case 4342: /* RETU4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETU4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 138;
		}
		break;
	case 4401: /* ADDF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 118;
			_closure_reg(a, c + 0);
		}
		break;
	case 4405: /* ADDI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 116;
			_closure_reg(a, c + 0);
		}
		break;
	case 4406: /* ADDU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 117;
			_closure_reg(a, c + 0);
		}
		break;
	case 4417: /* SUBF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 121;
			_closure_reg(a, c + 0);
		}
		break;
	case 4421: /* SUBI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 119;
			_closure_reg(a, c + 0);
		}
		break;
	case 4422: /* SUBU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 120;
			_closure_reg(a, c + 0);
		}
		break;
	case 4437: /* LSHI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHI4(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 104;
			_closure_reg(a, c + 0);
		}
		break;
	case 4438: /* LSHU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHU4(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 105;
			_closure_reg(a, c + 0);
		}
		break;
	case 4453: /* MODI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 108;
			_closure_reg(a, c + 0);
		}
		break;
	case 4454: /* MODU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 109;
			_closure_reg(a, c + 0);
		}
		break;
	case 4469: /* RSHI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHI4(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 106;
			_closure_reg(a, c + 0);
		}
		break;
	case 4470: /* RSHU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHU4(reg,rc8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc8_NT] + 16;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 107;
			_closure_reg(a, c + 0);
		}
		break;
	case 4485: /* BANDI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 110;
			_closure_reg(a, c + 0);
		}
		break;
	case 4486: /* BANDU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 111;
			_closure_reg(a, c + 0);
		}
		break;
	case 4501: /* BCOMI4 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMI4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 102;
			_closure_reg(a, c + 0);
		}
		break;
	case 4502: /* BCOMU4 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMU4(maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 103;
			_closure_reg(a, c + 0);
		}
		break;
	case 4517: /* BORI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 112;
			_closure_reg(a, c + 0);
		}
		break;
	case 4518: /* BORU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 113;
			_closure_reg(a, c + 0);
		}
		break;
	case 4533: /* BXORI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 114;
			_closure_reg(a, c + 0);
		}
		break;
	case 4534: /* BXORU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 115;
			_closure_reg(a, c + 0);
		}
		break;
	case 4545: /* DIVF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 127;
			_closure_reg(a, c + 0);
		}
		break;
	case 4549: /* DIVI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 125;
			_closure_reg(a, c + 0);
		}
		break;
	case 4550: /* DIVU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 126;
			_closure_reg(a, c + 0);
		}
		break;
	case 4561: /* MULF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 124;
			_closure_reg(a, c + 0);
		}
		break;
	case 4565: /* MULI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 122;
			_closure_reg(a, c + 0);
		}
		break;
	case 4566: /* MULU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 32;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 123;
			_closure_reg(a, c + 0);
		}
		break;
	case 4577: /* EQF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 121;
		}
		break;
	case 4581: /* EQI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 119;
		}
		break;
	case 4582: /* EQU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 120;
		}
		break;
	case 4593: /* GEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 127;
		}
		break;
	case 4597: /* GEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 125;
		}
		break;
	case 4598: /* GEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 126;
		}
		break;
	case 4609: /* GTF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 130;
		}
		break;
	case 4613: /* GTI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 128;
		}
		break;
	case 4614: /* GTU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 129;
		}
		break;
	case 4625: /* LEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 133;
		}
		break;
	case 4629: /* LEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 131;
		}
		break;
	case 4630: /* LEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 132;
		}
		break;
	case 4641: /* LTF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 136;
		}
		break;
	case 4645: /* LTI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 134;
		}
		break;
	case 4646: /* LTU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 135;
		}
		break;
	case 4657: /* NEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEF4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 124;
		}
		break;
	case 4661: /* NEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEI4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 122;
		}
		break;
	case 4662: /* NEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEU4(maf,maf) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_maf_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_maf_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 123;
		}
		break;
	default:
		fatal("_label", "Bad terminal %d\n", OP_LABEL(a));
	}
}

static void _kids(NODEPTR_TYPE p, int eruleno, NODEPTR_TYPE kids[]) {
	if (!p)
		fatal("_kids", "Null tree\n", 0);
	if (!kids)
		fatal("_kids", "Null kids\n", 0);
	switch (eruleno) {
	case 208: /* memf: INDIRF4(ADDRGP2) */
	case 207: /* memf: INDIRU4(ADDRGP2) */
	case 206: /* memf: INDIRI4(ADDRGP2) */
	case 199: /* reg: INDIRF4(VREGP) */
	case 198: /* reg: INDIRU4(VREGP) */
	case 197: /* reg: INDIRI4(VREGP) */
	case 148: /* stmt: LABELV */
	case 145: /* addrj: ADDRGP2 */
	case 26: /* stk: ADDRLP2 */
	case 25: /* stk: ADDRFP2 */
	case 24: /* reg: ADDRLP2 */
	case 23: /* reg: ADDRFP2 */
	case 22: /* reg: ADDRGP2 */
	case 20: /* con8: CNSTU2 */
	case 19: /* con8: CNSTI2 */
	case 18: /* con8: CNSTU1 */
	case 17: /* con8: CNSTI1 */
	case 16: /* con: ADDRGP2 */
	case 15: /* con: CNSTP2 */
	case 14: /* con: CNSTU2 */
	case 13: /* con: CNSTI2 */
	case 12: /* con: CNSTU1 */
	case 11: /* con: CNSTI1 */
	case 5: /* reg: INDIRP2(VREGP) */
	case 4: /* reg: INDIRU2(VREGP) */
	case 3: /* reg: INDIRI2(VREGP) */
	case 2: /* reg: INDIRU1(VREGP) */
	case 1: /* reg: INDIRI1(VREGP) */
		break;
	case 202: /* stmt: ASGNF4(VREGP,reg) */
	case 201: /* stmt: ASGNU4(VREGP,reg) */
	case 200: /* stmt: ASGNI4(VREGP,reg) */
	case 10: /* stmt: ASGNP2(VREGP,reg) */
	case 9: /* stmt: ASGNU2(VREGP,reg) */
	case 8: /* stmt: ASGNI2(VREGP,reg) */
	case 7: /* stmt: ASGNU1(VREGP,reg) */
	case 6: /* stmt: ASGNI1(VREGP,reg) */
		kids[0] = RIGHT_CHILD(p);
		break;
	case 215: /* maf: miaf */
	case 214: /* maf: memf */
	case 213: /* mrf: reg */
	case 212: /* mrf: memf */
	case 146: /* addrj: reg */
	case 80: /* rc8: reg */
	case 79: /* rc8: con8 */
	case 40: /* reg: mrc */
	case 39: /* reg: addr */
	case 38: /* mrc: rc */
	case 37: /* mrc: mem */
	case 36: /* mr: reg */
	case 35: /* mr: mem */
	case 34: /* rc: reg */
	case 33: /* rc: con */
	case 30: /* addr: stk */
	case 29: /* addr: base */
	case 28: /* base: reg */
	case 27: /* base: con */
	case 21: /* stmt: reg */
		kids[0] = p;
		break;
	case 307: /* stmt: RETF4(reg) */
	case 306: /* stmt: RETU4(reg) */
	case 305: /* stmt: RETI4(reg) */
	case 304: /* reg: CALLF4(addrj) */
	case 303: /* reg: CALLU4(addrj) */
	case 302: /* reg: CALLI4(addrj) */
	case 235: /* reg: BCOMU4(maf) */
	case 234: /* reg: BCOMI4(maf) */
	case 233: /* reg: NEGF4(maf) */
	case 232: /* reg: NEGI4(maf) */
	case 231: /* reg: CVPU4(reg) */
	case 230: /* reg: CVUU4(reg) */
	case 229: /* reg: CVUI4(reg) */
	case 228: /* reg: CVIU4(reg) */
	case 227: /* reg: CVII4(reg) */
	case 226: /* reg: CVIF4(reg) */
	case 225: /* reg: CVFI4(maf) */
	case 224: /* reg: CVFI2(maf) */
	case 223: /* reg: CVFI1(maf) */
	case 222: /* reg: CVFF4(maf) */
	case 221: /* stmt: ARGF4(maf) */
	case 220: /* stmt: ARGU4(maf) */
	case 219: /* stmt: ARGI4(maf) */
	case 211: /* miaf: INDIRF4(addr) */
	case 210: /* miaf: INDIRU4(addr) */
	case 209: /* miaf: INDIRI4(addr) */
	case 205: /* reg: INDIRF4(addr) */
	case 204: /* reg: INDIRU4(addr) */
	case 203: /* reg: INDIRI4(addr) */
	case 196: /* stmt: RETV(reg) */
	case 195: /* stmt: RETP2(reg) */
	case 194: /* stmt: RETU2(reg) */
	case 193: /* stmt: RETI2(reg) */
	case 192: /* stmt: RETU1(reg) */
	case 191: /* stmt: RETI1(reg) */
	case 190: /* stmt: CALLV(addrj) */
	case 189: /* reg: CALLP2(addrj) */
	case 188: /* reg: CALLU2(addrj) */
	case 187: /* reg: CALLI2(addrj) */
	case 186: /* reg: CALLU1(addrj) */
	case 185: /* reg: CALLI1(addrj) */
	case 147: /* stmt: JUMPV(addrj) */
	case 142: /* stmt: ARGP2(reg) */
	case 141: /* stmt: ARGU2(reg) */
	case 140: /* stmt: ARGI2(reg) */
	case 139: /* stmt: ARGU1(mrc) */
	case 138: /* stmt: ARGI1(mrc) */
	case 127: /* reg: CVPU2(reg) */
	case 126: /* reg: CVUP2(reg) */
	case 125: /* reg: CVUU2(reg) */
	case 124: /* reg: CVUI2(reg) */
	case 123: /* reg: CVIU2(reg) */
	case 122: /* reg: CVII2(reg) */
	case 121: /* reg: CVUU1(reg) */
	case 120: /* reg: CVUI1(reg) */
	case 119: /* reg: CVIU1(reg) */
	case 118: /* reg: CVII1(reg) */
	case 78: /* reg: NEGI2(reg) */
	case 77: /* reg: NEGI1(mr) */
	case 76: /* reg: BCOMU2(reg) */
	case 75: /* reg: BCOMI2(reg) */
	case 74: /* reg: BCOMU1(mr) */
	case 73: /* reg: BCOMI1(mr) */
	case 50: /* reg: LOADP2(rc) */
	case 49: /* reg: LOADU2(rc) */
	case 48: /* reg: LOADI2(rc) */
	case 47: /* reg: LOADU1(rc) */
	case 46: /* reg: LOADI1(rc) */
	case 45: /* reg: INDIRP2(addr) */
	case 44: /* reg: INDIRU2(addr) */
	case 43: /* reg: INDIRI2(addr) */
	case 42: /* reg: INDIRU1(addr) */
	case 41: /* reg: INDIRI1(addr) */
	case 32: /* mem: INDIRU1(addr) */
	case 31: /* mem: INDIRI1(addr) */
		kids[0] = LEFT_CHILD(p);
		break;
	case 301: /* stmt: LTF4(maf,maf) */
	case 300: /* stmt: LTU4(maf,maf) */
	case 299: /* stmt: LTI4(maf,maf) */
	case 298: /* stmt: LEF4(maf,maf) */
	case 297: /* stmt: LEU4(maf,maf) */
	case 296: /* stmt: LEI4(maf,maf) */
	case 295: /* stmt: GTF4(maf,maf) */
	case 294: /* stmt: GTU4(maf,maf) */
	case 293: /* stmt: GTI4(maf,maf) */
	case 292: /* stmt: GEF4(maf,maf) */
	case 291: /* stmt: GEU4(maf,maf) */
	case 290: /* stmt: GEI4(maf,maf) */
	case 289: /* stmt: NEF4(maf,maf) */
	case 288: /* stmt: NEU4(maf,maf) */
	case 287: /* stmt: NEI4(maf,maf) */
	case 286: /* stmt: EQF4(maf,maf) */
	case 285: /* stmt: EQU4(maf,maf) */
	case 284: /* stmt: EQI4(maf,maf) */
	case 259: /* reg: DIVF4(maf,maf) */
	case 258: /* reg: DIVU4(maf,maf) */
	case 257: /* reg: DIVI4(maf,maf) */
	case 256: /* reg: MULF4(maf,maf) */
	case 255: /* reg: MULU4(maf,maf) */
	case 254: /* reg: MULI4(maf,maf) */
	case 253: /* reg: SUBF4(maf,maf) */
	case 252: /* reg: SUBU4(maf,maf) */
	case 251: /* reg: SUBI4(maf,maf) */
	case 250: /* reg: ADDF4(maf,maf) */
	case 249: /* reg: ADDU4(maf,maf) */
	case 248: /* reg: ADDI4(maf,maf) */
	case 247: /* reg: BXORU4(maf,maf) */
	case 246: /* reg: BXORI4(maf,maf) */
	case 245: /* reg: BORU4(maf,maf) */
	case 244: /* reg: BORI4(maf,maf) */
	case 243: /* reg: BANDU4(maf,maf) */
	case 242: /* reg: BANDI4(maf,maf) */
	case 241: /* reg: MODU4(maf,maf) */
	case 240: /* reg: MODI4(maf,maf) */
	case 239: /* reg: RSHU4(reg,rc8) */
	case 238: /* reg: RSHI4(reg,rc8) */
	case 237: /* reg: LSHU4(reg,rc8) */
	case 236: /* reg: LSHI4(reg,rc8) */
	case 218: /* stmt: ASGNF4(addr,mrf) */
	case 217: /* stmt: ASGNU4(addr,mrf) */
	case 216: /* stmt: ASGNI4(addr,mrf) */
	case 184: /* stmt: LEU2(reg,rc) */
	case 183: /* stmt: LEI2(reg,rc) */
	case 182: /* stmt: GTU2(reg,rc) */
	case 181: /* stmt: GTI2(reg,rc) */
	case 180: /* stmt: LTU2(reg,rc) */
	case 179: /* stmt: LTI2(reg,rc) */
	case 178: /* stmt: GEU2(reg,rc) */
	case 177: /* stmt: GEI2(reg,rc) */
	case 176: /* stmt: NEU2(reg,rc) */
	case 175: /* stmt: NEI2(reg,rc) */
	case 174: /* stmt: EQU2(reg,rc) */
	case 173: /* stmt: EQI2(reg,rc) */
	case 172: /* stmt: LEU1(mem,con) */
	case 171: /* stmt: LEI1(mem,con) */
	case 170: /* stmt: GTU1(mem,con) */
	case 169: /* stmt: GTI1(mem,con) */
	case 168: /* stmt: LTU1(mem,con) */
	case 167: /* stmt: LTI1(mem,con) */
	case 166: /* stmt: GEU1(mem,con) */
	case 165: /* stmt: GEI1(mem,con) */
	case 164: /* stmt: NEU1(mem,con) */
	case 163: /* stmt: NEI1(mem,con) */
	case 162: /* stmt: EQU1(mem,con) */
	case 161: /* stmt: EQI1(mem,con) */
	case 160: /* stmt: LEU1(reg,mrc) */
	case 159: /* stmt: LEI1(reg,mrc) */
	case 158: /* stmt: GTU1(reg,mrc) */
	case 157: /* stmt: GTI1(reg,mrc) */
	case 156: /* stmt: LTU1(reg,mrc) */
	case 155: /* stmt: LTI1(reg,mrc) */
	case 154: /* stmt: GEU1(reg,mrc) */
	case 153: /* stmt: GEI1(reg,mrc) */
	case 152: /* stmt: NEU1(reg,mrc) */
	case 151: /* stmt: NEI1(reg,mrc) */
	case 150: /* stmt: EQU1(reg,mrc) */
	case 149: /* stmt: EQI1(reg,mrc) */
	case 137: /* stmt: ASGNP2(stk,rc) */
	case 136: /* stmt: ASGNU2(stk,rc) */
	case 135: /* stmt: ASGNI2(stk,rc) */
	case 134: /* stmt: ASGNU1(stk,rc) */
	case 133: /* stmt: ASGNI1(stk,rc) */
	case 132: /* stmt: ASGNP2(addr,rc) */
	case 131: /* stmt: ASGNU2(addr,rc) */
	case 130: /* stmt: ASGNI2(addr,rc) */
	case 129: /* stmt: ASGNU1(addr,rc) */
	case 128: /* stmt: ASGNI1(addr,rc) */
	case 100: /* reg: MODU2(reg,reg) */
	case 99: /* reg: MODU1(reg,reg) */
	case 98: /* reg: MODI2(reg,reg) */
	case 97: /* reg: MODI1(reg,reg) */
	case 96: /* reg: DIVU2(reg,reg) */
	case 95: /* reg: DIVU1(reg,reg) */
	case 94: /* reg: DIVI2(reg,reg) */
	case 93: /* reg: DIVI1(reg,reg) */
	case 92: /* reg: MULU2(reg,reg) */
	case 91: /* reg: MULU1(reg,reg) */
	case 90: /* reg: MULI2(reg,reg) */
	case 89: /* reg: MULI1(reg,reg) */
	case 88: /* reg: RSHU2(reg,rc8) */
	case 87: /* reg: RSHU1(reg,rc8) */
	case 86: /* reg: RSHI2(reg,rc8) */
	case 85: /* reg: RSHI1(reg,rc8) */
	case 84: /* reg: LSHU2(reg,rc8) */
	case 83: /* reg: LSHU1(reg,rc8) */
	case 82: /* reg: LSHI2(reg,rc8) */
	case 81: /* reg: LSHI1(reg,rc8) */
	case 72: /* reg: BXORU2(reg,rc) */
	case 71: /* reg: BXORI2(reg,rc) */
	case 70: /* reg: BXORU1(reg,mrc) */
	case 69: /* reg: BXORI1(reg,mrc) */
	case 68: /* reg: BORU2(reg,rc) */
	case 67: /* reg: BORI2(reg,rc) */
	case 66: /* reg: BORU1(reg,mrc) */
	case 65: /* reg: BORI1(reg,mrc) */
	case 64: /* reg: BANDU2(reg,rc) */
	case 63: /* reg: BANDI2(reg,rc) */
	case 62: /* reg: BANDU1(reg,mrc) */
	case 61: /* reg: BANDI1(reg,mrc) */
	case 60: /* reg: SUBP2(reg,rc) */
	case 59: /* reg: SUBU2(reg,rc) */
	case 58: /* reg: SUBI2(reg,rc) */
	case 57: /* reg: SUBU1(reg,mrc) */
	case 56: /* reg: SUBI1(reg,mrc) */
	case 55: /* reg: ADDP2(reg,rc) */
	case 54: /* reg: ADDU2(reg,rc) */
	case 53: /* reg: ADDI2(reg,rc) */
	case 52: /* reg: ADDU1(reg,mrc) */
	case 51: /* reg: ADDI1(reg,mrc) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = RIGHT_CHILD(p);
		break;
	case 283: /* stmt: ASGNU4(addr,BXORU4(maf,maf)) */
	case 282: /* stmt: ASGNI4(addr,BXORI4(maf,maf)) */
	case 281: /* stmt: ASGNU4(addr,BORU4(maf,maf)) */
	case 280: /* stmt: ASGNI4(addr,BORI4(maf,maf)) */
	case 279: /* stmt: ASGNU4(addr,BANDU4(maf,maf)) */
	case 278: /* stmt: ASGNI4(addr,BANDI4(maf,maf)) */
	case 277: /* stmt: ASGNU4(addr,MODU4(maf,maf)) */
	case 276: /* stmt: ASGNI4(addr,MODI4(maf,maf)) */
	case 275: /* stmt: ASGNF4(addr,DIVF4(maf,maf)) */
	case 274: /* stmt: ASGNU4(addr,DIVU4(maf,maf)) */
	case 273: /* stmt: ASGNI4(addr,DIVI4(maf,maf)) */
	case 272: /* stmt: ASGNF4(addr,MULF4(maf,maf)) */
	case 271: /* stmt: ASGNU4(addr,MULU4(maf,maf)) */
	case 270: /* stmt: ASGNI4(addr,MULI4(maf,maf)) */
	case 269: /* stmt: ASGNF4(addr,SUBF4(maf,maf)) */
	case 268: /* stmt: ASGNU4(addr,SUBU4(maf,maf)) */
	case 267: /* stmt: ASGNI4(addr,SUBI4(maf,maf)) */
	case 266: /* stmt: ASGNF4(addr,ADDF4(maf,maf)) */
	case 265: /* stmt: ASGNU4(addr,ADDU4(maf,maf)) */
	case 264: /* stmt: ASGNI4(addr,ADDI4(maf,maf)) */
	case 117: /* stmt: ASGNU1(addr,RSHU1(mem,con8)) */
	case 116: /* stmt: ASGNI1(addr,RSHI1(mem,con8)) */
	case 115: /* stmt: ASGNU1(addr,LSHU1(mem,con8)) */
	case 114: /* stmt: ASGNI1(addr,LSHI1(mem,con8)) */
	case 110: /* stmt: ASGNU1(addr,BXORU1(mem,rc)) */
	case 109: /* stmt: ASGNI1(addr,BXORI1(mem,rc)) */
	case 108: /* stmt: ASGNU1(addr,BORU1(mem,rc)) */
	case 107: /* stmt: ASGNI1(addr,BORI1(mem,rc)) */
	case 106: /* stmt: ASGNU1(addr,BANDU1(mem,rc)) */
	case 105: /* stmt: ASGNI1(addr,BANDI1(mem,rc)) */
	case 104: /* stmt: ASGNU1(addr,SUBU1(mem,rc)) */
	case 103: /* stmt: ASGNI1(addr,SUBI1(mem,rc)) */
	case 102: /* stmt: ASGNU1(addr,ADDU1(mem,rc)) */
	case 101: /* stmt: ASGNI1(addr,ADDI1(mem,rc)) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = LEFT_CHILD(RIGHT_CHILD(p));
		kids[2] = RIGHT_CHILD(RIGHT_CHILD(p));
		break;
	case 263: /* stmt: ASGNF4(addr,BCOMU4(maf)) */
	case 262: /* stmt: ASGNI4(addr,BCOMI4(maf)) */
	case 261: /* stmt: ASGNF4(addr,NEGF4(maf)) */
	case 260: /* stmt: ASGNI4(addr,NEGI4(maf)) */
	case 143: /* stmt: ASGNB(reg,INDIRB(reg)) */
	case 113: /* stmt: ASGNI1(addr,NEGI1(mem)) */
	case 112: /* stmt: ASGNU1(addr,BCOMU1(mem)) */
	case 111: /* stmt: ASGNI1(addr,BCOMI1(mem)) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = LEFT_CHILD(RIGHT_CHILD(p));
		break;
	case 144: /* stmt: ARGB(INDIRB(reg)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		break;
	default:
		fatal("_kids", "Bad rule number %d\n", eruleno);
	}
}


static void progbeg(int argc, char *argv[]) {
  int i;

  {
    union {
      char c;
      int i;
    } u;
    u.i = 0;
    u.c = 1;
    swap = ((int)(u.i == 1)) != IR->little_endian;
  }
  parseflags(argc, argv);
  rom_bank_str[0] = ram_bank_str[0] = 0;
  debug = 0;
  optimize = 0;
  comments = 0;
  for(i = 0; i < argc; i++) {
    if(strncmp(argv[i], "-BO", 3) == 0 || strncmp(argv[i], "-bo", 3) == 0) {
      if(atoi(argv[i] + 3) > 0)
	sprintf(rom_bank_str, "_%d", atoi(argv[i] + 3));
    } else if(strncmp(argv[i], "-BA", 3) == 0 || strncmp(argv[i], "-ba", 3) == 0) {
      sprintf(ram_bank_str, "_%d (OVR)", atoi(argv[i] + 3));
    } else if(strcmp(argv[i], "-debug") == 0 || strcmp(argv[i], "-DEBUG") == 0) {
      debug = 1;
      comments = 1;
      glevel = 2;
    } else if(strcmp(argv[i], "-optimize") == 0 || strcmp(argv[i], "-OPTIMIZE") == 0) {
      optimize = 1;
    } else if(strcmp(argv[i], "-comments") == 0 || strcmp(argv[i], "-COMMENTS") == 0) {
      comments = 1;
      glevel = 2;
    }
  }

  for(i = 0; i < NBREG_16; i++)
    /* Mask is 0b1001 = 9 */
    reg16[i] = mkreg(wreg[i], i, 9, IREG);

  for(i = 0; i < NBREG_8; i++)
    reg8[i] = mkreg(breg[i], i, 1, IREG);

  for(i = 0; i < NBREG_32; i++)
    reg32[i] = mkreg(xreg[i], i, 1, FREG);

  reg8w = mkwildcard(reg8);
  reg16w = mkwildcard(reg16);
  reg32w = mkwildcard(reg32);

#ifdef GAMEBOY
  tmask[IREG] = reg16[BC]->x.regnode->mask | reg16[DE]->x.regnode->mask;
#else
  tmask[IREG] = reg16[BC]->x.regnode->mask | reg16[DE]->x.regnode->mask | reg16[HL]->x.regnode->mask;
#endif
  vmask[IREG] = 0;
  tmask[FREG] = 0xFE;
  vmask[FREG] = 0;

#ifdef GAMEBOY
  print("\t;; File generated by GBDK 2.0, P. Felber, 1995-1998\n");
#else
  print("\t;; File generated by Z80DK 2.0, P. Felber, 1995-1998\n");
#endif
  print("\n");
#ifdef GAMEBOY
#else
  print("\t.globl\t.c_entry, .c_exit\n");
#endif
  print("\n");
  print("\t;; Ordering of segments for the linker\n");
  print("\t.area\t_CODE%s\n", rom_bank_str);
  print("\t.area\t_DATA%s\n", rom_bank_str);
  print("\t.area\t_LIT%s\n", rom_bank_str);
  print("\t.area\t_BSS%s\n", ram_bank_str);
  print("\n");

  cseg = 0;
  argstack = 0;
  if(optimize) {
    int i;
    for(i = 0; i < nb_rules; i++)
      rules[i] = 0;
  }
}

static Symbol rmap(int opk) {
  switch(optype(opk)) {
   case B: case P:
     return reg16w;
   case I: case U:
     if(opsize(opk) == 1)
       return reg8w;
     else if(opsize(opk) == 2)
       return reg16w;
     else
       return reg32w;
   case F:
     return reg32w;
   default:
     return 0;
  }
}

static void segment(int n) {
  if(n == cseg)
    return;
  generate();
  if(cseg == CODE)
    print("\t;; _CODE%s ends\n", rom_bank_str);
  else if(cseg == LIT)
    print("\t;; _LIT%s ends\n", rom_bank_str);
  else if(cseg == DATA)
    print("\t;; _DATA%s ends\n", rom_bank_str);
  else if(cseg == BSS)
    print("\t;; _BSS%s ends\n", ram_bank_str);
  cseg = n;
  if(cseg == CODE)
    print("\t.area\t_CODE%s\n", rom_bank_str);
  else if(cseg == LIT)
    print("\t.area\t_LIT%s\n", rom_bank_str);
  else if(cseg == DATA)
    print("\t.area\t_DATA%s\n", rom_bank_str);
  else if(cseg == BSS)
    print("\t.area\t_BSS%s\n", ram_bank_str);
}

static void progend(void) {
  segment(0);
  generate();
  if(optimize && comments) {
    int i;
    print("\t;; Optimization summary\n");
    for(i = 0; i < nb_rules; i++)
      print("\t;;   Rule %d: %d\n", i, rules[i]);
  }
  print("\t;; End of program\n");
}

#ifdef GAMEBOY
#define HARDWARE_REG_STR "__reg_"
#define HARDWARE_REG_LEN 6
#define HARDWARE_REG(addr) (!strncmp(addr, HARDWARE_REG_STR, HARDWARE_REG_LEN))
#endif

#define LEFT_NODE(p) LEFT_CHILD(p)
#define RIGHT_NODE(p) RIGHT_CHILD(p)

#define REG(p)  (getregnum(p))
#define LEFT_CHILD_REG(p)  (REG(LEFT_CHILD(p)))
#define RIGHT_CHILD_REG(p)  (REG(RIGHT_CHILD(p)))
#define LEFT_X_CHILD_REG(p)  (REG(LEFT_X_CHILD(p)))
#define RIGHT_X_CHILD_REG(p)  (REG(RIGHT_X_CHILD(p)))
#define LEFT_REG(p) \
	(p->kids[0]->x.registered ? LEFT_CHILD_REG(p) : \
	(p->x.kids[0] ? LEFT_X_CHILD_REG(p) : LEFT_CHILD_REG(p)))
#define RIGHT_REG(p) \
	(p->kids[1]->x.registered ? RIGHT_CHILD_REG(p) : \
	(p->x.kids[1] ? RIGHT_X_CHILD_REG(p) : RIGHT_CHILD_REG(p)))

#define VAL(p) \
	((generic(p->op) == CNST \
	|| specific(p->op) == ADDRG+P) ? \
	p->syms[0]->x.name : \
	p->syms[RX]->u.t.cse->syms[0]->x.name)
#define RIGHT_VAL(p) VAL(p->kids[1])
#define LEFT_VAL(p) VAL(p->kids[0])

#define IS_CONST(p) \
	(!p->x.registered \
	&& (generic(p->op) == CNST \
	|| (generic(p->op) == INDIR \
	&& p->kids[0]->op == VREG+P \
	&& p->syms[RX]->u.t.cse \
	&& generic(p->syms[RX]->u.t.cse->op) == CNST)))
#define IS_RIGHT_CONST(p) IS_CONST(p->kids[1])
#define IS_LEFT_CONST(p) IS_CONST(p->kids[0])

#define IS_ADDRGP(p) \
	(!p->x.registered \
	&& (specific(p->op) == ADDRG+P \
	|| (generic(p->op) == INDIR \
	&& p->kids[0]->op == VREG+P \
	&& p->syms[RX]->u.t.cse \
	&& specific(p->syms[RX]->u.t.cse->op) == ADDRG+P)))
#define IS_RIGHT_ADDRGP(p) IS_ADDRGP(p->kids[1])
#define IS_LEFT_ADDRGP(p) IS_ADDRGP(p->kids[0])

#define IS_INDIR(p) \
	(generic(p->op) == INDIR \
	&& !p->x.registered \
	&& p->kids[0]->op != VREG+P)
#define IS_RIGHT_INDIR(p) (IS_INDIR(p->kids[1]))
#define IS_LEFT_INDIR(p) (IS_INDIR(p->kids[0]))

#define IS_ADDRFP(p) \
	(specific(p->op) == ADDRF+P)
#define IS_RIGHT_ADDRFP(p) IS_ADDRFP(p->kids[1])
#define IS_LEFT_ADDRFP(p) IS_ADDRFP(p->kids[0])

#define IS_ADDRLP(p) \
	(specific(p->op) == ADDRL+P)
#define IS_RIGHT_ADDRLP(p) IS_ADDRLP(p->kids[1])
#define IS_LEFT_ADDRLP(p) IS_ADDRLP(p->kids[0])

static void target(Node p) {
  assert(p);
  switch(specific(p->op)) {

#ifdef GAMEBOY
   case CALL+I: case CALL+U: case CALL+P: case CALL+V: case CALL+F:
     if(specific(p->op) != CALL+V) {
       if(opsize(p->op) == 1) {
	 setreg(p, reg8[_E]);
       } else if(opsize(p->op) == 2) {
	 setreg(p, reg16[DE]);
       } else if(opsize(p->op) == 4) {
	 setreg(p, reg32[0]);
       }
     }
     if(!IS_LEFT_CONST(p))
       rtarget(p, 0, reg16[HL]);
     break;
   case RET+I: case RET+U: case RET+P: case RET+F:
     if(opsize(p->op) == 1) {
       rtarget(p, 0, reg8[_E]);
     } else if(opsize(p->op) == 2) {
       rtarget(p, 0, reg16[DE]);
     } else if(opsize(p->op) == 4) {
       rtarget(p, 0, reg32[0]);
     }
     break;
#else
   case ASGN+B:
     rtarget(p, 0, reg16[DE]);
     rtarget(p->kids[1], 0, reg16[HL]);
     break;
   case ARG+B:
     rtarget(p->kids[0], 0, reg16[DE]);
     break;
   case ARG+I: case ARG+U: case ARG+P: case ARG+F: {
     Symbol sym;
     Node call;
     int argno = 0;

     for(call = p->link; call && generic(call->op) != CALL; call = call->link)
       argno++;
     assert(call && call->kids[0] && call->kids[0]->syms[0]);
     sym = argreg(call->kids[0]->syms[0], p->op, p->link->op, argno);
     if(sym && opsize(p->op) <= 2)
       rtarget(p, 0, sym);
     break;
   }
   case CALL+I: case CALL+U: case CALL+P: case CALL+V: case CALL+F:
     if(specific(p->op) != CALL+V) {
       if(opsize(p->op) == 1) {
	 setreg(p, reg8[_L]);
       } else if(opsize(p->op) == 2) {
	 setreg(p, reg16[HL]);
       } else if(opsize(p->op) == 4) {
	 setreg(p, reg32[0]);
       }
     }
     if(!IS_LEFT_CONST(p))
       rtarget(p, 0, reg16[HL]);
     break;
   case RET+I: case RET+U: case RET+P: case RET+F:
     if(opsize(p->op) == 1) {
       rtarget(p, 0, reg8[_L]);
     } else if(opsize(p->op) == 2) {
       rtarget(p, 0, reg16[HL]);
     } else if(opsize(p->op) == 4) {
       rtarget(p, 0, reg32[0]);
     }
     break;
/*
  case ADDRF+P: case ADDRL+P:
  setreg(p, reg16[HL]);
  break;
*/
#endif
   case JUMP+V:
     if(!IS_LEFT_CONST(p))
       rtarget(p, 0, reg16[HL]);
     break;
/*
  case ADD+I: case ADD+U: case ADD+P:
  if(opsize(p->op) == 2 && !IS_RIGHT_CONST(p) && !IS_RIGHT_ADDRGP(p)) {
    setreg(p, reg16[HL]);
    rtarget(p, 0, reg16[HL]);
  }
  break;
*/
   case MUL+I: case MUL+U:
     if(opsize(p->op) == 1) {
       setreg(p, reg8[_E]);
       rtarget(p, 0, reg8[_C]);
       rtarget(p, 1, reg8[_E]);
     } else if(opsize(p->op) == 2) {
       setreg(p, reg16[DE]);
       rtarget(p, 0, reg16[BC]);
       rtarget(p, 1, reg16[DE]);
     }
     break;
   case DIV+I: case DIV+U:
     if(opsize(p->op) == 1) {
       setreg(p, reg8[_C]);
       rtarget(p, 0, reg8[_C]);
       rtarget(p, 1, reg8[_E]);
     } else if(opsize(p->op) == 2) {
       setreg(p, reg16[BC]);
       rtarget(p, 0, reg16[BC]);
       rtarget(p, 1, reg16[DE]);
     }
     break;
   case MOD+I: case MOD+U:
     if(opsize(p->op) == 1) {
       setreg(p, reg8[_E]);
       rtarget(p, 0, reg8[_C]);
       rtarget(p, 1, reg8[_E]);
     } else if(opsize(p->op) == 2) {
       setreg(p, reg16[DE]);
       rtarget(p, 0, reg16[BC]);
       rtarget(p, 1, reg16[DE]);
     }
     break;
   case LSH+I: case LSH+U: case RSH+I: case RSH+U:
     if(generic(RIGHT_NODE(p)->op) != CNST) {
       if(opsize(p->op) == 1) {
	 setreg(p, reg8[_C]);
	 rtarget(p, 0, reg8[_C]);
       } else if(opsize(p->op) == 2) {
	 setreg(p, reg16[BC]);
	 rtarget(p, 0, reg16[BC]);
       }
     }
     break;
   case CVF+I:
     if(opsize(LEFT_NODE(p)->op) == 1) {
       setreg(p, reg8[_E]);
     } else if(opsize(LEFT_NODE(p)->op) == 2) {
       setreg(p, reg16[DE]);
     }
     break;
   case CVI+I: case CVI+U: case CVU+I: case CVU+U: case CVP+U: case CVI+F:
     if(opsize(p->op) == 4) {
       if(opsize(LEFT_NODE(p)->op) == 1) {
	 rtarget(p, 0, reg8[_E]);
       } else if(opsize(LEFT_NODE(p)->op) == 2) {
	 rtarget(p, 0, reg16[DE]);
       }
     }
     break;
  }
}

static void clobber(Node p) {
  static int nstack = 0;

  assert(p);

  nstack = ckstack(p, nstack);
  assert(p->count > 0 || nstack == 0);

  switch (p->op) {
#ifdef GAMEBOY
#else
   case ASGN+B:
     spill(reg16[BC]->x.regnode->mask, IREG, p);
     break;
   case ARG+B:
     spill(reg16[BC]->x.regnode->mask | reg16[HL]->x.regnode->mask, IREG, p);
     break;
   case ARG+I: case ARG+U: case ARG+P: case ARG+F: {
     Symbol sym;
     Node call;
     int argno = 0;

     for(call = p->link; call && generic(call->op) != CALL; call = call->link)
       argno++;
     assert(call && call->kids[0] && call->kids[0]->syms[0]);
     sym = argreg(call->kids[0]->syms[0], p->op, p->link->op, argno);
     if(sym && opsize(p->op) == 4)
       spill(reg16[BC]->x.regnode->mask | reg16[DE]->x.regnode->mask, IREG, p);
     break;
   }
#endif
   case MUL+I: case MUL+U:
     if(opsize(p->op) == 1)
       spill((1<<B_) | (1<<D_), IREG, p);
     break;
   case DIV+I: case DIV+U:
     if(opsize(p->op) == 1)
       spill((1<<B_) | (1<<D_) | (1<<_E), IREG, p);
     else
       spill((1<<D_) | (1<<_E), IREG, p);
     break;
   case MOD+I: case MOD+U:
     if(opsize(p->op) == 1)
       spill((1<<B_) | (1<<_C) | (1<<D_), IREG, p);
     else
       spill((1<<B_) | (1<<_C), IREG, p);
     break;
   case LSH+I: case LSH+U:
   case RSH+I: case RSH+U:
     if(opsize(p->op) == 1)
       spill((1<<B_), IREG, p);
     break;
   case CVF+I:
     if(opsize(p->op) == 1)
       spill((1<<D_), IREG, p);
     break;
   case CVI+I:
   case CVI+U:
   case CVU+I:
   case CVU+U:
   case CVP+U:
   case CVI+F:
     if(opsize(LEFT_NODE(p)->op) == 1)
       spill((1<<D_), IREG, p);
     break;
  }
}

static int memop(Node p) {
  assert(p);
  assert(generic(p->op) == ASGN);
  assert(p->kids[0]);
  assert(p->kids[1]);
  if(generic(p->kids[1]->kids[0]->op) == INDIR
     && sametree(p->kids[0], p->kids[1]->kids[0]->kids[0]))
    return 1;
  else
    return LBURG_MAX;
}

static int sametree(Node p, Node q) {
  return p == NULL && q == NULL
    || p && q && p->op == q->op && p->syms[0] == q->syms[0]
    && sametree(p->kids[0], q->kids[0])
    && sametree(p->kids[1], q->kids[1]);
}

int move_r(Node p) {
  if(!IS_LEFT_CONST(p) && !IS_LEFT_ADDRGP(p))
    move(p);
  return 1;
}

static void debug_node(Node p) {
  int i, j;
  GENERATE________ comment(STR(" %s", opname(p->op)));
  GENERATE________ comment(STR(" #%d %s (%x)", p->x.inst, opname(p->op), (char *)p));
  for(i = 0; i < NELEMS(p->kids) && p->kids[i]; i++) {
    GENERATE________ comment(STR("  kids[%d]: #%d %s (%x)", i, p->kids[i]->x.inst, opname(p->kids[i]->op), (char *)p->kids[i]));
    for(j = 0; j < 3; j++) {
      if(p->kids[i]->syms[j] && p->kids[i]->syms[j]->x.name)
	GENERATE________ comment(STR("   syms[%d]: %s", j, p->kids[i]->syms[j]->x.name));
    }
  }
  for(i = 0; i < NELEMS(p->x.kids) && p->x.kids[i]; i++) {
    GENERATE________ comment(STR("  x.kids[%d]: #%d %s (%x)", i, p->x.kids[i]->x.inst, opname(p->x.kids[i]->op), (char *)p->x.kids[i]));
    for(j = 0; j < 3; j++) {
      if(p->x.kids[i]->syms[j] && p->x.kids[i]->syms[j]->x.name)
	GENERATE________ comment(STR("   syms[%d]: %s", j, p->x.kids[i]->syms[j]->x.name));
    }
  }
  for(i = 0; i < 3; i++) {
    if(p->syms[i] && p->syms[i]->x.name)
      GENERATE________ comment(STR("  syms[%d]: %s", i, p->syms[i]->x.name));
  }
  GENERATE________ comment(STR("Freemask is %x", freereg));
}

static void emit2(Node p) {
  freereg = p->x.freemask[IREG];

  if(debug)
    debug_node(p);

  switch(p->op) {
   case INDIR+I+sizeop(1):
   case INDIR+U+sizeop(1):
     if(LEFT_NODE(p)->op == VREG+P)
       break;
     {
       int dreg = REG(p);
       char *dst = breg[dreg];
       GENERATE________ comment(STR("Load %s", dst));
       if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	 int off = const_val(LEFT_NODE(p));
#ifdef GAMEBOY
	 GENERATE________ offsethl(off + framesize + argstack);
	 GENERATE________ op2("LD", dst, "(HL)");
#else
	 GENERATE________ op2("LD", dst, STR("%d(IX)", off));
#endif
       } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	 char *addr = LEFT_VAL(p);
#ifdef GAMEBOY
	 if(HARDWARE_REG(addr)) {
	   GENERATE________ op2("LDH", "A", STR("(%s)", addr + HARDWARE_REG_LEN));
	   GENERATE________ op2("LD", dst, "A");
	 } else
#endif
	 {
	   GENERATE________ op2("LD", "A", STR("(%s)", addr));
	   GENERATE________ op2("LD", dst, "A");
	 }
       } else {
	 int sreg = LEFT_REG(p);
	 if(sreg == HL) {
	   GENERATE________ op2("LD", dst, "(HL)");
	 } else {
	   GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	   GENERATE________ op2("LD", dst, "A");
	 }
       }
       break;
     }
   case INDIR+I+sizeop(2):
   case INDIR+U+sizeop(2):
   case INDIR+P+sizeop(2):
     if(LEFT_NODE(p)->op == VREG+P)
       break;
     {
       int dreg = REG(p);
       GENERATE________ comment(STR("Load %s", wreg[dreg]));
       if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	 int off = const_val(LEFT_NODE(p));
#ifdef GAMEBOY
	 GENERATE________ offsethl(off + framesize + argstack);
	 GENERATE________ op2("LD", "A", "(HL+)");
	 GENERATE________ op2("LD", hreg[dreg], "(HL)");
	 GENERATE________ op2("LD", lreg[dreg], "A");
#else
	 GENERATE________ op2("LD", lreg[dreg], STR("%d(IX)", off));
	 off++;
	 GENERATE________ op2("LD", hreg[dreg], STR("%d(IX)", off));
#endif
       } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	 char *addr = LEFT_VAL(p);
#ifdef GAMEBOY
	 if(HARDWARE_REG(addr)) {
	   GENERATE________ op2("LDH", "A", STR("(%s+1)", addr + HARDWARE_REG_LEN));
	   GENERATE________ op2("LD", hreg[dreg], "A");
	   GENERATE________ op2("LDH", "A", STR("(%s)", addr + HARDWARE_REG_LEN));
	   GENERATE________ op2("LD", lreg[dreg], "A");
	 } else {
	   GENERATE________ op2("LD", "A", STR("(%s+1)", addr));
	   GENERATE________ op2("LD", hreg[dreg], "A");
	   GENERATE________ op2("LD", "A", STR("(%s)", addr));
	   GENERATE________ op2("LD", lreg[dreg], "A");
	 }
#else
	 GENERATE________ op2("LD", wreg[dreg], STR("(%s)", addr));
#endif
       } else {
	 int sreg = LEFT_REG(p);
#ifdef GAMEBOY
	 if(sreg == HL) {
	   GENERATE________ op2("LD", "A", "(HL+)");
	   GENERATE________ op2("LD", hreg[dreg], "(HL)");
	   GENERATE________ op2("LD", lreg[dreg], "A");
	 } else {
	   GENERATE________ op2("LD", "H", hreg[sreg]);
	   GENERATE________ op2("LD", "L", lreg[sreg]);
	   GENERATE________ op2("LD", "A", "(HL+)");
	   GENERATE________ op2("LD", hreg[dreg], "(HL)");
	   GENERATE________ op2("LD", lreg[dreg], "A");
	 }
#else
	 if(sreg == HL) {
	   if(dreg == HL) {
	     GENERATE________ op2("LD", "A", "(HL)");
	     GENERATE________ op1("INC", "HL");
	     GENERATE________ op2("LD", "H", "(HL)");
	     GENERATE________ op2("LD", "L", "A");
	   } else {
	     GENERATE________ op2("LD", lreg[dreg], "(HL)");
	     GENERATE________ op1("INC", "HL");
	     GENERATE________ op2("LD", hreg[dreg], "(HL)");
	   }
	 } else {
	   GENERATE________ op1("PUSH", wreg[sreg]);
	   GENERATE________ op1("POP", "IY");
	   GENERATE________ op2("LD", hreg[dreg], "0(IY)");
	   GENERATE________ op2("LD", lreg[dreg], "1(IY)");
	 }
#endif
       }
       break;
     }
   case INDIR+I+sizeop(4):
   case INDIR+U+sizeop(4):
   case INDIR+F+sizeop(4):
     if(LEFT_NODE(p)->op == VREG+P)
       break;
     {
       int dreg = REG(p);
       char *dst = xreg[dreg];
       GENERATE________ comment(STR("Load %s", dst));
#ifdef GAMEBOY
       if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	 int off = const_val(LEFT_NODE(p));
	 GENERATE________ offsethl(off + framesize + argstack);
       } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	 GENERATE________ op2("LD", "HL", STR("#%s", LEFT_VAL(p)));
       } else {
	 int sreg = LEFT_REG(p);
	 GENERATE________ op2("LD", "H", hreg[sreg]);
	 GENERATE________ op2("LD", "L", lreg[sreg]);
       }
       GENERATE________ op2("LD", "A", "(HL+)");
       GENERATE________ op2("LD", STR("(%s)", dst), "A");
       GENERATE________ op2("LD", "A", "(HL+)");
       GENERATE________ op2("LD", STR("(%s+1)", dst), "A");
       GENERATE________ op2("LD", "A", "(HL+)");
       GENERATE________ op2("LD", STR("(%s+2)", dst), "A");
       GENERATE________ op2("LD", "A", "(HL)");
       GENERATE________ op2("LD", STR("(%s+3)", dst), "A");
#else
       if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	 int off = const_val(LEFT_NODE(p));
	 int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : HL)));
	 int free = tmp16(treg);
	 if(!free) {
	   GENERATE________ op0("EXX");
	 }
	 GENERATE________ op2("LD", hreg[treg], STR("%d(IX)", off+3));
	 GENERATE________ op2("LD", lreg[treg], STR("%d(IX)", off+2));
	 GENERATE________ op2("LD", STR("(%s+2)", src), wreg[treg]);
	 GENERATE________ op2("LD", hreg[treg], STR("%d(IX)", off+1));
	 GENERATE________ op2("LD", lreg[treg], STR("%d(IX)", off));
	 GENERATE________ op2("LD", STR("(%s)", src), wreg[treg]);
	 if(!free) {
	   GENERATE________ op0("EXX");
	 }
       } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	 char *addr = LEFT_VAL(p);
	 int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : IY)));
	 GENERATE________ op2("LD", wreg[treg], STR("(%s+2)", addr));
	 GENERATE________ op2("LD", STR("(%s+2)", src), wreg[treg]);
	 GENERATE________ op2("LD", wreg[treg], STR("(%s)", addr));
	 GENERATE________ op2("LD", STR("(%s)", src), wreg[treg]);
       } else {
	 int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : HL)));
	 int free = tmp16(treg);
	 GENERATE________ op1("PUSH", wreg[LEFT_REG(p)]);
	 GENERATE________ op1("POP", "IY");
	 if(!free) {
	   GENERATE________ op0("EXX");
	 }
	 GENERATE________ op2("LD", hreg[treg], "3(IY)");
	 GENERATE________ op2("LD", lreg[treg], "2(IY)");
	 GENERATE________ op2("LD", STR("(%s+2)", src), wreg[treg]);
	 GENERATE________ op2("LD", hreg[treg], "1(IY)");
	 GENERATE________ op2("LD", lreg[treg], "0(IY)");
	 GENERATE________ op2("LD", STR("(%s)", src), wreg[treg]);
	 if(!free) {
	   GENERATE________ op0("EXX");
	 }
       }
#endif
       break;
     }
   case ASGN+I+sizeop(1):
   case ASGN+U+sizeop(1):
     if(LEFT_NODE(p)->op == VREG+P)
       break;
     {
       if(LEFT_NODE(p) != NULL && RIGHT_NODE(p) != NULL &&
	  (generic(RIGHT_NODE(p)->op) == ADD ||
	   generic(RIGHT_NODE(p)->op) == SUB ||
	   generic(RIGHT_NODE(p)->op) == BAND ||
	   generic(RIGHT_NODE(p)->op) == BOR ||
	   generic(RIGHT_NODE(p)->op) == BXOR ||
	   generic(RIGHT_NODE(p)->op) == BCOM ||
	   generic(RIGHT_NODE(p)->op) == NEG ||
	   ((generic(RIGHT_NODE(p)->op) == LSH ||
	     generic(RIGHT_NODE(p)->op) == RSH) &&
	    IS_RIGHT_CONST(RIGHT_NODE(p)))) &&
	  RIGHT_NODE(p)->kids[0] != NULL &&
	  generic(RIGHT_NODE(p)->kids[0]->op) == INDIR &&
	  sametree(LEFT_NODE(p), RIGHT_NODE(p)->kids[0]->kids[0])) {
	 Node q = RIGHT_NODE(p);
	 int at = -1;
#ifdef GAMEBOY
	 int hw_reg = 0;
#endif
	 if(RIGHT_NODE(q) != NULL && IS_RIGHT_CONST(q)) {
	   int n = const_val(RIGHT_NODE(q));
#ifdef GAMEBOY
	   if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	     char *addr = LEFT_VAL(p);
	     if(HARDWARE_REG(addr)) {
	       hw_reg = 1;
	     }
	   }
	   if(!hw_reg &&
	      (((generic(q->op) == ADD || generic(q->op) == SUB) && (n > 0 && n <= 2)) ||
	       (generic(q->op) == LSH || generic(q->op) == RSH))) {
	     at = HL;
	   }
#else
	   if(((generic(q->op) == ADD || generic(q->op) == SUB) && (n > 0 && n <= 2)) ||
	      (generic(q->op) == LSH || generic(q->op) == RSH)) {
	     if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	       at = IX;
	     } else {
	       at = IY;
	     }
	   }
	   if(!(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p) ||
		IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) &&
	      LEFT_REG(p) == HL) {
	     at = HL;
	   }
#endif
	 }
	 if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	   int off = const_val(LEFT_NODE(p));
#ifdef GAMEBOY
	   GENERATE________ offsethl(off + framesize + argstack);
	   if(at != HL) {
	     GENERATE________ op2("LD", "A", "(HL)");
	   }
#else
	   if(at != IX) {
	     GENERATE________ op2("LD", "A", STR("%d(IX)", off));
	   }
#endif
	 } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	   char *addr = LEFT_VAL(p);
#ifdef GAMEBOY
	   if(hw_reg) {
	     GENERATE________ op2("LDH", "A", STR("(%s)", addr + HARDWARE_REG_LEN));
	   } else if(at == HL) {
	     GENERATE________ op2("LD", "HL", STR("#%s", addr));
	   }
#else
	   if(at = IY) {
	     GENERATE________ op2("LD", "IY", STR("#%s", addr));
	   }
#endif
	   else {
	     GENERATE________ op2("LD", "A", STR("(%s)", addr));
	   }
	 } else {
	   int sreg = LEFT_REG(p);
	   if(at == HL) {
	     if(sreg != HL) {
	       GENERATE________ op2("LD", "H", hreg[sreg]);
	       GENERATE________ op2("LD", "L", lreg[sreg]);
	     }
	   } else {
	     GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	   }
	 }
	 switch(generic(q->op)) {
	   /* One argument */
	  case BCOM:
	    GENERATE________ comment("Complement (mem)");
	    GENERATE________ op0("CPL");
	    break;
	  case NEG:
	    GENERATE________ comment("Negate (mem)");
#ifdef GAMEBOY
	    GENERATE________ op0("CPL");
	    GENERATE________ op1("INC", "A");
#else
	    GENERATE________ op0("NEG");
#endif
	    break;
	    /* Two arguments */
	  default:
	    if(IS_RIGHT_CONST(q)) {
	      char *val = RIGHT_VAL(q);
	      int n = const_val(RIGHT_NODE(q));
	      switch(generic(q->op)) {
	       case ADD:
	       case SUB:
		 GENERATE________ comment(STR("Add/sub %s to/from (mem)", val));
		 if(at == HL && n > 0) {
		   while(n--)
		     GENERATE________ op1(generic(q->op) == ADD ? "INC" : "DEC", "(HL)");
		 } else if(at == HL && n < 0) {
		   while(n++)
		     GENERATE________ op1(generic(q->op) == ADD ? "DEC" : "INC", "(HL)");
		 } else
#ifdef GAMEBOY
#else
		   if(at == IX && n > 0) {
		     int off = const_val(LEFT_NODE(p));
		     while(n--)
		       GENERATE________ op1(generic(q->op) == ADD ? "INC" : "DEC", STR("%d(IX)", off));
		   } else if(at == IX && n < 0) {
		     int off = const_val(LEFT_NODE(p));
		     while(n++)
		       GENERATE________ op1(generic(q->op) == ADD ? "DEC" : "INC", STR("%d(IX)", off));
		   } else if(at == IY && n > 0) {
		     int off = const_val(LEFT_NODE(p));
		     while(n--)
		       GENERATE________ op1(generic(q->op) == ADD ? "INC" : "DEC", STR("%d(IY)", off));
		   } else if(at == IY && n < 0) {
		     int off = const_val(LEFT_NODE(p));
		     while(n++)
		       GENERATE________ op1(generic(q->op) == ADD ? "DEC" : "INC", STR("%d(IY)", off));
		   } else
#endif
		   {
		     GENERATE________ op1(generic(q->op) == ADD ? "ADD" : "SUB", STR("#<%s", val));
		   }
		 break;
	       case BAND:
		 GENERATE________ comment(STR("And %s and (mem)", val));
		 GENERATE________ op1("AND", STR("#<%s", val));
		 break;
	       case BOR:
		 GENERATE________ comment(STR("Or %s and (mem)", val));
		 GENERATE________ op1("OR", STR("#<%s", val));
		 break;
	       case BXOR:
		 GENERATE________ comment(STR("Xor %s and (mem)", val));
		 GENERATE________ op1("XOR", STR("#<%s", val));
		 break;
	       case LSH:
	       case RSH:
		 GENERATE________ comment(STR("Left/right shift (mem) by %s", val));
		 if(at == HL) {
		   while(n--)
		     GENERATE________ op1(generic(q->op) == LSH ? "SLA" : (optype(q->op)==U ? "SRL" : "SRA"), "(HL)");
		 } else
#ifdef GAMEBOY
#else
		   if(at == IX) {
		     int off = const_val(LEFT_NODE(p));
		     while(n--)
		       GENERATE________ op1(generic(q->op) == LSH ? "SLA" : (optype(q->op)==U ? "SRL" : "SRA"), STR("%d(IX)", off));
		   } else if(at == IY) {
		     int off = const_val(LEFT_NODE(p));
		     while(n--)
		       GENERATE________ op1(generic(q->op) == LSH ? "SLA" : (optype(q->op)==U ? "SRL" : "SRA"), STR("%d(IY)", off));
		   } else
#endif
		   {
		     while(n--)
		       GENERATE________ op1(generic(q->op) == LSH ? "SLA" : (optype(q->op)==U ? "SRL" : "SRA"), "A");
		   }
		 break;
	      }
	    } else {
	      int sreg = RIGHT_REG(q);
	      switch(generic(q->op)) {
	       case ADD:
		 GENERATE________ comment(STR("Add %s to (mem)", breg[sreg]));
		 GENERATE________ op1("ADD", breg[sreg]);
		 break;
	       case SUB:
		 GENERATE________ comment(STR("Sub %s from (mem)", breg[sreg]));
		 GENERATE________ op1("SUB", breg[sreg]);
		 break;
	       case BAND:
		 GENERATE________ comment(STR("And %s and (mem)", breg[sreg]));
		 GENERATE________ op1("AND", breg[sreg]);
		 break;
	       case BOR:
		 GENERATE________ comment(STR("Or %s and (mem)", breg[sreg]));
		 GENERATE________ op1("OR", breg[sreg]);
		 break;
	       case BXOR:
		 GENERATE________ comment(STR("Xor %s and (mem)", breg[sreg]));
		 GENERATE________ op1("XOR", breg[sreg]);
		 break;
	      }
	    }
	 }
	 if(at < 0) {
	   if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	     char *addr = LEFT_VAL(p);
#ifdef GAMEBOY
	     if(hw_reg) {
	       GENERATE________ op2("LDH", STR("(%s)", addr + HARDWARE_REG_LEN), "A");
	     } else
#endif
	     {
	       GENERATE________ op2("LD", STR("(%s)", addr), "A");
	     }
	   } else if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
#ifdef GAMEBOY
	     GENERATE________ op2("LD", "(HL)", "A");
#else
	     int off = const_val(LEFT_NODE(p));
	     GENERATE________ op2("LD", STR("%d(IX)", off), "A");
#endif
	   } else {
	     int sreg = LEFT_REG(p);
	     GENERATE________ op2("LD", STR("(%s)", wreg[sreg]), "A");
	   }
	 }
       } else if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	 int off = const_val(LEFT_NODE(p));
#ifdef GAMEBOY
	 GENERATE________ offsethl(off + framesize + argstack);
#endif
	 if(IS_RIGHT_CONST(p)) {
	   char *val = RIGHT_VAL(p);
	   GENERATE________ comment(STR("Store %s", val));
#ifdef GAMEBOY
	   GENERATE________ op2("LD", "(HL)", STR("#<%s", val));
#else
	   GENERATE________ op2("LD", STR("%d(IX)", off), STR("#<%s", val));
#endif
	 } else {
	   int sreg = LEFT_REG(p);
	   GENERATE________ comment(STR("Store %s", breg[sreg]));
#ifdef GAMEBOY
	   GENERATE________ op2("LD", "(HL)", breg[sreg]);
#else
	   GENERATE________ op2("LD", STR("%d(IX)", off), breg[sreg]);
#endif
	 }
       } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	 char *addr = LEFT_VAL(p);
	 if(IS_RIGHT_CONST(p)) {
	   char *val = RIGHT_VAL(p);
	   GENERATE________ comment(STR("Store %s", val));
	   GENERATE________ op2("LD", "A", STR("#<%s", val));
	 } else {
	   int sreg = LEFT_REG(p);
	   GENERATE________ comment(STR("Store %s", breg[sreg]));
	   GENERATE________ op2("LD", "A", breg[sreg]);
	 }
#ifdef GAMEBOY
	 if(HARDWARE_REG(addr)) {
	   GENERATE________ op2("LDH", STR("(%s)", addr + HARDWARE_REG_LEN), "A");
	 } else
#endif
	 {
	   GENERATE________ op2("LD", STR("(%s)", addr), "A");
	 }
       } else {
	 int dreg = LEFT_REG(p);
	 if(IS_RIGHT_CONST(p)) {
	   char *val = RIGHT_VAL(p);
	   GENERATE________ comment(STR("Store %s", val));
	   if(dreg != HL) {
	     GENERATE________ op2("LD", "A", STR("#<%s", val));
	     GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	   } else {
	     GENERATE________ op2("LD", "(HL)", STR("#%s", val));
	   }
	 } else {
	   int sreg = RIGHT_REG(p);
	   GENERATE________ comment(STR("Store %s", breg[sreg]));
	   if(dreg != HL) {
	     GENERATE________ op2("LD", "A", breg[sreg]);
	     GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	   } else {
	     GENERATE________ op2("LD", "(HL)", breg[sreg]);
	   }
	 }
       }
       break;
     }
   case ASGN+I+sizeop(2):
   case ASGN+U+sizeop(2):
   case ASGN+P+sizeop(2):
     if(LEFT_NODE(p)->op == VREG+P)
       break;
     {
       if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	 int off = const_val(LEFT_NODE(p));
#ifdef GAMEBOY
	 GENERATE________ offsethl(off + framesize + argstack);
#endif
	 if(IS_RIGHT_CONST(p) || IS_RIGHT_ADDRGP(p)) {
	   char *val = RIGHT_VAL(p);
#ifdef GAMEBOY
	   GENERATE________ comment(STR("Store %s", val));
	   GENERATE________ op2("LD", "(HL)", STR("#<%s", val));
	   GENERATE________ op1("INC", "HL");
	   GENERATE________ op2("LD", "(HL)", STR("#>%s", val));
#else
	   if(IS_RIGHT_CONST(p) && const_val(RIGHT_NODE(p)) == 0) {
	     GENERATE________ op1("XOR", "A");
	     GENERATE________ op2("LD", STR("%d(IX)", off), "A");
	     off++;
	     GENERATE________ op2("LD", STR("%d(IX)", off), "A");
	   } else {
	     GENERATE________ op2("LD", STR("%d(IX)", off), STR("#<%s", val));
	     off++;
	     GENERATE________ op2("LD", STR("%d(IX)", off), STR("#>%s", val));
	   }
#endif
	 } else {
	   int sreg = RIGHT_REG(p);
	   GENERATE________ comment(STR("Store %s", wreg[sreg]));
#ifdef GAMEBOY
	   GENERATE________ op2("LD", "A", lreg[sreg]);
	   GENERATE________ op2("LD", "(HL+)", "A");
	   GENERATE________ op2("LD", "(HL)", hreg[sreg]);
#else
	   GENERATE________ op2("LD", STR("%d(IX)", off), lreg[sreg]);
	   off++;
	   GENERATE________ op2("LD", STR("%d(IX)", off), hreg[sreg]);
#endif
	 }
       } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	 char *addr = LEFT_VAL(p);
#ifdef GAMEBOY
	 if(IS_RIGHT_CONST(p) || IS_RIGHT_ADDRGP(p)) {
	   char *val = RIGHT_VAL(p);
	   GENERATE________ comment(STR("Store %s", val));
	   GENERATE________ op2("LD", "A", STR("#<%s", val));
	   if(HARDWARE_REG(addr)) {
	     GENERATE________ op2("LDH", STR("(%s)", addr + HARDWARE_REG_LEN), "A");
	     GENERATE________ op2("LD", "A", STR("#>%s", val));
	     GENERATE________ op2("LDH", STR("(%s+1)", addr + HARDWARE_REG_LEN), "A");
	   } else {
	     GENERATE________ op2("LD", STR("(%s)", addr), "A");
	     GENERATE________ op2("LD", "A", STR("#>%s", val));
	     GENERATE________ op2("LD", STR("(%s+1)", addr), "A");
	   }
#else
	   if(IS_RIGHT_CONST(p) || IS_RIGHT_ADDRGP(p)) {
	     char *val = RIGHT_VAL(p);
	     int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : HL)));
	     int free = tmp16(treg);
	     GENERATE________ comment(STR("Store %s", val));
	     if(!free) {
	       GENERATE________ op0("EXX");
	     }
	     GENERATE________ op2("LD", wreg[treg], STR("#%s", val));
	     GENERATE________ op2("LD", STR("(%s)", addr), wreg[treg]);
	     if(!free) {
	       GENERATE________ op0("EXX");
	     }
#endif
	   } else {
	     int sreg = RIGHT_REG(p);
#ifdef GAMEBOY
	     GENERATE________ comment(STR("Store %s", wreg[sreg]));
	     GENERATE________ op2("LD", "A", lreg[sreg]);
	     if(HARDWARE_REG(addr)) {
	       GENERATE________ op2("LDH", STR("(%s)", addr + HARDWARE_REG_LEN), "A");
	       GENERATE________ op2("LD", "A", hreg[sreg]);
	       GENERATE________ op2("LDH", STR("(%s+1)", addr + HARDWARE_REG_LEN), "A");
	     } else {
	       GENERATE________ op2("LD", STR("(%s)", addr), "A");
	       GENERATE________ op2("LD", "A", hreg[sreg]);
	       GENERATE________ op2("LD", STR("(%s+1)", addr), "A");
	     }
#else
	     GENERATE________ op2("LD", STR("(%s)", addr), wreg[sreg]);
#endif
	   }
	 } else {
	   int dreg = LEFT_REG(p);
	   if(IS_RIGHT_CONST(p) || IS_RIGHT_ADDRGP(p)) {
	     char *val = RIGHT_VAL(p);
	     GENERATE________ comment(STR("Store %s", val));
	     if(dreg == HL) {
	       GENERATE________ op2("LD", "(HL)", STR("#<%s", val));
	       GENERATE________ op1("INC", "HL");
	       GENERATE________ op2("LD", "(HL)", STR("#>%s", val));
	     } else {
	       GENERATE________ op2("LD", "A", STR("#<%s", val));
	       GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	       GENERATE________ op1("INC", wreg[dreg]);
	       GENERATE________ op2("LD", "A", STR("#>%s", val));
	       GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	     }
	   } else {
	     int sreg = RIGHT_REG(p);
	     GENERATE________ comment(STR("Store %s", wreg[sreg]));
	     if(dreg == HL) {
	       GENERATE________ op2("LD", "(HL)", lreg[sreg]);
	       GENERATE________ op1("INC", "HL");
	       GENERATE________ op2("LD", "(HL)", hreg[sreg]);
	     } else {
	       GENERATE________ op2("LD", "A", lreg[sreg]);
	       GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	       GENERATE________ op1("INC", wreg[dreg]);
	       GENERATE________ op2("LD", "A", hreg[sreg]);
	       GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	     }
	   }
	 }
	 break;
       }
      case ASGN+I+sizeop(4):
      case ASGN+U+sizeop(4):
      case ASGN+F+sizeop(4):
	if(LEFT_NODE(p)->op == VREG+P)
	  break;
	{
	  if(LEFT_NODE(p) != NULL && RIGHT_NODE(p) != NULL &&
	     (generic(RIGHT_NODE(p)->op) == NEG ||
	      generic(RIGHT_NODE(p)->op) == BCOM)) {
	    Node q = RIGHT_NODE(p);
	    GENERATE________ comment("Long/floating point neg");
	    save(BC);
	    save(DE);
#ifdef GAMEBOY
#else
	    save(HL);
#endif
	    load_32(LEFT_NODE(q));
	    if(generic(q->op) == NEG) {
	      GENERATE________ op1(".globl", optype((p)->op)==F ? ".fneg32" : ".neg32");
	      GENERATE________ op1("CALL", optype((p)->op)==F ? ".fneg32" : ".neg32");
	    } else if(generic(p->op) == BXOR) {
	      GENERATE________ op1(".globl", ".cpl32");
	      GENERATE________ op1("CALL", ".cpl32");
	    }
	    store_32(LEFT_NODE(p));
#ifdef GAMEBOY
#else
	    restore(HL);
#endif
	    restore(DE);
	    restore(BC);
	  } else if(LEFT_NODE(p) != NULL && RIGHT_NODE(p) != NULL &&
		    (generic(RIGHT_NODE(p)->op) == ADD ||
		     generic(RIGHT_NODE(p)->op) == SUB ||
		     generic(RIGHT_NODE(p)->op) == MUL ||
		     generic(RIGHT_NODE(p)->op) == DIV ||
		     generic(RIGHT_NODE(p)->op) == MOD ||
		     generic(RIGHT_NODE(p)->op) == BAND ||
		     generic(RIGHT_NODE(p)->op) == BOR ||
		     generic(RIGHT_NODE(p)->op) == BXOR)) {
	    Node q = RIGHT_NODE(p);
	    GENERATE________ comment("Long/floating point add/sub/mul/div");
	    save(BC);
	    save(DE);
#ifdef GAMEBOY
#else
	    save(HL);
#endif
	    load_32(RIGHT_NODE(q));
	    GENERATE________ op1("PUSH", "HL");
	    GENERATE________ op1("PUSH", "DE");
	    argstack += 4;
	    load_32(LEFT_NODE(q));
	    if(generic(q->op) == ADD) {
	      GENERATE________ op1(".globl", optype((p)->op)==F ? ".fadd32" : (optype((p)->op)==U ? ".addu32" : ".add32"));
	      GENERATE________ op1("CALL", optype((p)->op)==F ? ".fadd32" : (optype((p)->op)==U ? ".addu32" : ".add32"));
	    } else if(generic(q->op) == SUB) {
	      GENERATE________ op1(".globl", optype((p)->op)==F ? ".fsub32" : (optype((p)->op)==U ? ".subu32" : ".sub32"));
	      GENERATE________ op1("CALL", optype((p)->op)==F ? ".fsub32" : (optype((p)->op)==U ? ".subu32" : ".sub32"));
	    } else if(generic(q->op) == MUL) {
	      GENERATE________ op1(".globl", optype((p)->op)==F ? ".fmul32" : (optype((p)->op)==U ? ".mulu32" : ".mul32"));
	      GENERATE________ op1("CALL", optype((p)->op)==F ? ".fmul32" : (optype((p)->op)==U ? ".mulu32" : ".mul32"));
	    } else if(generic(q->op) == DIV) {
	      GENERATE________ op1(".globl", optype((p)->op)==F ? ".fdiv32" : (optype((p)->op)==U ? ".divu32" : ".div32"));
	      GENERATE________ op1("CALL", optype((p)->op)==F ? ".fdiv32" : (optype((p)->op)==U ? ".divu32" : ".div32"));
	    } else if(generic(p->op) == MOD) {
	      GENERATE________ op1(".globl", optype((p)->op)==U ? ".modu32" : ".mod32");
	      GENERATE________ op1("CALL", optype((p)->op)==U ? ".modu32" : ".mod32");
	    } else if(generic(p->op) == BAND) {
	      GENERATE________ op1(".globl", ".and32");
	      GENERATE________ op1("CALL", ".and32");
	    } else if(generic(p->op) == BOR) {
	      GENERATE________ op1(".globl", ".or32");
	      GENERATE________ op1("CALL", ".or32");
	    } else if(generic(p->op) == BXOR) {
	      GENERATE________ op1(".globl", ".xor32");
	      GENERATE________ op1("CALL", ".xor32");
	    }
	    argstack -= 4;
	    store_32(LEFT_NODE(p));
#ifdef GAMEBOY
#else
	    restore(HL);
#endif
	    restore(DE);
	    restore(BC);
	  } else {
	    char *src;
	    if(IS_RIGHT_INDIR(p) && IS_LEFT_ADDRGP(RIGHT_NODE(p)))
	      src = LEFT_VAL(RIGHT_NODE(p));
	    else
	      src = xreg[RIGHT_REG(p)];
	    GENERATE________ comment(STR("Store %s", src));
#ifdef GAMEBOY
	    if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	      int off = const_val(LEFT_NODE(p));
	      GENERATE________ offsethl(off + framesize + argstack);
	    } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	      GENERATE________ op2("LD", "HL", STR("#%s", LEFT_VAL(p)));
	    } else {
	      GENERATE________ op2("LD", "HL", STR("#%s", xreg[LEFT_REG(p)]));
	    }
	    GENERATE________ op2("LD", "A", STR("(%s)", src));
	    GENERATE________ op2("LD", "(HL+)", "A");
	    GENERATE________ op2("LD", "A", STR("(%s+1)", src));
	    GENERATE________ op2("LD", "(HL+)", "A");
	    GENERATE________ op2("LD", "A", STR("(%s+2)", src));
	    GENERATE________ op2("LD", "(HL+)", "A");
	    GENERATE________ op2("LD", "A", STR("(%s+3)", src));
	    GENERATE________ op2("LD", "(HL)", "A");
#else
	    if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
	      int off = const_val(LEFT_NODE(p));
	      int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : HL)));
	      int free = tmp16(treg);
	      if(!free) {
		GENERATE________ op0("EXX");
	      }
	      GENERATE________ op2("LD", wreg[treg], STR("(%s+2)", src));
	      GENERATE________ op2("LD", STR("%d(IX)", off+3), hreg[treg]);
	      GENERATE________ op2("LD", STR("%d(IX)", off+2), lreg[treg]);
	      GENERATE________ op2("LD", wreg[treg], STR("(%s)", src));
	      GENERATE________ op2("LD", STR("%d(IX)", off+1), hreg[treg]);
	      GENERATE________ op2("LD", STR("%d(IX)", off), lreg[treg]);
	      if(!free) {
		GENERATE________ op0("EXX");
	      }
	    } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	      char *addr = LEFT_VAL(p);
	      int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : IY)));
	      GENERATE________ op2("LD", wreg[treg], STR("(%s+2)", src));
	      GENERATE________ op2("LD", STR("(%s+2)", addr), wreg[treg]);
	      GENERATE________ op2("LD", wreg[treg], STR("(%s)", src));
	      GENERATE________ op2("LD", STR("(%s)", addr), wreg[treg]);
	    } else {
	      int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : HL)));
	      int free = tmp16(treg);
	      GENERATE________ op1("PUSH", wreg[LEFT_REG(p)]);
	      GENERATE________ op1("POP", "IY");
	      if(!free) {
		GENERATE________ op0("EXX");
	      }
	      GENERATE________ op2("LD", wreg[treg], STR("(%s+2)", src));
	      GENERATE________ op2("LD", "3(IY)", hreg[treg]);
	      GENERATE________ op2("LD", "2(IY)", lreg[treg]);
	      GENERATE________ op2("LD", wreg[treg], STR("(%s)", src));
	      GENERATE________ op2("LD", "1(IY)", hreg[treg]);
	      GENERATE________ op2("LD", "0(IY)", lreg[treg]);
	      if(!free) {
		GENERATE________ op0("EXX");
	      }
	    }
#endif
	  }
	  break;
	}
      case ASGN+B: {
	int sreg = RIGHT_REG(p);
	int dreg = LEFT_REG(p);
	int size = p->syms[0]->u.c.v.i;
	GENERATE________ comment(STR("Assign structure from %s to %s", wreg[sreg], wreg[dreg]));
#ifdef GAMEBOY
	if(size > 4) {
	  while(size > 0) {
	    int lab = genlabel(1);
	    GENERATE________ op2("LD", "H", STR("#%d", size > 0xFF ? 0 : size));
	    size -= (size > 0xFF ? 0x100 : size);
	    GENERATE________ label(STR(".L%d:", lab));
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	    GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	    GENERATE________ op1("INC", wreg[sreg]);
	    GENERATE________ op1("INC", wreg[dreg]);
	    GENERATE________ op1("DEC", "H");
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	  }
	} else {
	  while(size) {
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	    GENERATE________ op2("LD", STR("(%s)", wreg[dreg]), "A");
	    if(size > 1) {
	      GENERATE________ op1("INC", wreg[sreg]);
	      GENERATE________ op1("INC", wreg[dreg]);
	    }
	    size--;
	  }
	}
#else
	GENERATE________ op2("LD", "BC", STR("#%d", size));
	GENERATE________ op0("LDIR");
#endif
	break;
      }
      case CALL+I+sizeop(1):
      case CALL+U+sizeop(1):
      case CALL+I+sizeop(2):
      case CALL+U+sizeop(2):
      case CALL+P+sizeop(2):
      case CALL+I+sizeop(4):
      case CALL+U+sizeop(4):
      case CALL+F+sizeop(4):
      case CALL+V:
      case CALL+B: {
	int off = const_val(p);
	if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	  char *addr = LEFT_VAL(p);
	  GENERATE________ op1("CALL", addr);
	} else {
	  int sreg = LEFT_REG(p);
	  int lab1 = genlabel(1);
	  int lab2 = genlabel(1);
	  GENERATE________ op1("JR", STR(".L%d", lab2));
	  GENERATE________ label(STR(".L%d:", lab1));
	  GENERATE________ op1("JP", STR("(%s)", wreg[sreg]));
	  GENERATE________ label(STR(".L%d:", lab2));
	  GENERATE________ op1("CALL", STR(".L%d", lab1));
	}
#ifdef GAMEBOY
	offsetsp(off);
#endif
	argstack -= off;
	break;
      }
      case ARG+B: {
	int lab = genlabel(1);
	int sreg = LEFT_REG(p);
	int size = p->syms[0]->u.c.v.i;
	GENERATE________ comment("Structure argument");
#ifdef GAMEBOY
	if(size > 8)
	  fprintf(stderr, "WARNING: passing a big struct as value generates much code\n");
	GENERATE________ comment(STR("Pass structure parameter from %s", wreg[sreg]));
	GENERATE________ offsetsp(-size);
	GENERATE________ offsethl(0);
	while(size) {
	  GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	  GENERATE________ op2("LD", "(HL+)", "A");
	  if(size > 1) {
	    GENERATE________ op1("INC", wreg[sreg]);
	  }
	  size--;
	}
#else
	GENERATE________ op2("LD", "HL", STR("#-%d", size));
	GENERATE________ op2("ADD", "HL", "SP");
	GENERATE________ op2("LD", "SP", "HL");
	GENERATE________ op2("LD", "HL", "#0x0000");
	GENERATE________ op2("ADD", "HL", "SP");
	GENERATE________ op2("EX", "DE", "HL");
	GENERATE________ op0("LDIR");
#endif
	argstack += size;
	break;
      }
      case ARG+I+sizeop(1):
      case ARG+U+sizeop(1): {
#ifdef GAMEBOY
	GENERATE________ comment("8-bit argument");
	if(IS_LEFT_INDIR(p)) {
	  Node q = LEFT_NODE(p);
	  if(IS_LEFT_ADDRFP(q) || IS_LEFT_ADDRLP(q)) {
	    int off = const_val(LEFT_NODE(q));
	    GENERATE________ offsethl(off + framesize + argstack);
	    GENERATE________ op2("LD", "A", "(HL)");
	  } else if(IS_LEFT_CONST(q) || IS_LEFT_ADDRGP(q)) {
	    char *addr = LEFT_VAL(q);
	    if(HARDWARE_REG(addr)) {
	      GENERATE________ op2("LDH", "A", STR("(%s)", addr + HARDWARE_REG_LEN));
	    } else {
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	    }
	  } else {
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[LEFT_REG(q)]));
	  }
	} else if(IS_LEFT_CONST(p)) {
	  char *val = LEFT_VAL(p);
	  GENERATE________ op2("LD", "A", STR("#<%s", val));
	} else {
	  GENERATE________ op2("LD", "A", breg[LEFT_REG(p)]);
	}
	GENERATE________ op1("PUSH", "AF");
	GENERATE________ offsetsp(1);
	argstack++;
#else
	Symbol sym;
	Node call;
	int argno = 0;
	GENERATE________ comment("8-bit argument");
	for(call = p->link; call && generic(call->op) != CALL; call = call->link)
	  argno++;
	assert(call && call->kids[0] && call->kids[0]->syms[0]);
	sym = argreg(call->kids[0]->syms[0], p->op, p->link->op, argno);
	if(sym == NULL) {
	  if(IS_LEFT_INDIR(p)) {
	    Node q = LEFT_NODE(p);
	    if(IS_LEFT_ADDRFP(q) || IS_LEFT_ADDRLP(q)) {
	      int off = const_val(LEFT_NODE(q));
	      GENERATE________ op2("LD", "A", STR("%d(IX)", off));
	    } else if(IS_LEFT_CONST(q) || IS_LEFT_ADDRGP(q)) {
	      GENERATE________ op2("LD", "A", STR("(%s)", LEFT_VAL(q)));
	    } else {
	      GENERATE________ op2("LD", "A", STR("(%s)", wreg[LEFT_REG(q)]));
	    }
	  } else if(IS_LEFT_CONST(p)) {
	    char *val = LEFT_VAL(p);
	    GENERATE________ op2("LD", "A", STR("#<%s", val));
	  } else {
	    GENERATE________ op2("LD", "A", breg[LEFT_REG(p)]);
	  }
	  GENERATE________ op1("PUSH", "AF");
	  GENERATE________ offsetsp(1);
	  argstack++;
	} else {
	  char *dst = sym->x.name;
	  if(IS_LEFT_INDIR(p)) {
	    Node q = LEFT_NODE(p);
	    if(IS_LEFT_ADDRFP(q) || IS_LEFT_ADDRLP(q)) {
	      int off = const_val(LEFT_NODE(q));
	      GENERATE________ op2("LD", dst, STR("%d(IX)", off));
	    } else if(IS_LEFT_CONST(q) || IS_LEFT_ADDRGP(q)) {
	      GENERATE________ op2("LD", "A", STR("(%s)", LEFT_VAL(q)));
	      GENERATE________ op2("LD", dst, "A");
	    } else {
	      GENERATE________ op2("LD", "A", STR("(%s)", wreg[LEFT_REG(q)]));
	      GENERATE________ op2("LD", dst, "A");
	    }
	  } else if(IS_LEFT_CONST(p)) {
	    char *val = LEFT_VAL(p);
	    GENERATE________ op2("LD", dst, STR("#<%s", val));
	  } else {
	    GENERATE________ op2("LD", dst, breg[LEFT_REG(p)]);
	  }
	}
#endif
	break;
      }
      case ARG+I+sizeop(2):
      case ARG+U+sizeop(2):
      case ARG+P+sizeop(2): {
#ifdef GAMEBOY
	GENERATE________ comment("16-bit argument");
	GENERATE________ op1("PUSH", wreg[LEFT_REG(p)]);
	argstack += 2;
#else
	Symbol sym;
	Node call;
	int argno = 0;
	GENERATE________ comment("16-bit argument");
	for(call = p->link; call && generic(call->op) != CALL; call = call->link)
	  argno++;
	assert(call && call->kids[0] && call->kids[0]->syms[0]);
	sym = argreg(call->kids[0]->syms[0], p->op, p->link->op, argno);
	if(sym == NULL) {
	  GENERATE________ op1("PUSH", wreg[LEFT_REG(p)]);
	  argstack += 2;
	}
#endif
	break;
      }
      case ARG+I+sizeop(4):
      case ARG+U+sizeop(4):
      case ARG+F+sizeop(4): {
#ifdef GAMEBOY
	GENERATE________ comment("Long/floating point argument");
	if(IS_LEFT_INDIR(p)) {
	  Node q = LEFT_NODE(p);
	  if(IS_LEFT_ADDRFP(q) || IS_LEFT_ADDRLP(q)) {
	    int off = const_val(LEFT_NODE(q));
	    GENERATE________ offsethl(off + framesize + argstack + 3);
	  } else if(IS_LEFT_CONST(q) || IS_LEFT_ADDRGP(q)) {
	    GENERATE________ op2("LD", "HL", STR("#%s+3", LEFT_VAL(q)));
	  } else {
	    GENERATE________ op2("LD", "HL", "#0x0003");
	    GENERATE________ op2("ADD", "HL", wreg[LEFT_REG(q)]);
	  }
	} else {
	  GENERATE________ op2("LD", "HL", STR("#%s+3", xreg[LEFT_REG(p)]));
	}
	GENERATE________ op2("LD", "A", "(HL-)");
	GENERATE________ op1("PUSH", "AF");
	GENERATE________ op1("INC", "SP");
	GENERATE________ op2("LD", "A", "(HL-)");
	GENERATE________ op1("PUSH", "AF");
	GENERATE________ op1("INC", "SP");
	GENERATE________ op2("LD", "A", "(HL-)");
	GENERATE________ op2("LD", "L", "(HL)");
	GENERATE________ op2("LD", "H", "A");
	GENERATE________ op1("PUSH", "HL");
	argstack += 4;
#else
	Symbol sym;
	Node call;
	int argno = 0;
	GENERATE________ comment("Long/floating point argument");
	for(call = p->link; call && generic(call->op) != CALL; call = call->link)
	  argno++;
	assert(call && call->kids[0] && call->kids[0]->syms[0]);
	sym = argreg(call->kids[0]->syms[0], p->op, p->link->op, argno);
	if(sym == NULL) {
	  if(IS_LEFT_INDIR(p)) {
	    Node q = LEFT_NODE(p);
	    if(IS_LEFT_ADDRFP(q) || IS_LEFT_ADDRLP(q)) {
	      int off = const_val(LEFT_NODE(q));
	      GENERATE________ op1("PUSH", "HL");
	      GENERATE________ op2("LD", "H", STR("%d(IX)", off+3));
	      GENERATE________ op2("LD", "L", STR("%d(IX)", off+2));
	      GENERATE________ op2("EX", "(SP)", "HL");
	      GENERATE________ op1("PUSH", "HL");
	      GENERATE________ op2("LD", "H", STR("%d(IX)", off+1));
	      GENERATE________ op2("LD", "L", STR("%d(IX)", off));
	      GENERATE________ op2("EX", "(SP)", "HL");
	    } else if(IS_LEFT_CONST(q) || IS_LEFT_ADDRGP(q)) {
	      char *addr = LEFT_VAL(q);
	      int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : IY)));
	      GENERATE________ op2("LD", wreg[treg], STR("(%s+2)", addr));
	      GENERATE________ op1("PUSH", wreg[treg]);
	      GENERATE________ op2("LD", wreg[treg], STR("(%s)", addr));
	      GENERATE________ op1("PUSH", wreg[treg]);
	    } else {
	      GENERATE________ op1("PUSH", wreg[LEFT_REG(q)]);
	      GENERATE________ op1("POP", "IY");
	      GENERATE________ op1("PUSH", "HL");
	      GENERATE________ op2("LD", "H", STR("3(IY)"));
	      GENERATE________ op2("LD", "L", STR("2(IY)"));
	      GENERATE________ op2("EX", "(SP)", "HL");
	      GENERATE________ op1("PUSH", "HL");
	      GENERATE________ op2("LD", "H", STR("1(IY)"));
	      GENERATE________ op2("LD", "L", STR("0(IY)"));
	      GENERATE________ op2("EX", "(SP)", "HL");
	    }
	  } else {
	    int sreg = LEFT_REG(p);
	    int treg = tmp16(HL) ? HL : (tmp16(DE) ? DE : ((tmp16(BC) ? BC : IY)));
	    GENERATE________ op2("LD", wreg[treg], STR("(%s+2)", xreg[sreg]));
	    GENERATE________ op1("PUSH", wreg[treg]);
	    GENERATE________ op2("LD", wreg[treg], STR("(%s)", xreg[sreg]));
	    GENERATE________ op1("PUSH", wreg[treg]);
	  }
	  argstack += 4;
	} else {
	  if(IS_LEFT_INDIR(p)) {
	    Node q = LEFT_NODE(p);
	    if(IS_LEFT_ADDRFP(q) || IS_LEFT_ADDRLP(q)) {
	      int off = const_val(LEFT_NODE(q));
	      GENERATE________ op2("LD", "B", STR("%d(IX)", off+3));
	      GENERATE________ op2("LD", "C", STR("%d(IX)", off+2));
	      GENERATE________ op2("LD", "D", STR("%d(IX)", off+1));
	      GENERATE________ op2("LD", "E", STR("%d(IX)", off));
	    } else if(IS_LEFT_CONST(q) || IS_LEFT_ADDRGP(q)) {
	      char *addr = LEFT_VAL(q);
	      GENERATE________ op2("LD", "BC", STR("(%s+2)", addr));
	      GENERATE________ op2("LD", "DE", STR("(%s)", addr));
	    } else {
	      GENERATE________ op1("PUSH", wreg[LEFT_REG(q)]);
	      GENERATE________ op1("POP", "IY");
	      GENERATE________ op2("LD", "B", "3(IY)");
	      GENERATE________ op2("LD", "C", "2(IY)");
	      GENERATE________ op2("LD", "D", "1(IY)");
	      GENERATE________ op2("LD", "E", "0(IY)");
	    }
	  } else {
	    int sreg = LEFT_REG(p);
	    GENERATE________ op2("LD", "BC", STR("(%s+2)", xreg[sreg]));
	    GENERATE________ op2("LD", "DE", STR("(%s)", xreg[sreg]));
	  }
	}
#endif
	break;
      }
      case CVI+I+sizeop(2):
      case CVI+U+sizeop(2):
      case CVU+I+sizeop(2):
      case CVU+U+sizeop(2):
      case CVU+P+sizeop(2):
      case CVP+U+sizeop(2): {
	int dreg = REG(p);
	int sreg = LEFT_REG(p);
	if(opsize(LEFT_NODE(p)->op) == 1) {
	  GENERATE________ comment("Convert (un)signed 8-bit to 16-bit");
	  if(optype(LEFT_NODE(p)->op) == I) {
	    GENERATE________ op2("LD", "A", breg[sreg]);
	    GENERATE________ op2("LD", lreg[dreg], "A");
	    GENERATE________ op0("RLCA");
	    GENERATE________ op1("SBC", "A");
	    GENERATE________ op2("LD", hreg[dreg], "A");
	  } else {
	    GENERATE________ op2("LD", lreg[dreg], breg[sreg]);
	    GENERATE________ op2("LD", hreg[dreg], "#0");
	  }
	} else if(opsize(LEFT_NODE(p)->op) == 2) {
	  GENERATE________ comment("Convert (un)signed 16-bit to 16-bit");
	  GENERATE________ op2("LD", hreg[dreg], hreg[sreg]);
	  GENERATE________ op2("LD", lreg[dreg], lreg[sreg]);
	} else if(opsize(LEFT_NODE(p)->op) == 4) {
	  GENERATE________ comment("Convert (un)signed 32-bit to 16-bit");
#ifdef GAMEBOY
	  GENERATE________ op2("LD", "A", STR("(%s+1)", xreg[sreg]));
	  GENERATE________ op2("LD", hreg[dreg], "A");
	  GENERATE________ op2("LD", "A", STR("(%s)", xreg[sreg]));
	  GENERATE________ op2("LD", lreg[dreg], "A");
#else
	  GENERATE________ op2("LD", wreg[dreg], STR("(%s)", xreg[sreg]));
#endif
	}
	break;
      }
      case CVI+I+sizeop(4):
      case CVI+U+sizeop(4):
      case CVU+I+sizeop(4):
      case CVU+U+sizeop(4):
      case CVP+U+sizeop(4): {
#ifdef GAMEBOY
#else
	save(HL);
#endif
	if(opsize(LEFT_NODE(p)->op) == 1) {
	  GENERATE________ comment("Convert (un)signed 8-bit to 32-bit");
	  if(optype(LEFT_NODE(p)->op) == I) {
	    GENERATE________ op2("LD", "A", "E");
	    GENERATE________ op0("RLCA");
	    GENERATE________ op1("SBC", "A");
	    GENERATE________ op2("LD", "D", "A");
	    GENERATE________ op2("LD", "L", "A");
	    GENERATE________ op2("LD", "H", "A");
	  } else {
	    GENERATE________ op2("LD", "HL", "#0x0000");
	    GENERATE________ op2("LD", "D", "L");
	  }
	} else if(opsize(LEFT_NODE(p)->op) == 2) {
	  if(optype(LEFT_NODE(p)->op) == I) {
	    GENERATE________ op2("LD", "A", "D");
	    GENERATE________ op0("RLCA");
	    GENERATE________ op1("SBC", "A");
	    GENERATE________ op2("LD", "L", "A");
	    GENERATE________ op2("LD", "H", "A");
	  } else {
	    GENERATE________ comment("Convert (un)signed 16-bit to 32-bit");
	    GENERATE________ op2("LD", "HL", "#0x0000");
	  }
	} else if(opsize(LEFT_NODE(p)->op) == 4) {
	  GENERATE________ 	comment("Convert (un)signed 32-bit to 32-bit");
	  save(DE);
	  load_32(LEFT_NODE(p));
	}
	store_32(p);
	if(opsize(LEFT_NODE(p)->op) == 4) {
	  restore(DE);
	}
#ifdef GAMEBOY
#else
	restore(HL);
#endif
	break;
      }
      case CVI+F+sizeop(4): {
	int sreg = LEFT_REG(p);
	GENERATE________ comment("Convert int to floating point");
	save(BC);
	if(opsize(LEFT_NODE(p)->op) == 4) {
	  save(DE);
	  load_32(LEFT_NODE(p));
	}
	if(opsize(LEFT_NODE(p)->op) == 1) {
	  GENERATE________ op1(".globl", ".fi8tof32");
	  GENERATE________ op1("CALL", ".fi8tof32");
	} else if(opsize(LEFT_NODE(p)->op) == 2) {
	  GENERATE________ op1(".globl", ".fi16tof32");
	  GENERATE________ op1("CALL", ".fi16tof32");
	} else if(opsize(LEFT_NODE(p)->op) == 4) {
	  GENERATE________ op1(".globl", ".fi32tof32");
	  GENERATE________ op1("CALL", ".fi32tof32");
	}
	store_32(p);
	if(opsize(LEFT_NODE(p)->op) == 4) {
	  restore(DE);
	}
	restore(BC);
	break;
      }
      case CVF+I+sizeop(1):
      case CVF+I+sizeop(2):
      case CVF+I+sizeop(4): {
	int dreg = REG(p);
	GENERATE________ comment("Convert floating point to int");
	save(BC);
	if(opsize(p->op) == 4) {
	  save(DE);
	}
#ifdef GAMEBOY
#else
	save(HL);
#endif
	load_32(LEFT_NODE(p));
	GENERATE________ op1(".globl", ".ff32toi32");
	GENERATE________ op1("CALL", ".ff32toi32");
	if(opsize(p->op) == 4) {
	  store_32(p);
	}
#ifdef GAMEBOY
#else
	restore(HL);
#endif
	if(opsize(p->op) == 4) {
	  restore(DE);
	}
	restore(BC);
	break;
      }
      case CVF+F+sizeop(4): {
	int sreg = LEFT_REG(p);
	int dreg = REG(p);
	GENERATE________ comment("Convert floating point to floating point");
	if(sreg != dreg) {
	  load_32(LEFT_NODE(p));
	  store_32(p);
	}
	break;
      }
      case CNST+I+sizeop(1):
      case CNST+U+sizeop(1): {
	int dreg = REG(p);
	char *val = VAL(p);
	GENERATE________ comment(STR("Load %s into %s", val, breg[dreg]));
	GENERATE________ op2("LD", breg[dreg], STR("#<%s", val));
	break;
      }
      case CNST+I+sizeop(2):
      case CNST+U+sizeop(2):
      case CNST+P+sizeop(2):
      case ADDRG+P+sizeop(2): {
	int dreg = REG(p);
	char *dst = wreg[dreg];
	char *val = VAL(p);
	GENERATE________ comment(STR("Load %s into %s", val, dst));
	GENERATE________ op2("LD", dst, STR("#%s", val));
	break;
      }
      case ADDRF+P+sizeop(2):
      case ADDRL+P+sizeop(2): {
	int dreg = REG(p);
	char *dst = wreg[dreg];
	int off = const_val(p);
	GENERATE________ comment(STR("Load local address into %s", dst));
#ifdef GAMEBOY
	GENERATE________ offsethl(off + framesize + argstack);
	GENERATE________ op2("LD", hreg[dreg], "H");
	GENERATE________ op2("LD", lreg[dreg], "L");
#else
	if(dreg == HL) {
	  GENERATE________ op2("LD", "HL", STR("#%d", off + framesize + argstack));
	  GENERATE________ op2("ADD", "HL", "SP");
	} else if(tmp16(HL)) {
	  GENERATE________ op2("LD", "HL", STR("#%d", off + framesize + argstack));
	  GENERATE________ op2("ADD", "HL", "SP");
	  if(dreg == DE) {
	    GENERATE________ op2("EX", "DE", "HL");
	  } else {
	    GENERATE________ op2("LD", hreg[dreg], "H");
	    GENERATE________ op2("LD", lreg[dreg], "L");
	  }
	} else {
	  GENERATE________ op2("LD", "IY", STR("#%d", off + framesize + argstack));
	  GENERATE________ op2("ADD", "IY", "SP");
	  GENERATE________ op1("PUSH", "IY");
	  GENERATE________ op1("POP", wreg[dreg]);
	}
#endif
	break;
      }
      case LOAD+I+sizeop(1):
      case LOAD+U+sizeop(1): {
	int dreg = REG(p);
	if(IS_LEFT_CONST(p)) {
	  char *val = LEFT_VAL(p);
	  GENERATE________ comment(STR("Load %s into %s", val, breg[dreg]));
	  GENERATE________ op2("LD", breg[dreg], STR("#<%s", val));
	} else {
	  int sreg = LEFT_REG(p);
	  if(opsize(LEFT_NODE(p)->op) == 1) {
	    GENERATE________ comment(STR("Load %s into %s", breg[sreg], breg[dreg]));
	    GENERATE________ op2("LD", breg[dreg], breg[sreg]);
	  } else if(opsize(LEFT_NODE(p)->op) == 2) {
	    GENERATE________ comment(STR("Load %s into %s", lreg[sreg], breg[dreg]));
	    GENERATE________ op2("LD", breg[dreg], lreg[sreg]);
	  } else if(opsize(LEFT_NODE(p)->op) == 4) {
	    GENERATE________ comment(STR("Load %s into %s", xreg[sreg], breg[dreg]));
	    GENERATE________ op2("LD", "A", STR("(%s)", xreg[sreg]));
	    GENERATE________ op2("LD", breg[dreg], "A");
	  }
	}
	break;
      }
      case LOAD+I+sizeop(2):
      case LOAD+U+sizeop(2):
      case LOAD+P+sizeop(2): {
	int dreg = REG(p);
	if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	  char *dst = wreg[dreg];
	  char *val = LEFT_VAL(p);
	  GENERATE________ comment(STR("Load %s into %s", val, dst));
	  GENERATE________ op2("LD", dst, STR("#%s", val));
	} else {
	  int sreg = LEFT_REG(p);
	  GENERATE________ comment(STR("Load %s into %s", wreg[sreg], wreg[dreg]));
#ifdef GAMEBOY
	  GENERATE________ op2("LD", hreg[dreg], hreg[sreg]);
	  GENERATE________ op2("LD", lreg[dreg], lreg[sreg]);
#else
	  if(sreg == IX || sreg == IY || dreg == IX || dreg == IY) {
	    GENERATE________ op1("PUSH", wreg[sreg]);
	    GENERATE________ op1("POP", wreg[dreg]);
	  } else {
	    GENERATE________ op2("LD", hreg[dreg], hreg[sreg]);
	    GENERATE________ op2("LD", lreg[dreg], lreg[sreg]);
	  }
#endif
	}
	break;
      }
      case ADD+I+sizeop(1):
      case ADD+U+sizeop(1):
      case SUB+I+sizeop(1):
      case SUB+U+sizeop(1): {
	int dreg = REG(p);
	int sreg1 = LEFT_REG(p);
	if(IS_RIGHT_INDIR(p) &&
	   (IS_LEFT_ADDRFP(RIGHT_NODE(p)) || IS_LEFT_ADDRLP(RIGHT_NODE(p)))) {
	  int off = const_val(LEFT_NODE(RIGHT_NODE(p)));
	  GENERATE________ comment(STR("Add/sub (mem) to/from %s into %s", breg[sreg1], breg[dreg]));
#ifdef GAMEBOY
	  GENERATE________ offsethl(off + framesize + argstack);
	  GENERATE________ op2("LD", "A", breg[sreg1]);
	  GENERATE________ op1(generic(p->op) == ADD ? "ADD" : "SUB", "(HL)");
#else
	  GENERATE________ op2("LD", "A", breg[sreg1]);
	  GENERATE________ op1(generic(p->op) == ADD ? "ADD" : "SUB", STR("%d(IX)", off));
#endif
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else if(IS_RIGHT_INDIR(p) &&
		  (IS_LEFT_CONST(RIGHT_NODE(p)) || IS_LEFT_ADDRGP(RIGHT_NODE(p)))) {
	  char *addr = LEFT_VAL(RIGHT_NODE(p));
	  GENERATE________ comment(STR("Add/sub (mem) to/from %s into %s", breg[sreg1], breg[dreg]));
	  GENERATE________ op2("LD", "A", STR("(%s)", addr));
	  GENERATE________ op1(generic(p->op) == ADD ? "ADD" : "SUB", breg[sreg1]);
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  int n = const_val(RIGHT_NODE(p));
	  GENERATE________ comment(STR("Add/sub %s to %s/from into %s", val, breg[sreg1], breg[dreg]));
	  if(n > 0 && n <= 2) {
	    if(sreg1 != dreg)
	      GENERATE________ op2("LD", breg[dreg], breg[sreg1]);
	    while(n--)
	      GENERATE________ op1(generic(p->op) == ADD ? "INC" : "DEC", breg[dreg]);
	  } else if(n >= -2 && n < 0) {
	    if(sreg1 != dreg)
	      GENERATE________ op2("LD", breg[dreg], breg[sreg1]);
	    while(n++)
	      GENERATE________ op1(generic(p->op) == ADD ? "DEC" : "INC", breg[dreg]);
	  } else {
	    GENERATE________ op2("LD", "A", breg[sreg1]);
	    GENERATE________ op1(generic(p->op) == ADD ? "ADD" : "SUB", STR("#<%s", val));
	    GENERATE________ op2("LD", breg[dreg], "A");
	  }
	} else {
	  int sreg2 = RIGHT_REG(p);
	  if(IS_RIGHT_INDIR(p)) {
	    GENERATE________ comment(STR("Add/sub (mem) to/from %s into %s", breg[sreg1], breg[dreg]));
	    if(generic(p->op) == ADD) {
	      GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
	      GENERATE________ op1("ADD", breg[sreg1]);
	      GENERATE________ op2("LD", breg[dreg], "A");
	    } else if(sreg2 == HL) {
	      GENERATE________ op2("LD", "A", breg[sreg1]);
	      GENERATE________ op1("SUB", "(HL)");
	      GENERATE________ op2("LD", breg[dreg], "A");
	    } else {
	      GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
	      GENERATE________ op1("SUB", breg[sreg1]);
#ifdef GAMEBOY
	      GENERATE________ op0("CPL");
	      GENERATE________ op1("INC", "A");
#else
	      GENERATE________ op0("NEG");
#endif
	      GENERATE________ op2("LD", breg[dreg], "A");
	    }
	  } else {
	    GENERATE________ comment(STR("Add/sub %s to/from %s into %s", breg[sreg2], breg[sreg1], breg[dreg]));
	    GENERATE________ op2("LD", "A", breg[sreg1]);
	    GENERATE________ op1(generic(p->op) == ADD ? "ADD" : "SUB", breg[sreg2]);
	    GENERATE________ op2("LD", breg[dreg], "A");
	  }
	}
	break;
      }
      case ADD+P+sizeop(2):
	if(opsize(LEFT_NODE(p)->op) == 1) {
	  int dreg = REG(p);
	  int sreg1 = LEFT_REG(p);
	  if(IS_RIGHT_CONST(p) || IS_RIGHT_ADDRGP(p)) {
	    char *val = RIGHT_VAL(p);
	    GENERATE________ comment(STR("Add %s to %s into %s", val, breg[sreg1], wreg[dreg]));
	    GENERATE________ op2("LD", "A", breg[sreg1]);
	    GENERATE________ op1("ADD", STR("#<%s", val));
	    GENERATE________ op2("LD", lreg[dreg], "A");
	    GENERATE________ op2("LD", "A", "#0x00 ; LD does not change flags!!!");
	    GENERATE________ op1("ADC", STR("#>%s", val));
	    GENERATE________ op2("LD", hreg[dreg], "A");
	  } else {
	    int sreg2 = RIGHT_REG(p);
	    assert(opsize(RIGHT_NODE(p)->op) == 2);
	    GENERATE________ comment(STR("Add %s to %s into %s", wreg[sreg2], breg[sreg1], wreg[dreg]));
	    if(dreg == HL && sreg2 != HL) {
	      GENERATE________ op2("LD", "H", "#0x00");
	      if(sreg1 != HL)
		GENERATE________ op2("LD", "L", breg[sreg1]);
	      GENERATE________ op2("ADD", "HL", wreg[sreg2]);
	    } else {
	      GENERATE________ op2("LD", "A", breg[sreg1]);
	      GENERATE________ op1("ADD", lreg[sreg2]);
	      GENERATE________ op2("LD", lreg[dreg], "A");
	      GENERATE________ op2("LD", "A", "#0x00 ; LD does not change flags!!!");
	      GENERATE________ op1("ADC", hreg[sreg2]);
	      GENERATE________ op2("LD", hreg[dreg], "A");
	    }
	  }
	  break;
	}
      case ADD+I+sizeop(2):
      case ADD+U+sizeop(2):
      case SUB+I+sizeop(2):
      case SUB+U+sizeop(2):
      case SUB+P+sizeop(2): {
	int dreg = REG(p);
	int sreg1 = LEFT_REG(p);
	assert(opsize(LEFT_NODE(p)->op) == 2);
	if(IS_RIGHT_CONST(p) || IS_RIGHT_ADDRGP(p)) {
	  char *val = RIGHT_VAL(p);
	  int n = IS_RIGHT_CONST(p) ? const_val(RIGHT_NODE(p)) : 0;
	  GENERATE________ comment(STR("Add/sub %s to/from %s into %s", val, wreg[sreg1], wreg[dreg]));
	  if(n > 0 && n <= 3) {
	    if(sreg1 != dreg) {
	      GENERATE________ op2("LD", hreg[dreg], hreg[sreg1]);
	      GENERATE________ op2("LD", lreg[dreg], lreg[sreg1]);
	    }
	    while(n--)
	      GENERATE________ op1(generic(p->op) == ADD ? "INC" : "DEC", wreg[dreg]);
	  } else if(n >= -3 && n < 0) {
	    if(sreg1 != dreg) {
	      GENERATE________ op2("LD", hreg[dreg], hreg[sreg1]);
	      GENERATE________ op2("LD", lreg[dreg], lreg[sreg1]);
	    }
	    while(n++)
	      GENERATE________ op1(generic(p->op) == ADD ? "DEC" : "INC", wreg[dreg]);
	  } else {
	    int treg = tmp16(DE) ? DE : tmp16(BC) ? BC : -1;
	    if(treg >= 0 && generic(p->op) == ADD && sreg1 == HL && dreg == HL) {
	      GENERATE________ op2("LD", wreg[treg], STR("#%s", val));
	      GENERATE________ op2("ADD", "HL", wreg[treg]);
	    } else if(generic(p->op) == ADD && sreg1 != HL && dreg == HL) {
	      GENERATE________ op2("LD", "HL", STR("#%s", val));
	      GENERATE________ op2("ADD", "HL", wreg[sreg1]);
#ifdef GAMEBOY
	    } else if(generic(p->op) == ADD) {
	      GENERATE________ op2("LD", "HL", STR("#%s", val));
	      GENERATE________ op2("ADD", "HL", wreg[sreg1]);
	      GENERATE________ op2("LD", hreg[dreg], "H");
	      GENERATE________ op2("LD", lreg[dreg], "L");
#else
	    } else if(treg >= 0 && generic(p->op) == SUB && sreg1 == HL && dreg == HL) {
	      GENERATE________ op2("LD", wreg[treg], STR("#%s", val));
	      GENERATE________ op1("OR", "A");
	      GENERATE________ op2("SBC", "HL", wreg[sreg1]);
#endif
	    } else {
	      GENERATE________ op2("LD", "A", lreg[sreg1]);
	      GENERATE________ op1(generic(p->op) == ADD ? "ADD" : "SUB", STR("#<%s", val));
	      GENERATE________ op2("LD", lreg[dreg], "A");
	      GENERATE________ op2("LD", "A", hreg[sreg1]);
	      GENERATE________ op1(generic(p->op) == ADD ? "ADC" : "SBC", STR("#>%s", val));
	      GENERATE________ op2("LD", hreg[dreg], "A");
	    }
	  }
	} else {
	  int sreg2 = RIGHT_REG(p);
	  assert(opsize(RIGHT_NODE(p)->op) == 2);
	  GENERATE________ comment(STR("Add/sub %s to/from %s into %s", wreg[sreg2], wreg[sreg1], wreg[dreg]));
	  if(generic(p->op) == ADD && dreg == HL) {
	    if(sreg2 == HL) {
	      GENERATE________ op2("ADD", "HL", wreg[sreg1]);
	    } else if(sreg1 == HL) {
	      GENERATE________ op2("ADD", "HL", wreg[sreg2]);
	    } else {
	      GENERATE________ op2("LD", "H", hreg[sreg1]);
	      GENERATE________ op2("LD", "L", lreg[sreg1]);
	      GENERATE________ op2("ADD", "HL", wreg[sreg2]);
	    }
#ifdef GAMEBOY
#else
	  } else if(generic(p->op) == SUB && sreg1 == HL && dreg == HL) {
	    GENERATE________ op1("OR", "A");
	    GENERATE________ op2("SBC", "HL", wreg[sreg2]);
	  } else if(generic(p->op) == SUB && sreg1 == DE && dreg == DE) {
	    GENERATE________ op2("EX", "DE", "HL");
	    if(sreg2 == HL)
	      sreg2 = DE;
	    else if(sreg2 == DE)
	      sreg2 = HL;
	    GENERATE________ op1("OR", "A");
	    GENERATE________ op2("SBC", "HL", wreg[sreg2]);
	    GENERATE________ op2("EX", "DE", "HL");
#endif
	  } else {
	    GENERATE________ op2("LD", "A", lreg[sreg1]);
	    GENERATE________ op1(generic(p->op) == ADD ? "ADD" : "SUB", lreg[sreg2]);
	    GENERATE________ op2("LD", lreg[dreg], "A");
	    GENERATE________ op2("LD", "A", hreg[sreg1]);
	    GENERATE________ op1(generic(p->op) == ADD ? "ADC" : "SBC", hreg[sreg2]);
	    GENERATE________ op2("LD", hreg[dreg], "A");
	  }
	}
	break;
      }
      case BAND+I+sizeop(1):
      case BAND+U+sizeop(1):
      case BOR+I+sizeop(1):
      case BOR+U+sizeop(1):
      case BXOR+I+sizeop(1):
      case BXOR+U+sizeop(1): {
	int dreg = REG(p);
	int sreg1 = LEFT_REG(p);
	if(IS_RIGHT_INDIR(p) &&
	   (IS_LEFT_ADDRFP(RIGHT_NODE(p)) || IS_LEFT_ADDRLP(RIGHT_NODE(p)))) {
	  int off = const_val(LEFT_NODE(RIGHT_NODE(p)));
	  GENERATE________ comment(STR("And (mem) and %s into %s", breg[sreg1], breg[dreg]));
#ifdef GAMEBOY
	  GENERATE________ offsethl(off + framesize + argstack);
	  GENERATE________ op2("LD", "A", "(HL)");
#else
	  GENERATE________ op2("LD", "A", STR("%d(IX)", off));
#endif
	  if(generic(p->op) == BAND) {
	    GENERATE________ op1("AND", breg[sreg1]);
	  } else if(generic(p->op) == BOR) {
	    GENERATE________ op1("OR", breg[sreg1]);
	  } else if(generic(p->op) == BXOR) {
	    GENERATE________ op1("XOR", breg[sreg1]);
	  }
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else if(IS_RIGHT_INDIR(p) &&
		  (IS_LEFT_CONST(RIGHT_NODE(p)) || IS_LEFT_ADDRGP(RIGHT_NODE(p)))) {
	  char *addr = LEFT_VAL(RIGHT_NODE(p));
	  GENERATE________ comment(STR("And (mem) and %s into %s", breg[sreg1], breg[dreg]));
	  GENERATE________ op2("LD", "A", STR("(%s)", addr));
	  if(generic(p->op) == BAND) {
	    GENERATE________ op1("AND", breg[sreg1]);
	  } else if(generic(p->op) == BOR) {
	    GENERATE________ op1("OR", breg[sreg1]);
	  } else if(generic(p->op) == BXOR) {
	    GENERATE________ op1("XOR", breg[sreg1]);
	  }
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  GENERATE________ comment(STR("And %s and %s into %s", val, breg[sreg1], breg[dreg]));
	  GENERATE________ op2("LD", "A", STR("#<%s", val));
	  if(generic(p->op) == BAND) {
	    GENERATE________ op1("AND", breg[sreg1]);
	  } else if(generic(p->op) == BOR) {
	    GENERATE________ op1("OR", breg[sreg1]);
	  } else if(generic(p->op) == BXOR) {
	    GENERATE________ op1("XOR", breg[sreg1]);
	  }
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else {
	  int sreg2 = RIGHT_REG(p);
	  if(IS_RIGHT_INDIR(p)) {
	    GENERATE________ comment(STR("And (mem) and %s into %s", breg[sreg1], breg[dreg]));
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
	    if(generic(p->op) == BAND) {
	      GENERATE________ op1("AND", breg[sreg1]);
	    } else if(generic(p->op) == BOR) {
	      GENERATE________ op1("OR", breg[sreg1]);
	    } else if(generic(p->op) == BXOR) {
	      GENERATE________ op1("XOR", breg[sreg1]);
	    }
	    GENERATE________ op2("LD", breg[dreg], "A");
	  } else {
	    GENERATE________ comment(STR("And %s and %s into %s", breg[sreg2], breg[sreg1], breg[dreg]));
	    GENERATE________ op2("LD", "A", breg[sreg2]);
	    if(generic(p->op) == BAND) {
	      GENERATE________ op1("AND", breg[sreg1]);
	    } else if(generic(p->op) == BOR) {
	      GENERATE________ op1("OR", breg[sreg1]);
	    } else if(generic(p->op) == BXOR) {
	      GENERATE________ op1("XOR", breg[sreg1]);
	    }
	    GENERATE________ op2("LD", breg[dreg], "A");
	  }
	}
	break;
      }
      case BAND+I+sizeop(2):
      case BAND+U+sizeop(2):
      case BOR+I+sizeop(2):
      case BOR+U+sizeop(2):
      case BXOR+I+sizeop(2):
      case BXOR+U+sizeop(2): {
	int dreg = REG(p);
	int sreg1 = LEFT_REG(p);
	assert(opsize(LEFT_NODE(p)->op) == 2);
	if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  GENERATE________ comment(STR("And %s and %s into %s", val, wreg[sreg1], wreg[dreg]));
	  GENERATE________ op2("LD", "A", STR("#<%s", val));
	  if(generic(p->op) == BAND) {
	    GENERATE________ op1("AND", lreg[sreg1]);
	  } else if(generic(p->op) == BOR) {
	    GENERATE________ op1("OR", lreg[sreg1]);
	  } else if(generic(p->op) == BXOR) {
	    GENERATE________ op1("XOR", lreg[sreg1]);
	  }
	  GENERATE________ op2("LD", lreg[dreg], "A");
	  GENERATE________ op2("LD", "A", STR("#>%s", val));
	  if(generic(p->op) == BAND) {
	    GENERATE________ op1("AND", hreg[sreg1]);
	  } else if(generic(p->op) == BOR) {
	    GENERATE________ op1("OR", hreg[sreg1]);
	  } else if(generic(p->op) == BXOR) {
	    GENERATE________ op1("XOR", hreg[sreg1]);
	  }
	  GENERATE________ op2("LD", hreg[dreg], "A");
	} else {
	  int sreg2 = RIGHT_REG(p);
	  assert(opsize(RIGHT_NODE(p)->op) == 2);
	  GENERATE________ comment(STR("And %s and %s into %s", wreg[sreg2], wreg[sreg1], wreg[dreg]));
	  GENERATE________ op2("LD", "A", lreg[sreg2]);
	  if(generic(p->op) == BAND) {
	    GENERATE________ op1("AND", lreg[sreg1]);
	  } else if(generic(p->op) == BOR) {
	    GENERATE________ op1("OR", lreg[sreg1]);
	  } else if(generic(p->op) == BXOR) {
	    GENERATE________ op1("XOR", lreg[sreg1]);
	  }
	  GENERATE________ op2("LD", lreg[dreg], "A");
	  GENERATE________ op2("LD", "A", hreg[sreg2]);
	  if(generic(p->op) == BAND) {
	    GENERATE________ op1("AND", hreg[sreg1]);
	  } else if(generic(p->op) == BOR) {
	    GENERATE________ op1("OR", hreg[sreg1]);
	  } else if(generic(p->op) == BXOR) {
	    GENERATE________ op1("XOR", hreg[sreg1]);
	  }
	  GENERATE________ op2("LD", hreg[dreg], "A");
	}
	break;
      }
      case BCOM+I+sizeop(1):
      case BCOM+U+sizeop(1): {
	int dreg = REG(p);
	if(IS_LEFT_INDIR(p) &&
	   (IS_LEFT_ADDRFP(LEFT_NODE(p)) || IS_LEFT_ADDRLP(LEFT_NODE(p)))) {
	  int off = const_val(LEFT_NODE(LEFT_NODE(p)));
	  GENERATE________ comment(STR("Complement (mem) into %s", breg[dreg]));
#ifdef GAMEBOY
	  GENERATE________ offsethl(off + framesize + argstack);
	  GENERATE________ op2("LD", "A", "(HL)");
#else
	  GENERATE________ op2("LD", "A", STR("%d(IX)", off));
#endif
	  GENERATE________ op0("CPL");
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else if(IS_LEFT_INDIR(p) &&
		  (IS_LEFT_CONST(LEFT_NODE(p)) || IS_LEFT_ADDRGP(LEFT_NODE(p)))) {
	  char *addr = LEFT_VAL(LEFT_NODE(p));
	  GENERATE________ comment(STR("Complement (mem) into %s", breg[dreg]));
	  GENERATE________ op2("LD", "A", STR("(%s)", addr));
	  GENERATE________ op0("CPL");
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else {
	  int sreg = LEFT_REG(p);
	  if(IS_LEFT_INDIR(p)) {
	    GENERATE________ comment(STR("Complement (mem) into %s", breg[dreg]));
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	    GENERATE________ op0("CPL");
	    GENERATE________ op2("LD", breg[dreg], "A");
	  } else {
	    GENERATE________ comment(STR("Complement %s into %s", breg[sreg], breg[dreg]));
	    GENERATE________ op2("LD", "A", breg[sreg]);
	    GENERATE________ op0("CPL");
	    GENERATE________ op2("LD", breg[dreg], "A");
	  }
	}
	break;
      }
      case BCOM+I+sizeop(2):
      case BCOM+U+sizeop(2): {
	int dreg = REG(p);
	int sreg = LEFT_REG(p);
	GENERATE________ comment(STR("Complement %s into %s", wreg[dreg], wreg[sreg]));
	GENERATE________ op2("LD", "A", lreg[sreg]);
	GENERATE________ op0("CPL");
	GENERATE________ op2("LD", lreg[dreg], "A");
	GENERATE________ op2("LD", "A", hreg[sreg]);
	GENERATE________ op0("CPL");
	GENERATE________ op2("LD", hreg[dreg], "A");
	break;
      }
      case NEG+I+sizeop(1): {
	int dreg = REG(p);
	if(IS_LEFT_INDIR(p) &&
	   (IS_LEFT_ADDRFP(LEFT_NODE(p)) || IS_LEFT_ADDRLP(LEFT_NODE(p)))) {
	  int off = const_val(LEFT_NODE(LEFT_NODE(p)));
	  GENERATE________ comment(STR("Negate (mem) into %s", breg[dreg]));
#ifdef GAMEBOY
	  GENERATE________ offsethl(off + framesize + argstack);
	  GENERATE________ op1("XOR", "A");
	  GENERATE________ op1("SUB", "(HL)");
#else
	  GENERATE________ op1("XOR", "A");
	  GENERATE________ op1("SUB", STR("%d(IX)", off));
#endif
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else if(IS_LEFT_INDIR(p) &&
		  (IS_LEFT_CONST(LEFT_NODE(p)) || IS_LEFT_ADDRGP(LEFT_NODE(p)))) {
	  char *addr = LEFT_VAL(LEFT_NODE(p));
	  GENERATE________ comment(STR("Negate (mem) into %s", breg[dreg]));
	  GENERATE________ op2("LD", "A", STR("(%s)", addr));
#ifdef GAMEBOY
	  GENERATE________ op0("CPL");
	  GENERATE________ op1("INC", "A");
#else
	  GENERATE________ op0("NEG");
#endif
	  GENERATE________ op2("LD", breg[dreg], "A");
	} else {
	  int sreg = LEFT_REG(p);
	  if(IS_LEFT_INDIR(p)) {
	    GENERATE________ comment(STR("Negate (mem) into %s", breg[dreg]));
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
#ifdef GAMEBOY
	    GENERATE________ op0("CPL");
	    GENERATE________ op1("INC", "A");
#else
	    GENERATE________ op0("NEG");
#endif
	    GENERATE________ op2("LD", breg[dreg], "A");
	  } else {
	    GENERATE________ comment(STR("Negate %s into %s", breg[sreg], breg[dreg]));
	    GENERATE________ op1("XOR", "A");
	    GENERATE________ op1("SUB", breg[sreg]);
	    GENERATE________ op2("LD", breg[dreg], "A");
	  }
	}
	break;
      }
      case NEG+I+sizeop(2): {
	int dreg = REG(p);
	int sreg = LEFT_REG(p);
	GENERATE________ comment(STR("Negate %s into %s", wreg[dreg], wreg[sreg]));
#ifdef GAMEBOY
#else
	if(sreg != HL && dreg == HL) {
	  GENERATE________ op2("LD", "HL", "#0x0000");
	  GENERATE________ op1("OR", "A");
	  GENERATE________ op1("SBC", wreg[sreg]);
	} else
#endif
	{
	  GENERATE________ op1("XOR", "A");
	  GENERATE________ op1("SUB", lreg[sreg]);
	  GENERATE________ op2("LD", lreg[dreg], "A");
	  GENERATE________ op2("LD", "A", "#0x00 ; LD does not change flags!!!");
	  GENERATE________ op1("SBC", hreg[sreg]);
	  GENERATE________ op2("LD", hreg[dreg], "A");
	}
	break;
      }
      case BCOM+I+sizeop(4):
      case BCOM+U+sizeop(4):
      case NEG+I+sizeop(4):
      case NEG+U+sizeop(4):
      case NEG+F+sizeop(4): {
	GENERATE________ comment("Long/floating point negate/complement");
	save(BC);
	save(DE);
#ifdef GAMEBOY
#else
	save(HL);
#endif
	load_32(LEFT_NODE(p));
	if(generic(p->op) == NEG) {
	  GENERATE________ op1(".globl", optype((p)->op)==F ? ".fneg32" : ".neg32");
	  GENERATE________ op1("CALL", optype((p)->op)==F ? ".fneg32" : ".neg32");
	} else if(generic(p->op) == BXOR) {
	  GENERATE________ op1(".globl", ".cpl32");
	  GENERATE________ op1("CALL", ".cpl32");
	}
	store_32(p);
#ifdef GAMEBOY
#else
	restore(HL);
#endif
	restore(DE);
	restore(BC);
	break;
      }
      case EQ+I+sizeop(1):
      case EQ+U+sizeop(1):
      case NE+I+sizeop(1):
      case NE+U+sizeop(1): {
	char *jmp = p->syms[0]->x.name;
	if(IS_LEFT_INDIR(p)) {
	  char *val;
	  assert(IS_RIGHT_CONST(p));
	  val = RIGHT_VAL(p);
	  if(IS_LEFT_ADDRFP(LEFT_NODE(p)) || IS_LEFT_ADDRLP(LEFT_NODE(p))) {
	    int off = const_val(LEFT_NODE(LEFT_NODE(p)));
	    GENERATE________ comment(STR("Compare EQ/NE (mem) and %s", val));
#ifdef GAMEBOY
	    GENERATE________ offsethl(off + framesize + argstack);
	    GENERATE________ op2("LD", "A", STR("#<%s", val));
	    GENERATE________ op1("CP", "(HL)");
#else
	    GENERATE________ op2("LD", "A", STR("#<%s", val));
	    GENERATE________ op1("CP", STR("%d(IX)", off));
#endif
	    GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  } else if(IS_LEFT_CONST(LEFT_NODE(p)) || IS_LEFT_ADDRGP(LEFT_NODE(p))) {
	    char *addr = LEFT_VAL(LEFT_NODE(p));
	    GENERATE________ comment(STR("Compare EQ/NE (mem) and %s", val));
	    GENERATE________ op2("LD", "A", STR("(%s)", addr));
	    GENERATE________ op1("CP", STR("#<%s", val));
	    GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  } else {
	    int sreg = LEFT_REG(p);
	    GENERATE________ comment(STR("Compare EQ/NE (mem) and %s", val));
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	    GENERATE________ op1("CP", STR("#<%s", val));
	    GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  }
	} else {
	  int sreg = LEFT_REG(p);
	  if(IS_RIGHT_INDIR(p) &&
	     (IS_LEFT_ADDRFP(RIGHT_NODE(p)) || IS_LEFT_ADDRLP(RIGHT_NODE(p)))) {
	    int off = const_val(LEFT_NODE(RIGHT_NODE(p)));
	    GENERATE________ comment(STR("Compare EQ/NE %s and (mem)", breg[sreg]));
#ifdef GAMEBOY
	    GENERATE________ offsethl(off + framesize + argstack);
	    GENERATE________ op2("LD", "A", breg[sreg]);
	    GENERATE________ op1("CP", "(HL)");
#else
	    GENERATE________ op2("LD", "A", breg[sreg]);
	    GENERATE________ op1("CP", STR("%d(IX)", off));
#endif
	    GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  } else if(IS_RIGHT_INDIR(p) &&
		    (IS_LEFT_CONST(RIGHT_NODE(p)) || IS_LEFT_ADDRGP(RIGHT_NODE(p)))) {
	    char *addr = LEFT_VAL(RIGHT_NODE(p));
	    GENERATE________ comment(STR("Compare EQ/NE %s and (mem)", breg[sreg]));
	    GENERATE________ op2("LD", "A", STR("(%s)", addr));
	    GENERATE________ op1("CP", breg[sreg]);
	    GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  } else if(IS_RIGHT_CONST(p)) {
	    char *val = RIGHT_VAL(p);
	    GENERATE________ comment(STR("Compare EQ/NE %s and %s", breg[sreg], val));
	    GENERATE________ op2("LD", "A", breg[sreg]);
	    GENERATE________ op1("CP", STR("#<%s", val));
	    GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  } else {
	    int sreg2 = RIGHT_REG(p);
	    if(IS_RIGHT_INDIR(p)) {
	      GENERATE________ comment(STR("Compare EQ/NE %s and (mem)", breg[sreg]));
	      GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
	      GENERATE________ op1("CP", breg[sreg]);
	      GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	    } else {
	      GENERATE________ comment(STR("Compare EQ/NE %s and %s", breg[sreg], breg[sreg2]));
	      GENERATE________ op2("LD", "A", breg[sreg2]);
	      GENERATE________ op1("CP", breg[sreg]);
	      GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	    }
	  }
	}
	break;
      }
      case EQ+I+sizeop(2):
      case EQ+U+sizeop(2):
      case NE+I+sizeop(2):
      case NE+U+sizeop(2): {
	int lab = genlabel(1);
	int sreg = LEFT_REG(p);
	char *src1 = wreg[sreg];
	char *jmp = p->syms[0]->x.name;
	assert(opsize(LEFT_NODE(p)->op) == 2);
	if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  GENERATE________ comment(STR("Compare EQ/NE %s and %s", src1, val));
	  GENERATE________ op2("LD", "A", lreg[sreg]);
	  GENERATE________ op1("CP", STR("#<%s", val));
	  if(generic(p->op) == EQ) {
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	  } else {
	    GENERATE________ op2("JP", "NZ", jmp);
	  }
	  GENERATE________ op2("LD", "A", hreg[sreg]);
	  GENERATE________ op1("CP", STR("#>%s", val));
	  GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  GENERATE________ label(STR(".L%d:", lab));
	} else {
	  int sreg2 = RIGHT_REG(p);
	  char *src2 = wreg[sreg2];
	  assert(opsize(RIGHT_NODE(p)->op) == 2);
	  GENERATE________ comment(STR("Compare EQ/NE %s and %s", src1, src2));
	  GENERATE________ op2("LD", "A", lreg[sreg2]);
	  GENERATE________ op1("CP", lreg[sreg]);
	  if(generic(p->op) == EQ) {
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	  } else {
	    GENERATE________ op2("JP", "NZ", jmp);
	  }
	  GENERATE________ op2("LD", "A", hreg[sreg2]);
	  GENERATE________ op1("CP", hreg[sreg]);
	  GENERATE________ op2("JP", (generic(p->op) == EQ ? "Z" : "NZ"), jmp);
	  GENERATE________ label(STR(".L%d:", lab));
	}
	break;
      }
      case GE+I+sizeop(1):
      case GE+U+sizeop(1):
      case LT+I+sizeop(1):
      case LT+U+sizeop(1): {
	char *jmp = p->syms[0]->x.name;
	if(IS_LEFT_INDIR(p)) {
	  char *val;
	  int n;
	  assert(IS_RIGHT_CONST(p));
	  val = RIGHT_VAL(p);
	  n = const_val(RIGHT_NODE(p));
	  if(IS_LEFT_ADDRFP(LEFT_NODE(p)) || IS_LEFT_ADDRLP(LEFT_NODE(p))) {
	    int off = const_val(LEFT_NODE(LEFT_NODE(p)));
	    GENERATE________ comment(STR("Compare GE/LT (mem) and %s", val));
#ifdef GAMEBOY
	    GENERATE________ offsethl(off + framesize + argstack);
	    GENERATE________ op2("LD", "A", "(HL)");
#else
	    GENERATE________ op2("LD", "A", STR("%d(IX)", off));
#endif
	    if(optype(p->op) == I) {
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	    } else {
	      GENERATE________ op1("CP", STR("#<%s", val));
	    }
	    GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	  } else if(IS_LEFT_CONST(LEFT_NODE(p)) || IS_LEFT_ADDRGP(LEFT_NODE(p))) {
	    char *addr = LEFT_VAL(LEFT_NODE(p));
	    GENERATE________ comment(STR("Compare GE/LT (mem) and %s", val));
	    GENERATE________ op2("LD", "A", STR("(%s)", addr));
	    if(optype(p->op) == I) {
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	    } else {
	      GENERATE________ op1("CP", STR("#<%s", val));
	    }
	    GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	  } else {
	    int sreg = LEFT_REG(p);
	    GENERATE________ comment(STR("Compare GE/LT (mem) and %s", val));
	    GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	    if(optype(p->op) == I) {
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	    } else {
	      GENERATE________ op1("CP", STR("#<%s", val));
	    }
	    GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	  }
	} else {
	  int sreg = LEFT_REG(p);
	  if(IS_RIGHT_INDIR(p) &&
	     (IS_LEFT_ADDRFP(RIGHT_NODE(p)) || IS_LEFT_ADDRLP(RIGHT_NODE(p)))) {
	    int off = const_val(LEFT_NODE(RIGHT_NODE(p)));
	    GENERATE________ comment(STR("Compare GE/LT %s and (mem)", breg[sreg]));
	    if(optype(p->op) == I) {
#ifdef GAMEBOY
	      GENERATE________ offsethl(off + framesize + argstack);
	      GENERATE________ op2("LD", "A", "(HL)");
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op2("LD", "L", "A");
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", "L");
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
#else
	      int lab1 = genlabel(1);
	      int lab2 = genlabel(1);
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("CP", STR("%d(IX)", off));
	      GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "P" : "M"), jmp);
	      GENERATE________ op1("JR", STR(".L%d", lab2));
	      GENERATE________ label(STR(".L%d:", lab1));
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "M" : "P"), jmp);
	      GENERATE________ label(STR(".L%d:", lab2));
#endif
	    } else {
#ifdef GAMEBOY
	      GENERATE________ offsethl(off + framesize + argstack);
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("CP", "(HL)");
#else
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("CP", STR("%d(IX)", off));
#endif
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	    }
	  } else if(IS_RIGHT_INDIR(p) &&
		    (IS_LEFT_CONST(RIGHT_NODE(p)) || IS_LEFT_ADDRGP(RIGHT_NODE(p)))) {
	    char *addr = LEFT_VAL(RIGHT_NODE(p));
	    GENERATE________ comment(STR("Compare GE/LT %s and (mem)", breg[sreg]));
	    if(optype(p->op) == I) {
#ifdef GAMEBOY
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op2("LD", "L", "A");
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", "L");
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
#else
	      int lab1 = genlabel(1);
	      int lab2 = genlabel(1);
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("CP", breg[sreg]);
	      GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
	      if(generic(p->op) == GE) {
		GENERATE________ op2("JP", "Z", jmp);
	      } else {
		GENERATE________ op2("JR", "Z", STR(".L%d", lab2));
	      }
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "M" : "P"), jmp);
	      GENERATE________ op1("JR", STR(".L%d", lab2));
	      GENERATE________ label(STR(".L%d:", lab1));
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "P" : "M"), jmp);
	      GENERATE________ label(STR(".L%d:", lab2));
#endif
	    } else {
#ifdef GAMEBOY
	      GENERATE________ op2("LD", "HL", STR("#%s", addr));
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("CP", "(HL)");
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
#else
	      int lab = genlabel(1);
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("CP", breg[sreg]);
	      if(generic(p->op) == GE) {
		GENERATE________ op2("JP", "C", jmp);
		GENERATE________ op2("JP", "Z", jmp);
	      } else {
		GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		GENERATE________ op2("JP", "NC", jmp);
	      }
	      GENERATE________ label(STR(".L%d:", lab));
#endif
	    }
	  } else if(IS_RIGHT_CONST(p)) {
	    char *val = RIGHT_VAL(p);
	    int n = const_val(RIGHT_NODE(p));
	    GENERATE________ comment(STR("Compare GE/LT %s and %s", breg[sreg], val));
	    if(optype(p->op) == I) {
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	    } else {
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("CP", STR("#<%s", val));
	      GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	    }
	  } else {
	    int sreg2 = RIGHT_REG(p);
	    if(IS_RIGHT_INDIR(p)) {
	      GENERATE________ comment(STR("Compare GE/LT %s and (mem)", breg[sreg]));
	      if(optype(p->op) == I) {
#ifdef GAMEBOY
		GENERATE________ op2("LD", "A", STR("(%s)",  wreg[sreg2]));
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op2("LD", "L", "A");
		GENERATE________ op2("LD", "A", breg[sreg]);
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op1("CP", "L");
		GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
#else
		int lab1 = genlabel(1);
		int lab2 = genlabel(1);
		if(sreg2 == HL) {
		  GENERATE________ op2("LD", "A", breg[sreg]);
		  GENERATE________ op1("CP", "(HL)");
		  GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
		  GENERATE________ op2("JP", (generic(p->op) == GE ? "P" : "M"), jmp);
		  GENERATE________ op1("JR", STR(".L%d", lab2));
		  GENERATE________ label(STR(".L%d:", lab1));
		  GENERATE________ op2("JP", (generic(p->op) == GE ? "M" : "P"), jmp);
		  GENERATE________ label(STR(".L%d:", lab2));
		} else {
		  GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
		  GENERATE________ op1("CP", breg[sreg]);
		  GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
		  if(generic(p->op) == GE) {
		    GENERATE________ op2("JP", "Z", jmp);
		  } else {
		    GENERATE________ op2("JR", "Z", STR(".L%d", lab2));
		  }
		  GENERATE________ op2("JP", (generic(p->op) == GE ? "M" : "P"), jmp);
		  GENERATE________ op1("JR", STR(".L%d", lab2));
		  GENERATE________ label(STR(".L%d:", lab1));
		  GENERATE________ op2("JP", (generic(p->op) == GE ? "P" : "M"), jmp);
		  GENERATE________ label(STR(".L%d:", lab2));
		}
#endif
	      } else {
#ifdef GAMEBOY
		if(sreg2 != HL) {
		  GENERATE________ op2("LD", "H", hreg[sreg2]);
		  GENERATE________ op2("LD", "L", lreg[sreg2]);
		}
		GENERATE________ op2("LD", "A", breg[sreg]);
		GENERATE________ op1("CP", "(HL)");
		GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
#else
		if(sreg2 == HL) {
		  GENERATE________ op2("LD", "A", breg[sreg]);
		  GENERATE________ op1("CP", "(HL)");
		  GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
		} else {
		  int lab = genlabel(1);
		  GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
		  GENERATE________ op1("CP", breg[sreg]);
		  if(generic(p->op) == GE) {
		    GENERATE________ op2("JP", "C", jmp);
		    GENERATE________ op2("JP", "Z", jmp);
		  } else {
		    GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		    GENERATE________ op2("JP", "NC", jmp);
		  }
		  GENERATE________ label(STR(".L%d:", lab));
		}
#endif
	      }
	    } else {
	      GENERATE________ comment(STR("Compare GE/LT %s and %s", breg[sreg], breg[sreg2]));
	      if(optype(p->op) == I) {
#ifdef GAMEBOY
		GENERATE________ op2("LD", "A", breg[sreg2]);
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op2("LD", "L", "A");
		GENERATE________ op2("LD", "A", breg[sreg]);
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op1("CP", "L");
		GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
#else
		int lab1 = genlabel(1);
		int lab2 = genlabel(1);
		GENERATE________ op2("LD", "A", breg[sreg]);
		GENERATE________ op1("CP", breg[sreg2]);
		GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
		GENERATE________ op2("JP", (generic(p->op) == GE ? "P" : "M"), jmp);
		GENERATE________ op1("JR", STR(".L%d", lab2));
		GENERATE________ label(STR(".L%d:", lab1));
		GENERATE________ op2("JP", (generic(p->op) == GE ? "M" : "P"), jmp);
		GENERATE________ label(STR(".L%d:", lab2));
#endif
	      } else {
		GENERATE________ op2("LD", "A", breg[sreg]);
		GENERATE________ op1("CP", breg[sreg2]);
		GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	      }
	    }
	  }
	}
	break;
      }
      case GE+I+sizeop(2):
      case GE+U+sizeop(2):
      case LT+I+sizeop(2):
      case LT+U+sizeop(2): {
	int lab = genlabel(1);
	int sreg = LEFT_REG(p);
	char *jmp = p->syms[0]->x.name;
	assert(opsize(LEFT_NODE(p)->op) == 2);
	if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  int n = const_val(RIGHT_NODE(p));
	  GENERATE________ comment(STR("Compare GE/LT %s and %s", wreg[sreg], val));
	  if(optype(p->op) == I) {
	    GENERATE________ op2("LD", "A", hreg[sreg]);
	    GENERATE________ op1("ADD", "#0x80");
	    GENERATE________ op1("CP", STR("#<%d", ((n>>8)&0xFF)^0x80));
	  } else {
	    GENERATE________ op2("LD", "A", hreg[sreg]);
	    GENERATE________ op1("CP", STR("#<%d", (n>>8)&0xFF));
	  }
	  GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	  GENERATE________ op2("LD", "A", lreg[sreg]);
	  GENERATE________ op1("CP", STR("#%d", n&0xFF));
	  GENERATE________ label(STR(".L%d:", lab));
	  GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	} else {
	  int sreg2 = RIGHT_REG(p);
	  assert(opsize(RIGHT_NODE(p)->op) == 2);
	  GENERATE________ comment(STR("Compare GE/LT %s and %s", wreg[sreg], wreg[sreg2]));
	  if(optype(p->op) == I) {
#ifdef GAMEBOY
	    GENERATE________ op2("LD", "A", hreg[sreg2]);
	    GENERATE________ op1("ADD", "#0x80");
	    GENERATE________ op2("LD", "L", "A");
	    GENERATE________ op2("LD", "A", hreg[sreg]);
	    GENERATE________ op1("ADD", "#0x80");
	    GENERATE________ op1("CP", "L");
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
#else
	    int lab2 = genlabel(1);
	    GENERATE________ op2("LD", "A", breg[sreg]);
	    GENERATE________ op1("CP", breg[sreg2]);
	    GENERATE________ op2("JR", "Z", STR(".L%d", lab2));
	    GENERATE________ op2("JP", "PE", STR(".L%d", lab));
	    GENERATE________ op2("JP", (generic(p->op) == GE ? "P" : "M"), jmp);
	    GENERATE________ op1("JR", STR(".L%d", lab2));
	    GENERATE________ label(STR(".L%d:", lab));
	    GENERATE________ op2("JP", (generic(p->op) == GE ? "M" : "P"), jmp);
	    GENERATE________ label(STR(".L%d:", lab2));
#endif
	  } else {
	    GENERATE________ op2("LD", "A", hreg[sreg]);
	    GENERATE________ op1("CP", hreg[sreg2]);
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	  }
	  GENERATE________ op2("LD", "A", lreg[sreg]);
	  GENERATE________ op1("CP", lreg[sreg2]);
	  GENERATE________ label(STR(".L%d:", lab));
	  GENERATE________ op2("JP", (generic(p->op) == GE ? "NC" : "C"), jmp);
	}
	break;
      }
      case LE+I+sizeop(1):
      case LE+U+sizeop(1):
      case GT+I+sizeop(1):
      case GT+U+sizeop(1): {
	char *jmp = p->syms[0]->x.name;
	if(IS_LEFT_INDIR(p)) {
	  char *val;
	  int n;
	  assert(IS_RIGHT_CONST(p));
	  val = RIGHT_VAL(p);
	  n = const_val(RIGHT_NODE(p));
	  if(IS_LEFT_ADDRFP(LEFT_NODE(p)) || IS_LEFT_ADDRLP(LEFT_NODE(p))) {
	    int off = const_val(LEFT_NODE(LEFT_NODE(p)));
	    GENERATE________ comment(STR("Compare LE/GT (mem) and %s", val));
#ifdef GAMEBOY
	    GENERATE________ offsethl(off + framesize + argstack);
	    GENERATE________ op2("LD", "A", "(HL)");
#else
	    GENERATE________ op2("LD", "A", STR("%d(IX)", off));
#endif
	    if(optype(p->op) == I) {
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	      if(generic(p->op) == GT) {
		int lab = genlabel(1);
		GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		GENERATE________ op2("JP", "NC", jmp);
		GENERATE________ label(STR(".L%d:", lab));
	      } else {
		GENERATE________ op2("JP", "C", jmp);
		GENERATE________ op2("JP", "Z", jmp);
	      }
	    } else {
	      GENERATE________ op2("LD", "A", STR("#<%s", val));
#ifdef GAMEBOY
	      GENERATE________ op1("CP", "(HL)");
#else
	      GENERATE________ op1("CP", STR("%d(IX)", off));
#endif
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	    }
	  } else if(IS_LEFT_CONST(LEFT_NODE(p)) || IS_LEFT_ADDRGP(LEFT_NODE(p))) {
	    char *addr = LEFT_VAL(LEFT_NODE(p));
	    GENERATE________ comment(STR("Compare LE/GT (mem) and %s", val));
	    if(optype(p->op) == I) {
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	    } else {
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("CP", STR("#<%s", val));
	    }
	    if(generic(p->op) == GT) {
	      int lab = genlabel(1);
	      GENERATE________ op2("JR", "Z", STR(".L%d", lab));
	      GENERATE________ op2("JP", "NC", jmp);
	      GENERATE________ label(STR(".L%d:", lab));
	    } else {
	      GENERATE________ op2("JP", "C", jmp);
	      GENERATE________ op2("JP", "Z", jmp);
	    }
	  } else {
	    int sreg = LEFT_REG(p);
	    GENERATE________ comment(STR("Compare LE/GT (mem) and %s", val));
	    if(optype(p->op) == I) {
	      GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	      if(generic(p->op) == GT) {
		int lab = genlabel(1);
		GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		GENERATE________ op2("JP", "NC", jmp);
		GENERATE________ label(STR(".L%d:", lab));
	      } else {
		GENERATE________ op2("JP", "C", jmp);
		GENERATE________ op2("JP", "Z", jmp);
	      }
	    } else if(sreg == HL) {
	      GENERATE________ op2("LD", "A", STR("#<%d", val));
	      GENERATE________ op1("CP", "(HL)");
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	    } else {
	      GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg]));
	      GENERATE________ op1("CP", STR("#<%s", val));
	      if(generic(p->op) == GT) {
		int lab = genlabel(1);
		GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		GENERATE________ op2("JP", "NC", jmp);
		GENERATE________ label(STR(".L%d:", lab));
	      } else {
		GENERATE________ op2("JP", "C", jmp);
		GENERATE________ op2("JP", "Z", jmp);
	      }
	    }
	  }
	} else {
	  int sreg = LEFT_REG(p);
	  if(IS_RIGHT_INDIR(p) &&
	     (IS_LEFT_ADDRFP(RIGHT_NODE(p)) || IS_LEFT_ADDRLP(RIGHT_NODE(p)))) {
	    int off = const_val(LEFT_NODE(RIGHT_NODE(p)));
	    GENERATE________ comment(STR("Compare LE/GT %s and (mem)", breg[sreg]));
	    if(optype(p->op) == I) {
#ifdef GAMEBOY
	      GENERATE________ offsethl(off + framesize + argstack);
	      GENERATE________ op2("LD", "H", "(HL)");
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op2("LD", "L", "A");
	      GENERATE________ op2("LD", "A", "H");
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", "L");
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
#else
	      int lab1 = genlabel(1);
	      int lab2 = genlabel(1);
	      GENERATE________ op2("LD", "A", STR("%d(IX)", off));
	      GENERATE________ op1("CP", breg[sreg]);
	      GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "P" : "M"), jmp);
	      GENERATE________ op1("JR", STR(".L%d", lab2));
	      GENERATE________ label(STR(".L%d:", lab1));
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "M" : "P"), jmp);
	      GENERATE________ label(STR(".L%d:", lab2));
#endif
	    } else {
#ifdef GAMEBOY
	      GENERATE________ offsethl(off + framesize + argstack);
	      GENERATE________ op2("LD", "A", "(HL)");
	      GENERATE________ op1("CP", breg[sreg]);
#else
	      GENERATE________ op2("LD", "A", STR("%d(IX)", off));
	      GENERATE________ op1("CP", breg[sreg]);
#endif
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	    }
	  } else if(IS_RIGHT_INDIR(p) &&
		    (IS_LEFT_CONST(RIGHT_NODE(p)) || IS_LEFT_ADDRGP(RIGHT_NODE(p)))) {
	    char *addr = LEFT_VAL(RIGHT_NODE(p));
	    GENERATE________ comment(STR("Compare LE/GT %s and (mem)", breg[sreg]));
	    if(optype(p->op) == I) {
#ifdef GAMEBOY
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op2("LD", "L", "A");
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", "L");
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
#else
	      int lab1 = genlabel(1);
	      int lab2 = genlabel(1);
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("CP", breg[sreg]);
	      GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "P" : "M"), jmp);
	      GENERATE________ op1("JR", STR(".L%d", lab2));
	      GENERATE________ label(STR(".L%d:", lab1));
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "M" : "P"), jmp);
	      GENERATE________ label(STR(".L%d:", lab2));
#endif
	    } else {
	      GENERATE________ op2("LD", "A", STR("(%s)", addr));
	      GENERATE________ op1("CP", breg[sreg]);
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	    }
	  } else if(IS_RIGHT_CONST(p)) {
	    char *val = RIGHT_VAL(p);
	    int n = const_val(RIGHT_NODE(p));
	    GENERATE________ comment(STR("Compare LE/GT %s and %s", breg[sreg], val));
	    if(optype(p->op) == I) {
	      GENERATE________ op2("LD", "A", breg[sreg]);
	      GENERATE________ op1("ADD", "#0x80");
	      GENERATE________ op1("CP", STR("#<%d", n^0x80));
	      if(generic(p->op) == GT) {
		int lab = genlabel(1);
		GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		GENERATE________ op2("JP", "NC", jmp);
		GENERATE________ label(STR(".L%d:", lab));
	      } else {
		GENERATE________ op2("JP", "C", jmp);
		GENERATE________ op2("JP", "Z", jmp);
	      }
	    } else {
	      GENERATE________ op2("LD", "A", STR("#<%s", val));
	      GENERATE________ op1("CP", breg[sreg]);
	      GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	    }
	  } else {
	    int sreg2 = RIGHT_REG(p);
	    if(IS_RIGHT_INDIR(p)) {
	      GENERATE________ comment(STR("Compare LE/GT %s and (mem)", breg[sreg]));
	      if(optype(p->op) == I) {
#ifdef GAMEBOY
		GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op2("LD", "L", "A");
		GENERATE________ op2("LD", "A", breg[sreg]);
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op1("CP", "L");
		if(generic(p->op) == GT) {
		  int lab = genlabel(1);
		  GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		  GENERATE________ op2("JP", "NC", jmp);
		  GENERATE________ label(STR(".L%d:", lab));
		} else {
		  GENERATE________ op2("JP", "C", jmp);
		  GENERATE________ op2("JP", "Z", jmp);
		}
#else
		int lab1 = genlabel(1);
		int lab2 = genlabel(1);
		GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
		GENERATE________ op1("CP", breg[sreg]);
		GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
		GENERATE________ op2("JP", (generic(p->op) == LE ? "P" : "M"), jmp);
		GENERATE________ op1("JR", STR(".L%d", lab2));
		GENERATE________ label(STR(".L%d:", lab1));
		GENERATE________ op2("JP", (generic(p->op) == LE ? "M" : "P"), jmp);
#endif
	      } else {
		GENERATE________ op2("LD", "A", STR("(%s)", wreg[sreg2]));
		GENERATE________ op1("CP", breg[sreg]);
		GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	      }
	    } else {
	      GENERATE________ comment(STR("Compare LE/GT %s and %s", breg[sreg], breg[sreg2]));
	      if(optype(p->op) == I) {
#ifdef GAMEBOY
		GENERATE________ op2("LD", "A", breg[sreg]);
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op2("LD", "L", "A");
		GENERATE________ op2("LD", "A", breg[sreg2]);
		GENERATE________ op1("ADD", "#0x80");
		GENERATE________ op1("CP", "L");
		GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
#else
		int lab1 = genlabel(1);
		int lab2 = genlabel(1);
		GENERATE________ op2("LD", "A", breg[sreg2]);
		GENERATE________ op1("CP", breg[sreg]);
		GENERATE________ op2("JP", "PE", STR(".L%d", lab1));
		GENERATE________ op2("JP", (generic(p->op) == LE ? "P" : "M"), jmp);
		GENERATE________ op1("JR", STR(".L%d", lab2));
		GENERATE________ label(STR(".L%d:", lab1));
		GENERATE________ op2("JP", (generic(p->op) == LE ? "M" : "P"), jmp);
		GENERATE________ label(STR(".L%d:", lab2));
#endif
	      } else {
		GENERATE________ op2("LD", "A", breg[sreg2]);
		GENERATE________ op1("CP", breg[sreg]);
		GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	      }
	    }
	  }
	}
	break;
      }
      case LE+I+sizeop(2):
      case LE+U+sizeop(2):
      case GT+I+sizeop(2):
      case GT+U+sizeop(2): {
	int lab = genlabel(1);
	int sreg = LEFT_REG(p);
	char *jmp = p->syms[0]->x.name;
	char *src1 = wreg[sreg];
	assert(opsize(LEFT_NODE(p)->op) == 2);
	if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  int n = const_val(RIGHT_NODE(p));
	  GENERATE________ comment(STR("Compare LE/GT %s and %s", src1, val));
	  if(optype(p->op) == I) {
	    int lab2 = genlabel(1);
	    GENERATE________ op2("LD", "A", hreg[sreg]);
	    GENERATE________ op1("ADD", "#0x80");
	    GENERATE________ op1("CP", STR("#<%d", ((n>>8)&0xFF)^0x80));
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	    GENERATE________ op2("LD", "A", lreg[sreg]);
	    GENERATE________ op1("CP", STR("#<%d", n));
	    if(generic(p->op) == GT) {
	      int lab2 = genlabel(1);
	      GENERATE________ op2("JR", "Z", STR(".L%d", lab2));
	      GENERATE________ label(STR(".L%d:", lab));
	      GENERATE________ op2("JP", "NC", jmp);
	      GENERATE________ label(STR(".L%d:", lab2));
	    } else {
	      GENERATE________ op2("JP", "Z", jmp);
	      GENERATE________ label(STR(".L%d:", lab));
	      GENERATE________ op2("JP", "C", jmp);
	    }
	  } else {
	    GENERATE________ op2("LD", "A", STR("#<%d", (n>>8)&0xFF));
	    GENERATE________ op1("CP", hreg[sreg]);
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	    GENERATE________ op2("LD", "A", STR("#<%d", n));
	    GENERATE________ op1("CP", lreg[sreg]);
	    GENERATE________ label(STR(".L%d:", lab));
	    GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	  }
	} else {
	  int sreg2 = RIGHT_REG(p);
	  char *src2 = wreg[sreg2];
	  assert(opsize(RIGHT_NODE(p)->op) == 2);
	  GENERATE________ comment(STR("Compare LE/GT %s and %s", src1, src2));
	  if(optype(p->op) == I) {
#ifdef GAMEBOY
	    GENERATE________ op2("LD", "A", hreg[sreg]);
	    GENERATE________ op1("ADD", "#0x80");
	    GENERATE________ op2("LD", "L", "A");
	    GENERATE________ op2("LD", "A", hreg[sreg2]);
	    GENERATE________ op1("ADD", "#0x80");
	    GENERATE________ op1("CP", "L");
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
#else
	    int lab2 = genlabel(1);
	    GENERATE________ op2("LD", "A", breg[sreg2]);
	    GENERATE________ op1("CP", breg[sreg]);
	    GENERATE________ op2("JR", "Z", STR(".L%d", lab2));
	    GENERATE________ op2("JP", "PE", STR(".L%d", lab));
	    GENERATE________ op2("JP", (generic(p->op) == LE ? "P" : "M"), jmp);
	    GENERATE________ op1("JR", STR(".L%d", lab2));
	    GENERATE________ label(STR(".L%d:", lab));
	    GENERATE________ op2("JP", (generic(p->op) == LE ? "M" : "P"), jmp);
	    GENERATE________ label(STR(".L%d:", lab2));
#endif
	  } else {
	    GENERATE________ op2("LD", "A", hreg[sreg2]);
	    GENERATE________ op1("CP", hreg[sreg]);
	    GENERATE________ op2("JR", "NZ", STR(".L%d", lab));
	  }
	  GENERATE________ op2("LD", "A", lreg[sreg2]);
	  GENERATE________ op1("CP", lreg[sreg]);
	  GENERATE________ label(STR(".L%d:", lab));
	  GENERATE________ op2("JP", (generic(p->op) == LE ? "NC" : "C"), jmp);
	}
	break;
      }
      case EQ+I+sizeop(4):
      case EQ+U+sizeop(4):
      case EQ+F+sizeop(4):
      case NE+I+sizeop(4):
      case NE+U+sizeop(4):
      case NE+F+sizeop(4):
      case GE+I+sizeop(4):
      case GE+U+sizeop(4):
      case GE+F+sizeop(4):
      case LT+I+sizeop(4):
      case LT+U+sizeop(4):
      case LT+F+sizeop(4):
      case GT+I+sizeop(4):
      case GT+U+sizeop(4):
      case GT+F+sizeop(4):
      case LE+I+sizeop(4):
      case LE+U+sizeop(4):
      case LE+F+sizeop(4): {
	char *jmp = p->syms[0]->x.name;
	GENERATE________ comment("Floating point comparison");
	save(BC);
	save(DE);
#ifdef GAMEBOY
#else
	save(HL);
#endif
	load_32(RIGHT_NODE(p));
	GENERATE________ op1("PUSH", "HL");
	GENERATE________ op1("PUSH", "DE");
	argstack += 4;
	load_32(LEFT_NODE(p));
	GENERATE________ op1(".globl", optype((p)->op)==F ? ".fsub32" : (optype((p)->op)==U ? ".subu32" : ".sub32"));
	GENERATE________ op1("CALL", optype((p)->op)==F ? ".fsub32" : (optype((p)->op)==U ? ".subu32" : ".sub32"));
	argstack -= 4;
	GENERATE________ op1(".globl", optype((p)->op)==F ? ".fcmp32" : ".cmp32");
	GENERATE________ op1("CALL", optype((p)->op)==F ? ".fcmp32" : ".cmp32");
	restore(DE);
	restore(BC);
#ifdef GAMEBOY
#else
	restore(HL);
#endif
	if(generic(p->op) == EQ) {
	  GENERATE________ op2("JP", "Z", jmp);
	} else if(generic(p->op) == NE) {
	  GENERATE________ op2("JP", "NZ", jmp);
	} else if(generic(p->op) == GE) {
	  GENERATE________ op2("JP", "NC", jmp);
	} else if(generic(p->op) == LT) {
	  GENERATE________ op2("JP", "C", jmp);
	} else if(generic(p->op) == GT) {
	  int lab = genlabel(1);
	  GENERATE________ op2("JR", "C", STR(".L%d", lab));
	  GENERATE________ op2("JP", "NZ", jmp);
	  GENERATE________ label(STR(".L%d:", lab));
	} else if(generic(p->op) == LE) {
	  GENERATE________ op2("JP", "C", jmp);
	  GENERATE________ op2("JP", "Z", jmp);
	}
	break;
      }
      case LSH+I+sizeop(1):
      case LSH+U+sizeop(1):
      case RSH+I+sizeop(1):
      case RSH+U+sizeop(1): {
	int dreg = REG(p);
	int sreg = LEFT_REG(p);
	if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  int n = const_val(RIGHT_NODE(p));
	  GENERATE________ comment(STR("Left/right shift %s by %s into %s", breg[sreg], val, breg[dreg]));
	  GENERATE________ op2("LD", breg[dreg], breg[sreg]);
	  while(n-- > 0) {
	    if(generic(p->op) == LSH) {
	      GENERATE________ op1("SLA", breg[dreg]);
	    } else if(generic(p->op) == RSH) {
	      GENERATE________ op1(optype((p)->op)==U ? "SRL" : "SRA", breg[dreg]);
	    }
	  }
	} else {
	  int shift = RIGHT_REG(p);
	  GENERATE________ comment(STR("Left/right shift %s by %s into %s", breg[sreg], breg[shift], breg[dreg]));
	  GENERATE________ op2("LD", "A", breg[shift]);
	  if(generic(p->op) == LSH) {
	    GENERATE________ op1(".globl", ".asl8");
	    GENERATE________ op1("CALL", ".asl8");
	  } else if(generic(p->op) == RSH) {
	    GENERATE________ op1(".globl", optype((p)->op)==U ? ".lsr8" : ".asr8");
	    GENERATE________ op1("CALL", optype((p)->op)==U ? ".lsr8" : ".asr8");
	  }
	}
	break;
      }
      case LSH+I+sizeop(2):
      case LSH+U+sizeop(2):
      case RSH+I+sizeop(2):
      case RSH+U+sizeop(2): {
	int dreg = REG(p);
	int sreg = LEFT_REG(p);
	assert(opsize(LEFT_NODE(p)->op) == 2);
	if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  int n = const_val(RIGHT_NODE(p));
	  GENERATE________ comment(STR("Left/right shift %s by %s into %s", wreg[sreg], val, wreg[dreg]));
	  if(n == 8) {
	    if(generic(p->op) == LSH) {
	      GENERATE________ op2("LD", "A", lreg[sreg]);
	      GENERATE________ op2("LD", hreg[dreg], "A");
	      GENERATE________ op1("XOR", "A");
	      GENERATE________ op2("LD", lreg[dreg], "A");
	    } else if(generic(p->op) == RSH) {
	      GENERATE________ op2("LD", "A", hreg[sreg]);
	      GENERATE________ op2("LD", lreg[dreg], "A");
	      if(optype((p)->op)==U) {
		GENERATE________ op1("XOR", "A");
		GENERATE________ op2("LD", hreg[dreg], "A");
	      } else {
		int lab = genlabel(1);
		GENERATE________ op1("AND", "#0x80");
		GENERATE________ op2("JR", "Z", STR(".L%d", lab));
		GENERATE________ op2("LD", "A", "#0xFF");
		GENERATE________ label(STR(".L%d:", lab));
		GENERATE________ op2("LD", hreg[dreg], "A");
	      }
	    }
	  } else {
	    GENERATE________ op2("LD", hreg[dreg], hreg[sreg]);
	    GENERATE________ op2("LD", lreg[dreg], lreg[sreg]);
	    while(n-- > 0) {
	      if(generic(p->op) == LSH) {
		if(dreg == HL) {
		  GENERATE________ op2("ADD", "HL", "HL");
		} else {
		  GENERATE________ op1("SLA", lreg[dreg]);
		  GENERATE________ op1("RL", hreg[dreg]);
		}
	      } else if(generic(p->op) == RSH) {
		GENERATE________ op1(optype((p)->op)==U ? "SRL" : "SRA", hreg[dreg]);
		GENERATE________ op1("RR", lreg[dreg]);
	      }
	    }
	  }
	} else {
	  int shift = RIGHT_REG(p);
	  GENERATE________ comment(STR("Left/right shift %s by %s into %s", wreg[sreg], breg[shift], wreg[dreg]));
	  GENERATE________ op2("LD", "A", breg[shift]);
	  if(generic(p->op) == LSH) {
	    GENERATE________ op1(".globl", ".asl16");
	    GENERATE________ op1("CALL", ".asl16");
	  } else if(generic(p->op) == RSH) {
	    GENERATE________ op1(".globl", optype((p)->op)==U ? ".lsr16" : ".asr16");
	    GENERATE________ op1("CALL", optype((p)->op)==U ? ".lsr16" : ".asr16");
	  }
	}
	break;
      }
      case LSH+I+sizeop(4):
      case LSH+U+sizeop(4):
      case RSH+I+sizeop(4):
      case RSH+U+sizeop(4): {
	GENERATE________ comment("Long left/right shift");
	save(BC);
	save(DE);
#ifdef GAMEBOY
#else
	save(HL);
#endif
	if(IS_RIGHT_CONST(p)) {
	  char *val = RIGHT_VAL(p);
	  load_32(LEFT_NODE(p));
	  GENERATE________ op2("LD", "A", STR("#<%d", val));
	} else {
	  int shift = RIGHT_REG(p);
	  GENERATE________ op2("LD", "C", breg[shift]);
	  load_32(LEFT_NODE(p));
	  GENERATE________ op2("LD", "A", "C");
	}
	if(generic(p->op) == LSH) {
	  GENERATE________ op1(".globl", ".asl32");
	  GENERATE________ op1("CALL", ".asl32");
	} else if(generic(p->op) == RSH) {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".lsr32" : ".asr32");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".lsr32" : ".asr32");
	}
	store_32(p);
#ifdef GAMEBOY
#else
	restore(HL);
#endif
	restore(DE);
	restore(BC);
	break;
      }
      case MUL+I+sizeop(1):
      case MUL+U+sizeop(1):
      case DIV+I+sizeop(1):
      case DIV+U+sizeop(1):
      case MOD+I+sizeop(1):
      case MOD+U+sizeop(1): {
	int dreg = REG(p);
	int sreg1 = LEFT_REG(p);
	int sreg2 = RIGHT_REG(p);
	GENERATE________ comment(STR("Mul/div/mod %s by %s into %s", breg[sreg1], breg[sreg2], breg[dreg]));
	if(generic(p->op) == MUL) {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".mulu8" : ".mul8");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".mulu8" : ".mul8");
	} else if(generic(p->op) == DIV) {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".divu8" : ".div8");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".divu8" : ".div8");
	} else {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".modu8" : ".mod8");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".modu8" : ".mod8");
	}
	break;
      }
      case MUL+I+sizeop(2):
      case MUL+U+sizeop(2):
      case DIV+I+sizeop(2):
      case DIV+U+sizeop(2):
      case MOD+I+sizeop(2):
      case MOD+U+sizeop(2): {
	int dreg = REG(p);
	int sreg1 = LEFT_REG(p);
	int sreg2 = RIGHT_REG(p);
	assert(opsize(LEFT_NODE(p)->op) == 2);
	assert(opsize(RIGHT_NODE(p)->op) == 2);
	GENERATE________ comment(STR("Mul/div/mod %s by %s into %s", wreg[sreg1], wreg[sreg2], wreg[dreg]));
	if(generic(p->op) == MUL) {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".mulu16" : ".mul16");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".mulu16" : ".mul16");
	} else if(generic(p->op) == DIV) {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".divu16" : ".div16");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".divu16" : ".div16");
	} else {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".modu16" : ".mod16");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".modu16" : ".mod16");
	}
	break;
      }
      case ADD+I+sizeop(4):
      case ADD+U+sizeop(4):
      case ADD+F+sizeop(4):
      case SUB+I+sizeop(4):
      case SUB+U+sizeop(4):
      case SUB+F+sizeop(4):
      case MUL+I+sizeop(4):
      case MUL+U+sizeop(4):
      case MUL+F+sizeop(4):
      case DIV+I+sizeop(4):
      case DIV+U+sizeop(4):
      case DIV+F+sizeop(4):
      case MOD+I+sizeop(4):
      case MOD+U+sizeop(4):
      case BAND+I+sizeop(4):
      case BAND+U+sizeop(4):
      case BOR+I+sizeop(4):
      case BOR+U+sizeop(4):
      case BXOR+I+sizeop(4):
      case BXOR+U+sizeop(4): {
	GENERATE________ comment("Long/floating point add/sub/mul/div/mod/and/or/xor");
	save(BC);
	save(DE);
#ifdef GAMEBOY
#else
	save(HL);
#endif
	load_32(RIGHT_NODE(p));
	GENERATE________ op1("PUSH", "HL");
	GENERATE________ op1("PUSH", "DE");
	argstack += 4;
	load_32(LEFT_NODE(p));
	if(generic(p->op) == ADD) {
	  GENERATE________ op1(".globl", optype((p)->op)==F ? ".fadd32" : (optype((p)->op)==U ? ".addu32" : ".add32"));
	  GENERATE________ op1("CALL", optype((p)->op)==F ? ".fadd32" : (optype((p)->op)==U ? ".addu32" : ".add32"));
	} else if(generic(p->op) == SUB) {
	  GENERATE________ op1(".globl", optype((p)->op)==F ? ".fsub32" : (optype((p)->op)==U ? ".subu32" : ".sub32"));
	  GENERATE________ op1("CALL", optype((p)->op)==F ? ".fsub32" : (optype((p)->op)==U ? ".subu32" : ".sub32"));
	} else if(generic(p->op) == MUL) {
	  GENERATE________ op1(".globl", optype((p)->op)==F ? ".fmul32" : (optype((p)->op)==U ? ".mulu32" : ".mul32"));
	  GENERATE________ op1("CALL", optype((p)->op)==F ? ".fmul32" : (optype((p)->op)==U ? ".mulu32" : ".mul32"));
	} else if(generic(p->op) == DIV) {
	  GENERATE________ op1(".globl", optype((p)->op)==F ? ".fdiv32" : (optype((p)->op)==U ? ".divu32" : ".div32"));
	  GENERATE________ op1("CALL", optype((p)->op)==F ? ".fdiv32" : (optype((p)->op)==U ? ".divu32" : ".div32"));
	} else if(generic(p->op) == MOD) {
	  GENERATE________ op1(".globl", optype((p)->op)==U ? ".modu32" : ".mod32");
	  GENERATE________ op1("CALL", optype((p)->op)==U ? ".modu32" : ".mod32");
	} else if(generic(p->op) == BAND) {
	  GENERATE________ op1(".globl", ".and32");
	  GENERATE________ op1("CALL", ".and32");
	} else if(generic(p->op) == BOR) {
	  GENERATE________ op1(".globl", ".or32");
	  GENERATE________ op1("CALL", ".or32");
	} else if(generic(p->op) == BXOR) {
	  GENERATE________ op1(".globl", ".xor32");
	  GENERATE________ op1("CALL", ".xor32");
	}
	argstack -= 4;
	store_32(p);
#ifdef GAMEBOY
#else
	restore(HL);
#endif
	restore(DE);
	restore(BC);
	break;
      }
      case RET+I+sizeop(1):
      case RET+U+sizeop(1):
      case RET+I+sizeop(2):
      case RET+U+sizeop(2):
      case RET+P+sizeop(2):
      case RET+I+sizeop(4):
      case RET+U+sizeop(4):
      case RET+F+sizeop(4):
      case RET+V: {
	break;
      }
      case LABEL+V: {
	GENERATE________ label(STR("%s:", p->syms[0]->x.name));
	break;
      }
      case JUMP+V: {
	if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
	  char *val = LEFT_VAL(p);
	  GENERATE________ op1("JP", val);
	} else {
	  int sreg = LEFT_REG(p);
	  char *src = wreg[sreg];
	  GENERATE________ op1("JP", STR("(%s)", src));
	}
	break;
      }
      default: {
	fprintf(stderr, "ERROR: unimplemented instruction %s\n", opname(p->op));
	break;
      }
    }
}

static void offsetsp(int off)
{
  if(off == 0)
    return;
#ifdef GAMEBOY
  while(off < -0x80) {
    GENERATE________ op2("LDA", "SP", "-128(SP)");
    off += 0x80;
  }
  while(off > 0x7F) {
    GENERATE________ op2("LDA", "SP", "127(SP)");
    off -= 0x7F;
  }
  if(off == 1) {
    GENERATE________ op1("INC", "SP");
  } else if(off == -1) {
    GENERATE________ op1("DEC", "SP");
  } else if(off != 0) {
    GENERATE________ op2("LDA", "SP", STR("%d(SP)", off));
  }
#else
  if(off > 0 && off <= 5) {
    while(off--) {
      GENERATE________ op1("INC", "SP");
    }
  } else if(off < 0 && off >= -5) {
    while(off++) {
      GENERATE________ op1("DEC", "SP");
    }
  } else if(off != 0) {
    int treg = tmp16(HL) ? HL : IY;
    GENERATE________ op2("LD", wreg[treg], STR("#%d", off));
    GENERATE________ op2("ADD", wreg[treg], "SP");
    GENERATE________ op2("LD", "SP", wreg[treg]);
  }
#endif
}

#ifdef GAMEBOY
static void offsethl(int off)
{
  if(off >= -0x80 && off <= 0x7F) {
    GENERATE________ op2("LDA", "HL", STR("%d(SP)", off));
  } else {
    GENERATE________ op2("LDA", "HL", "0(SP)");
    save(BC);
    GENERATE________ op2("LD", "BC", STR("#%d", off));
    GENERATE________ op2("ADD", "HL", "BC");
    restore(BC);
  }
}
#endif

static int save(int reg)
{
  if((freemask[IREG]&reg16[reg]->x.regnode->mask) != reg16[reg]->x.regnode->mask) {
    GENERATE________ op1("PUSH", wreg[reg]);
    argstack += 2;
    return 2;
  }
  return 0;
}

static int restore(int reg)
{
  if((freemask[IREG]&reg16[reg]->x.regnode->mask) != reg16[reg]->x.regnode->mask) {
    GENERATE________ op1("POP", wreg[reg]);
    argstack -= 2;
    return 2;
  }
  return 0;
}

static void load_32(Node p)
{
#ifdef GAMEBOY
  if(IS_INDIR(p)) {
    if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
      int off = const_val(LEFT_NODE(p));
      GENERATE________ offsethl(off + framesize + argstack);
    } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
      GENERATE________ op2("LD", "HL", STR("#%s", LEFT_VAL(p)));
    } else {
      int sreg = LEFT_REG(p);
      GENERATE________ op2("LD", "H", hreg[sreg]);
      GENERATE________ op2("LD", "L", lreg[sreg]);
    }
  } else
    GENERATE________ op2("LD", "HL", STR("#%s", xreg[REG(p)]));

  GENERATE________ op2("LD", "E", "(HL)");
  GENERATE________ op1("INC", "HL");
  GENERATE________ op2("LD", "D", "(HL)");
  GENERATE________ op1("INC", "HL");
  GENERATE________ op2("LD", "A", "(HL+)");
  GENERATE________ op2("LD", "H", "(HL)");
  GENERATE________ op2("LD", "L", "A");
#else
  char *src = NULL;
  if(IS_INDIR(p)) {
    if(IS_LEFT_ADDRFP(p) || IS_LEFT_ADDRLP(p)) {
      int off = const_val(LEFT_NODE(p));
      GENERATE________ op2("LD", "H", STR("%d(IX)", off+3));
      GENERATE________ op2("LD", "L", STR("%d(IX)", off+2));
      GENERATE________ op2("LD", "D", STR("%d(IX)", off+1));
      GENERATE________ op2("LD", "E", STR("%d(IX)", off));
    } else if(IS_LEFT_CONST(p) || IS_LEFT_ADDRGP(p)) {
      src = LEFT_VAL(p);
    } else {
      int sreg = LEFT_REG(p);
      if(sreg != IY) {
	GENERATE________ op1("PUSH", wreg[sreg]);
	GENERATE________ op1("POP", "IY");
      }
      GENERATE________ op2("LD", "H", "3(IY)");
      GENERATE________ op2("LD", "L", "2(IY)");
      GENERATE________ op2("LD", "D", "1(IY)");
      GENERATE________ op2("LD", "E", "0(IY)");
    }
  } else {
    src = xreg[REG(p)];
  }
  if(src) {
    GENERATE________ op2("LD", "HL", STR("(%s+2)", src));
    GENERATE________ op2("LD", "DE", STR("(%s)", src));
  }
#endif
}

static void store_32(Node p)
{
#ifdef GAMEBOY
  char *dst = NULL;
  if(IS_ADDRFP(p) || IS_ADDRLP(p)) {
    int off = const_val(p);
    GENERATE________ op1("PUSH", "HL");
    GENERATE________ offsethl(off + framesize + argstack + 2);
    GENERATE________ op2("LD", "(HL)", "E");
    GENERATE________ op1("INC", "HL");
    GENERATE________ op2("LD", "(HL)", "D");
    GENERATE________ op1("INC", "HL");
    GENERATE________ op1("POP", "DE");
    GENERATE________ op2("LD", "(HL)", "E");
    GENERATE________ op1("INC", "HL");
    GENERATE________ op2("LD", "(HL)", "D");
  } else if(IS_CONST(p) || IS_ADDRGP(p)) {
    dst = VAL(p);
  } else if(IS_INDIR(p)) {
    int sreg = LEFT_REG(p);
    GENERATE________ op1("PUSH", "HL");
    GENERATE________ op2("LD", "H", hreg[sreg]);
    GENERATE________ op2("LD", "L", lreg[sreg]);
    GENERATE________ op2("LD", "(HL)", "E");
    GENERATE________ op1("INC", "HL");
    GENERATE________ op2("LD", "(HL)", "D");
    GENERATE________ op1("INC", "HL");
    GENERATE________ op1("POP", "DE");
    GENERATE________ op2("LD", "(HL)", "E");
    GENERATE________ op1("INC", "HL");
    GENERATE________ op2("LD", "(HL)", "D");  
  } else {
    dst = xreg[REG(p)];
  }
  if(dst) {
    GENERATE________ op2("LD", "A", "H");
    GENERATE________ op2("LD", STR("(#%s+3)", dst), "A");
    GENERATE________ op2("LD", "A", "L");
    GENERATE________ op2("LD", STR("(#%s+2)", dst), "A");
    GENERATE________ op2("LD", "A", "D");
    GENERATE________ op2("LD", STR("(#%s+1)", dst), "A");
    GENERATE________ op2("LD", "A", "E");
    GENERATE________ op2("LD", STR("(#%s)", dst), "A");
  }
#else
  char *dst = NULL;
  if(IS_ADDRFP(p) || IS_ADDRLP(p)) {
    int off = const_val(p);
    GENERATE________ op2("LD", STR("%d(IX)", off+3), "H");
    GENERATE________ op2("LD", STR("%d(IX)", off+2), "L");
    GENERATE________ op2("LD", STR("%d(IX)", off+1), "D");
    GENERATE________ op2("LD", STR("%d(IX)", off), "E");
  } else if(IS_CONST(p) || IS_ADDRGP(p)) {
    dst = VAL(p);
  } else if(IS_INDIR(p)) {
    int sreg = LEFT_REG(p);
    if(sreg != IY) {
      GENERATE________ op1("PUSH", wreg[sreg]);
      GENERATE________ op1("POP", "IY");
    }
    GENERATE________ op2("LD", "3(IY)", "H");
    GENERATE________ op2("LD", "2(IY)", "L");
    GENERATE________ op2("LD", "1(IY)", "D");
    GENERATE________ op2("LD", "0(IY)", "E");
  } else {
    dst = xreg[REG(p)];
  }
  if(dst) {
    GENERATE________ op2("LD", STR("(%s+2)", dst), "HL");
    GENERATE________ op2("LD", STR("(%s)", dst), "DE");
  }
#endif
}

int const_val(Node p)
{
  if(generic(p->op) == ADDRF || generic(p->op) == ADDRL) {
    assert(p->syms[0] != NULL);
    return p->syms[0]->x.offset;
  }
  if(generic(p->op) == CNST) {
    assert(p->syms[0] != NULL);
    if(optype(p->op) == I)
      return p->syms[0]->u.c.v.i;
    else if(optype(p->op) == U || optype(p->op) == P)
      return p->syms[0]->u.c.v.u;
  }
  if(generic(p->op) == CALL) {
    assert(p->syms[0] != NULL);
    return p->syms[0]->u.c.v.i;
  }
  if(generic(p->op) == INDIR) {
    assert(p->syms[RX]->u.t.cse->syms[0] != NULL);
    if(optype(p->op) == I)
      return p->syms[RX]->u.t.cse->syms[0]->u.c.v.i;
    else if(optype(p->op) == U || optype(p->op) == P)
      return p->syms[RX]->u.t.cse->syms[0]->u.c.v.u;
  }
  assert(0);
  return 0;
}

static int tmp8(int reg)
{
  if((freereg&reg8[reg]->x.regnode->mask) == reg8[reg]->x.regnode->mask) {
    return 1;
  }
  return 0;
}

static int tmp16(int reg)
{
  if((freereg&reg16[reg]->x.regnode->mask) == reg16[reg]->x.regnode->mask) {
    return 1;
  }
  return 0;
}

static int ckstack(Node p, int n) {
  int i;

  for(i = 0; i < NELEMS(p->x.kids) && p->x.kids[i]; i++)
    if(opsize(p->x.kids[i]->op) == 4)
      n--;
  if(opsize(p->op) == 4 && p->count > 0)
    n++;
  if(n > 8)
    error("expression too complicated\n");
  debug(fprint(stderr, "(ckstack(%x)=%d)\n", p, n));
  assert(n >= 0);
  return n;
}

#ifdef GAMEBOY
#else
static Symbol argreg(Symbol f, int op, int prev, int argno) {
  if(variadic(f->type) || optype(op) == B)
    return NULL;
  if(argno == 0) {
    if(opsize(op) == 1)
      return reg8[_E];
    else if(opsize(op) == 2)
      return reg16[DE];
    else if(opsize(op) == 4)
      return reg32[0];
  } else if(argno == 1 && optype(prev) != B && opsize(prev) <= 2) {
    if(opsize(op) == 1)
      return reg8[_C];
    else if(opsize(op) == 2)
      return reg16[BC];
  }
  return NULL;
}
#endif

static void doarg(Node p) {
  static int argno;

  assert(p && p->syms[0]);

  if(argoffset == 0)
    argno = 0;
  p->x.argno = argno++;
  p->syms[RX] = intconst(mkactual(1, p->syms[0]->u.c.v.i));
}

static void blkfetch(int k, int off, int reg, int tmp) {}

static void blkstore(int k, int off, int reg, int tmp) {}

static void blkloop(int dreg, int doff, int sreg, int soff, int size, int tmps[]) {}

static void local(Symbol p) {
  if(p->type->size == 4)
    p->sclass = AUTO;
  if(askregvar(p, rmap(ttob(p->type))) == 0)
    mkauto(p);
}

static void function(Symbol f, Symbol caller[], Symbol callee[], int ncalls) {
  int i;
  unsigned um;
#ifdef GAMEBOY
#else
  unsigned argmask = 0;
  Symbol r, argregs[2];
#endif

  usedmask[IREG] = usedmask[FREG] = 0;
  freemask[IREG] = freemask[FREG] = ~(unsigned)0;
  offset = 2;
  /* offset = return address */

  for(i = 0; callee[i]; i++) {
    Symbol p = callee[i];
    Symbol q = caller[i];
    assert(q);

#ifdef GAMEBOY
    p->x.offset = q->x.offset = offset;
    p->x.name = q->x.name = stringd(offset);
    p->sclass = q->sclass = AUTO;
#else
    p->x.offset = q->x.offset = offset;
    p->x.name = q->x.name = stringd(offset);
    p->sclass = q->sclass = AUTO;
    r = argreg(f, ttob(q->type), i ? ttob(caller[i-1]->type): 0, i);
    if(i < 2)
      argregs[i] = r;
    if(!r) {
      p->sclass = AUTO;
    } else if(r && ncalls == 0 && !isstruct(q->type) && !p->addressed &&
	      q->type->size <= 2) {
      p->sclass = q->sclass = REGISTER;
      askregvar(p, r);
      assert(p->x.regnode && p->x.regnode->vbl == p);
      q->x = p->x;
      q->type = p->type;
    }
    if(r && q->type->size <= 2) {
      argmask |= r->x.regnode->mask;
    } else if(r && q->type->size == 4) {
      argmask |= reg16[BC]->x.regnode->mask | reg16[DE]->x.regnode->mask;
    }
    if(!isstruct(freturn(f->type)) && freturn(f->type)->size > 2) {
      argmask |= reg16[BC]->x.regnode->mask;
    }
#endif
    offset += q->type->size;
  }
  offset = maxoffset = 0;
  gencode(caller, callee);
  GENERATE________ label(STR("_start%s:", f->x.name));
  GENERATE________ label(STR("%s:", f->x.name));
  if(usedmask[FREG] & 0x01)
    GENERATE________ op1(".globl", ".lreg0");
  if(usedmask[FREG] & 0x02)
    GENERATE________ op1(".globl", ".lreg1");
  if(usedmask[FREG] & 0x04)
    GENERATE________ op1(".globl", ".lreg2");
  if(usedmask[FREG] & 0x08)
    GENERATE________ op1(".globl", ".lreg3");
  if(usedmask[FREG] & 0x10)
    GENERATE________ op1(".globl", ".lreg4");
  if(usedmask[FREG] & 0x20)
    GENERATE________ op1(".globl", ".lreg5");
  if(usedmask[FREG] & 0x40)
    GENERATE________ op1(".globl", ".lreg6");
  if(usedmask[FREG] & 0x80)
    GENERATE________ op1(".globl", ".lreg7");
  um = usedmask[IREG];
  framesize = maxoffset;
#ifdef GAMEBOY
  offsetsp(-framesize);
  if((um & reg16[BC]->x.regnode->mask) && strcmp(f->x.name, "_main")) {
    argstack += 2;
    GENERATE________ op1("PUSH", "BC");
  }
#else
  GENERATE________ op1("CALL", ".c_entry");
  GENERATE________ op1(".dw", STR("%d", framesize));
  for(i = 0; i < 2 && callee[i]; i++) {
    r = argregs[i];
    if(r && r->x.regnode != callee[i]->x.regnode) {
      Symbol out = callee[i];
      Symbol in  = caller[i];
      int sreg, off;

      assert(out && in && r->x.regnode);
      assert(out->sclass != REGISTER || out->x.regnode);

      sreg = r->x.regnode->number;
      off = in->x.offset + framesize;
      if(in->type->size == 1) {
	GENERATE________ op2("LD", STR("%d(IX)", off), breg[sreg]);
      } else if(in->type->size == 2) {
	GENERATE________ op2("LD", STR("%d(IX)", off), lreg[sreg]);
	off++;
	GENERATE________ op2("LD", STR("%d(IX)", off), hreg[sreg]);
      } else if(in->type->size == 4) {
	GENERATE________ op2("LD", STR("%d(IX)", off), "E");
	off++;
	GENERATE________ op2("LD", STR("%d(IX)", off), "D");
	off++;
	GENERATE________ op2("LD", STR("%d(IX)", off), "C");
	off++;
	GENERATE________ op2("LD", STR("%d(IX)", off), "B");
      }
    }
  }
  if((argmask & reg16[BC]->x.regnode->mask) == 0 &&
     (um & reg16[BC]->x.regnode->mask) && strcmp(f->x.name, "_main")) {
    argstack += 2;
    GENERATE________ op1("PUSH", "BC");
  }
  if((argmask & reg16[DE]->x.regnode->mask) == 0 &&
     (um & reg16[DE]->x.regnode->mask) && strcmp(f->x.name, "_main")) {
    argstack += 2;
    GENERATE________ op1("PUSH", "DE");
  }
#endif
  emitcode();
#ifdef GAMEBOY
  if((um & reg16[BC]->x.regnode->mask) && strcmp(f->x.name, "_main")) {
    argstack -= 2;
    GENERATE________ op1("POP", "BC");
  }
  offsetsp(framesize);
#else
  if((argmask & reg16[DE]->x.regnode->mask) == 0 &&
     (um & reg16[DE]->x.regnode->mask) && strcmp(f->x.name, "_main")) {
    argstack -= 2;
    GENERATE________ op1("POP", "DE");
  }
  if((argmask & reg16[BC]->x.regnode->mask) == 0 &&
     (um & reg16[BC]->x.regnode->mask) && strcmp(f->x.name, "_main")) {
    argstack -= 2;
    GENERATE________ op1("POP", "BC");
  }
#endif
  assert(argstack == 0);
#ifdef GAMEBOY
  GENERATE________ op0("RET");
#else
  GENERATE________ op1("JP", ".c_exit");
#endif
  GENERATE________ label(STR("_end%s:", f->x.name));
  generate();
}

static void defsymbol(Symbol p) {
  if(p->scope >= LOCAL && p->sclass == STATIC)
    p->x.name = stringf(".L%d", genlabel(1));
  else if(p->generated)
    p->x.name = stringf(".L%s", p->name);
  else if(p->scope == GLOBAL || p->sclass == EXTERN)
    p->x.name = stringf("_%s", p->name);
  else
    p->x.name = p->name;
}

static void address(Symbol q, Symbol p, long n) {
  if(p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN)
    q->x.name = stringf("%s%s%D", p->x.name, n >= 0 ? "+" : "", n);
  else {
    assert(n <= INT_MAX && n >= INT_MIN);
    q->x.offset = p->x.offset + n;
    q->x.name = stringd(q->x.offset);
  }
}

#define MAXFLOAT 0x7FFFFFFFUL
#define MINFLOAT 0x00800000UL
#define NEGFLOAT 0x80000000UL
#define ZEROFLOAT 0x00000000UL

static void defconst(int suffix, int size, Value v) {
  if(suffix == I && size == 1)
    GENERATE________ op1(".db", STR("%d", v.i));
  else if(suffix == I && size == 2)
    GENERATE________ op1(".dw", STR("%d", v.i));
  else if(suffix == I && size == 4)
    GENERATE________ op1(".dw", STR("0x%x,0x%x", v.i&0xFFFF, (v.i>>16)&0xFFFF));
  else if(suffix == U && size == 1)
    GENERATE________ op1(".db", STR("0x%x", v.u));
  else if(suffix == U && size == 2)
    GENERATE________ op1(".dw", STR("0x%x", v.u));
  else if(suffix == U && size == 4)
    GENERATE________ op1(".dw", STR("0x%x,0x%x", v.u&0xFFFF, (v.u>>16)&0xFFFF));
  else if(suffix == P && size == 2)
    GENERATE________ op1(".dw", STR("0x%x", v.p));
  else if(suffix == F && size == 4) {
    double d, f;
    unsigned long u, i;
    unsigned int exp;

    d = v.d;
    u = 0;
    exp = 64+1;

    if(d == 0.0) {
      /* ZERO */
      u = ZEROFLOAT;
      goto output;
    }
    if(d < 0.0) {
      u |= NEGFLOAT;
      d = -d;
    }
    while(d >= 2.0) {
      d /= 2.0;
      if(exp == 127) {
	/* MAX */
	fprintf(stderr, "WARNING: overflow in floating point constant %e\n", (float)v.d);
	fprintf(stderr, "MAXFLOAT will be used\n");
	u |= MAXFLOAT;
	goto output;
      }
      exp++;
    }
    while(d < 1.0) {
      d *= 2.0;
      if(exp == 0) {
	/* MIN */
	fprintf(stderr, "WARNING: underflow in floating point constant %e\n", (float)v.d);
	fprintf(stderr, "MINFLOAT will be used\n");
	u |= MINFLOAT;
	goto output;
      }
      exp--;
    }
    u |= ((exp&0x07F)<<24);
    f = 1.0;
    for(i = 0x00800000UL; i > 0; i >>= 1) {
      if(d >= f) {
	u |= i;
	d -= f;
      }
      f /= 2.0;
    }
output:
    GENERATE________ comment(STR("Float/double %e", (float)v.d));
    GENERATE________ op1(".db", STR("0x%x", u&0xFF));
    GENERATE________ op1(".db", STR("0x%x", (u>>8)&0xFF));
    GENERATE________ op1(".db", STR("0x%x", (u>>16)&0xFF));
    GENERATE________ op1(".db", STR("0x%x", (u>>24)&0xFF));
  } else assert(0);
}

static void defaddress(Symbol p) {
  GENERATE________ op1(".dw", p->x.name);
}

static void defstring(int n, char *str) {
  char *s;
  for(s = str; s < str + n; s++)
    GENERATE________ op1(".db", STR("%d", (*s)&0377));
}

static void export(Symbol p) {
#ifdef GAMEBOY
  if(!HARDWARE_REG(p->x.name))
#endif
    GENERATE________ op1(".globl", p->x.name);
}

static void import(Symbol p) {
  if(p->ref > 0)
#ifdef GAMEBOY
    if(!HARDWARE_REG(p->x.name))
#endif
      GENERATE________ op1(".globl", p->x.name);
}

static void global(Symbol p) {
  GENERATE________ label(STR("%s:", p->x.name));
  if(p->u.seg == BSS)
    GENERATE________ op1(".blkb", STR("%d", p->type->size));
}

static void space(int n) {
  if(cseg != BSS)
    GENERATE________ op1(".blkb", STR("%d", n));
}

static void stabinit(char *file, int argc, char *argv[]) {
  if(file) {
    currentfile = file;
    GENERATE________ comment(STR("File %s", currentfile));
    srcfp = fopen(currentfile, "r");
    srcpos = 0;
    currentline = 0;
  }
}

static void stabline(Coordinate *cp) {
  if(cp->file && cp->file != currentfile) {
    currentfile = cp->file;
    GENERATE________ comment(STR("File %s", currentfile));
    if(srcfp)
      fclose(srcfp);
    currentfile = cp->file;
    srcfp = fopen(currentfile, "r");
    srcpos = 0;
    currentline = 0;
  }
  if(currentline != cp->y && srcfp) {
    char buf[512];
    if(srcpos > cp->y) {
      rewind(srcfp);
      srcpos = 0;
    }
    for(; srcpos < cp->y; srcpos++)
      if(fgets(buf, sizeof buf, srcfp) == NULL) {
	fclose(srcfp);
	srcfp = NULL;
	break;
      }
    if(srcfp && srcpos == cp->y) {
      char *c = strchr(buf, '\n');
      if(c)
	*c = '\0';
      GENERATE________ comment(STR("%04d: %s", cp->y, buf));
    }
  }
  currentline = cp->y;
}

static void stabend(Coordinate *cp, Symbol p, Coordinate **cpp, Symbol *sp, Symbol *stab) {
  if(srcfp)
    fclose(srcfp);
}

#ifdef GAMEBOY
Interface z80gbIR8 = {
#else
Interface z80IR8 = {
#endif
  1, 1, 0,  /* char */
  1, 1, 0,  /* short */
  1, 1, 0,  /* int */
  2, 1, 1,  /* long */
  4, 1, 1,  /* long long */
  4, 1, 1,  /* float */
  4, 1, 1,  /* double */
  4, 1, 1,  /* long double */
  2, 1, 0,  /* T* */
  0, 1, 0,  /* struct */
  1,		  /* little_endian */
  0,		  /* mulops_calls: mul/div/mod are library routines */
  0,		  /* wants_callb */
  1,		  /* wants_argb */
  0,		  /* left_to_right */
  0,		  /* wants_dag */
  0,		  /* unsigned_char */
  address,
  blockbeg,
  blockend,
  defaddress,
  defconst,
  defstring,
  defsymbol,
  emit,
  export,
  function,
  gen,
  global,
  import,
  local,
  progbeg,
  progend,
  segment,
  space,
  NULL, stabend, NULL, stabinit, stabline, NULL, NULL,
  {
    2,		/* max_unaligned_load */
    rmap,
    blkfetch,
    blkstore,
    blkloop,
    _label,
    _rule,
    _nts,
    _kids,
    _string,
    _templates,
    _isinstruction,
    _ntname,
    emit2,
    doarg,
    target,
    clobber
  }
};

#ifdef GAMEBOY
Interface z80gbIR16 = {
#else
Interface z80IR16 = {
#endif
  1, 1, 0,  /* char */
  1, 1, 0,  /* short */
  2, 1, 0,  /* int */
  4, 1, 1,  /* long */
  4, 1, 1,  /* long long */
  4, 1, 1,  /* float */
  4, 1, 1,  /* double */
  4, 1, 1,  /* long double */
  2, 1, 0,  /* T* */
  0, 1, 0,  /* struct */
  1,		  /* little_endian */
  0,		  /* mulops_calls: mul/div/mod are library routines */
  0,		  /* wants_callb */
  1,		  /* wants_argb */
  0,		  /* left_to_right */
  0,		  /* wants_dag */
  0,		  /* unsigned_char */
  address,
  blockbeg,
  blockend,
  defaddress,
  defconst,
  defstring,
  defsymbol,
  emit,
  export,
  function,
  gen,
  global,
  import,
  local,
  progbeg,
  progend,
  segment,
  space,
  NULL, stabend, NULL, stabinit, stabline, NULL, NULL,
  {
    2,		/* max_unaligned_load */
    rmap,
    blkfetch,
    blkstore,
    blkloop,
    _label,
    _rule,
    _nts,
    _kids,
    _string,
    _templates,
    _isinstruction,
    _ntname,
    emit2,
    doarg,
    target,
    clobber
  }
};