#define INTTMP 0x03f0
#define INTVAR 0x0300
#define FLTTMP 0x0e
#define FLTVAR 0xf0

#define savelist	(0xd800) /* fp, ip, lr, pc */
#define reslist		(0xa800) /* fp, sp, pc */

#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))

#define readsreg(p) \
        (generic((p)->op)==INDIR && (p)->kids[0]->op==VREG+P)
#define setsrc(d) ((d) && (d)->x.regnode && \
        (d)->x.regnode->set == src->x.regnode->set && \
        (d)->x.regnode->mask&src->x.regnode->mask)

#define relink(a, b) ((b)->x.prev = (a), (a)->x.next = (b))

#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 STATE_LABEL(p) ((p)->x.state)
static void address(Symbol, Symbol, int);
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  imm(Node);
static int  imm_const(unsigned);
static int  bitcount(unsigned);
static void arm_blkcopy(int, int, int, int, int);
static void arm_mov(int, int);
static void arm_add(int, int, int);
static char *reglist(unsigned);

static Symbol ireg[32], freg[32];
static Symbol iregw, fregw;
static int cseg;
static int sizeisave;
static int bigargs;
/*
generated at Thu Mar  5 11:13:43 1998
by $Id: lburg.c,v 2.7 1995/12/20 19:29:25 drh 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 _con12_NT 4
#define _rc_NT 5
#define _rc5_NT 6
#define _bra_NT 7
#define _addr_NT 8
#define _spill_NT 9

static char *_ntname[] = {
	0,
	"stmt",
	"reg",
	"con",
	"con12",
	"rc",
	"rc5",
	"bra",
	"addr",
	"spill",
	0
};

struct _state {
	short cost[10];
	struct {
		unsigned int _stmt:7;
		unsigned int _reg:7;
		unsigned int _con:3;
		unsigned int _con12:3;
		unsigned int _rc:4;
		unsigned int _rc5:3;
		unsigned int _bra:2;
		unsigned int _addr:4;
		unsigned int _spill:1;
	} rule;
};

static short _nts_0[] = { _reg_NT, 0 };
static short _nts_1[] = { 0 };
static short _nts_2[] = { _con_NT, 0 };
static short _nts_3[] = { _reg_NT, _rc5_NT, 0 };
static short _nts_4[] = { _reg_NT, _con12_NT, 0 };
static short _nts_5[] = { _reg_NT, _reg_NT, 0 };
static short _nts_6[] = { _addr_NT, 0 };
static short _nts_7[] = { _addr_NT, _reg_NT, 0 };
static short _nts_8[] = { _rc_NT, 0 };
static short _nts_9[] = { _reg_NT, _rc_NT, 0 };
static short _nts_10[] = { _bra_NT, 0 };
static short _nts_11[] = { _spill_NT, _reg_NT, 0 };

static short *_nts[] = {
	0,	/* 0 */
	_nts_0,	/* 1 */
	_nts_1,	/* 2 */
	_nts_1,	/* 3 */
	_nts_1,	/* 4 */
	_nts_1,	/* 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_1,	/* 20 */
	_nts_1,	/* 21 */
	_nts_1,	/* 22 */
	_nts_1,	/* 23 */
	_nts_1,	/* 24 */
	_nts_1,	/* 25 */
	_nts_1,	/* 26 */
	_nts_1,	/* 27 */
	_nts_1,	/* 28 */
	_nts_1,	/* 29 */
	_nts_1,	/* 30 */
	_nts_1,	/* 31 */
	_nts_1,	/* 32 */
	_nts_1,	/* 33 */
	_nts_2,	/* 34 */
	_nts_1,	/* 35 */
	_nts_1,	/* 36 */
	_nts_1,	/* 37 */
	_nts_0,	/* 38 */
	_nts_1,	/* 39 */
	_nts_1,	/* 40 */
	_nts_1,	/* 41 */
	_nts_1,	/* 42 */
	_nts_1,	/* 43 */
	_nts_1,	/* 44 */
	_nts_1,	/* 45 */
	_nts_1,	/* 46 */
	_nts_1,	/* 47 */
	_nts_1,	/* 48 */
	_nts_1,	/* 49 */
	_nts_1,	/* 50 */
	_nts_1,	/* 51 */
	_nts_0,	/* 52 */
	_nts_3,	/* 53 */
	_nts_3,	/* 54 */
	_nts_3,	/* 55 */
	_nts_3,	/* 56 */
	_nts_1,	/* 57 */
	_nts_2,	/* 58 */
	_nts_0,	/* 59 */
	_nts_0,	/* 60 */
	_nts_0,	/* 61 */
	_nts_0,	/* 62 */
	_nts_0,	/* 63 */
	_nts_0,	/* 64 */
	_nts_0,	/* 65 */
	_nts_0,	/* 66 */
	_nts_0,	/* 67 */
	_nts_0,	/* 68 */
	_nts_0,	/* 69 */
	_nts_0,	/* 70 */
	_nts_0,	/* 71 */
	_nts_0,	/* 72 */
	_nts_0,	/* 73 */
	_nts_0,	/* 74 */
	_nts_0,	/* 75 */
	_nts_0,	/* 76 */
	_nts_0,	/* 77 */
	_nts_4,	/* 78 */
	_nts_4,	/* 79 */
	_nts_4,	/* 80 */
	_nts_1,	/* 81 */
	_nts_1,	/* 82 */
	_nts_5,	/* 83 */
	_nts_5,	/* 84 */
	_nts_5,	/* 85 */
	_nts_6,	/* 86 */
	_nts_6,	/* 87 */
	_nts_6,	/* 88 */
	_nts_6,	/* 89 */
	_nts_6,	/* 90 */
	_nts_6,	/* 91 */
	_nts_6,	/* 92 */
	_nts_6,	/* 93 */
	_nts_6,	/* 94 */
	_nts_7,	/* 95 */
	_nts_7,	/* 96 */
	_nts_7,	/* 97 */
	_nts_7,	/* 98 */
	_nts_7,	/* 99 */
	_nts_7,	/* 100 */
	_nts_7,	/* 101 */
	_nts_7,	/* 102 */
	_nts_7,	/* 103 */
	_nts_5,	/* 104 */
	_nts_0,	/* 105 */
	_nts_0,	/* 106 */
	_nts_0,	/* 107 */
	_nts_0,	/* 108 */
	_nts_0,	/* 109 */
	_nts_0,	/* 110 */
	_nts_0,	/* 111 */
	_nts_0,	/* 112 */
	_nts_0,	/* 113 */
	_nts_0,	/* 114 */
	_nts_0,	/* 115 */
	_nts_0,	/* 116 */
	_nts_8,	/* 117 */
	_nts_8,	/* 118 */
	_nts_9,	/* 119 */
	_nts_9,	/* 120 */
	_nts_9,	/* 121 */
	_nts_9,	/* 122 */
	_nts_9,	/* 123 */
	_nts_9,	/* 124 */
	_nts_9,	/* 125 */
	_nts_9,	/* 126 */
	_nts_9,	/* 127 */
	_nts_9,	/* 128 */
	_nts_9,	/* 129 */
	_nts_9,	/* 130 */
	_nts_9,	/* 131 */
	_nts_5,	/* 132 */
	_nts_5,	/* 133 */
	_nts_9,	/* 134 */
	_nts_9,	/* 135 */
	_nts_9,	/* 136 */
	_nts_5,	/* 137 */
	_nts_5,	/* 138 */
	_nts_5,	/* 139 */
	_nts_5,	/* 140 */
	_nts_5,	/* 141 */
	_nts_5,	/* 142 */
	_nts_5,	/* 143 */
	_nts_5,	/* 144 */
	_nts_5,	/* 145 */
	_nts_5,	/* 146 */
	_nts_5,	/* 147 */
	_nts_5,	/* 148 */
	_nts_1,	/* 149 */
	_nts_10,	/* 150 */
	_nts_0,	/* 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_9,	/* 161 */
	_nts_9,	/* 162 */
	_nts_9,	/* 163 */
	_nts_5,	/* 164 */
	_nts_5,	/* 165 */
	_nts_5,	/* 166 */
	_nts_5,	/* 167 */
	_nts_5,	/* 168 */
	_nts_5,	/* 169 */
	_nts_5,	/* 170 */
	_nts_5,	/* 171 */
	_nts_5,	/* 172 */
	_nts_5,	/* 173 */
	_nts_5,	/* 174 */
	_nts_5,	/* 175 */
	_nts_0,	/* 176 */
	_nts_0,	/* 177 */
	_nts_0,	/* 178 */
	_nts_0,	/* 179 */
	_nts_0,	/* 180 */
	_nts_0,	/* 181 */
	_nts_10,	/* 182 */
	_nts_10,	/* 183 */
	_nts_10,	/* 184 */
	_nts_10,	/* 185 */
	_nts_10,	/* 186 */
	_nts_10,	/* 187 */
	_nts_0,	/* 188 */
	_nts_0,	/* 189 */
	_nts_0,	/* 190 */
	_nts_0,	/* 191 */
	_nts_0,	/* 192 */
	_nts_0,	/* 193 */
	_nts_0,	/* 194 */
	_nts_0,	/* 195 */
	_nts_0,	/* 196 */
	_nts_0,	/* 197 */
	_nts_0,	/* 198 */
	_nts_0,	/* 199 */
	_nts_1,	/* 200 */
	_nts_11,	/* 201 */
	_nts_11,	/* 202 */
	_nts_11,	/* 203 */
	_nts_11,	/* 204 */
	_nts_11,	/* 205 */
	_nts_11,	/* 206 */
	_nts_11,	/* 207 */
	_nts_11,	/* 208 */
	_nts_11,	/* 209 */
};

static char *_templates[] = {
/* 0 */	0,
/* 1 */	"",	/* stmt: reg */
/* 2 */	"# read register\n",	/* reg: INDIRI1(VREGP) */
/* 3 */	"# read register\n",	/* reg: INDIRU1(VREGP) */
/* 4 */	"# read register\n",	/* reg: INDIRI2(VREGP) */
/* 5 */	"# read register\n",	/* reg: INDIRU2(VREGP) */
/* 6 */	"# read register\n",	/* reg: INDIRF4(VREGP) */
/* 7 */	"# read register\n",	/* reg: INDIRI4(VREGP) */
/* 8 */	"# read register\n",	/* reg: INDIRP4(VREGP) */
/* 9 */	"# read register\n",	/* reg: INDIRU4(VREGP) */
/* 10 */	"# read register\n",	/* reg: INDIRF8(VREGP) */
/* 11 */	"# write register\n",	/* stmt: ASGNI1(VREGP,reg) */
/* 12 */	"# write register\n",	/* stmt: ASGNU1(VREGP,reg) */
/* 13 */	"# write register\n",	/* stmt: ASGNI2(VREGP,reg) */
/* 14 */	"# write register\n",	/* stmt: ASGNU2(VREGP,reg) */
/* 15 */	"# write register\n",	/* stmt: ASGNF4(VREGP,reg) */
/* 16 */	"# write register\n",	/* stmt: ASGNI4(VREGP,reg) */
/* 17 */	"# write register\n",	/* stmt: ASGNP4(VREGP,reg) */
/* 18 */	"# write register\n",	/* stmt: ASGNU4(VREGP,reg) */
/* 19 */	"# write register\n",	/* stmt: ASGNF8(VREGP,reg) */
/* 20 */	"%a",	/* con: CNSTI1 */
/* 21 */	"%a",	/* con: CNSTU1 */
/* 22 */	"%a",	/* con: CNSTI2 */
/* 23 */	"%a",	/* con: CNSTU2 */
/* 24 */	"%a",	/* con: CNSTI4 */
/* 25 */	"%a",	/* con: CNSTU4 */
/* 26 */	"%a",	/* con: CNSTP4 */
/* 27 */	"%a",	/* con12: CNSTI1 */
/* 28 */	"%a",	/* con12: CNSTU1 */
/* 29 */	"%a",	/* con12: CNSTI2 */
/* 30 */	"%a",	/* con12: CNSTU2 */
/* 31 */	"%a",	/* con12: CNSTI4 */
/* 32 */	"%a",	/* con12: CNSTU4 */
/* 33 */	"%a",	/* con12: CNSTP4 */
/* 34 */	"# arbitrary constant\n",	/* reg: con */
/* 35 */	"\tldr\t%c, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%a\n",	/* reg: ADDRGP4 */
/* 36 */	"# arbitrary offset\n",	/* reg: ADDRFP4 */
/* 37 */	"sp, #%a+%F",	/* reg: ADDRLP4 */
/* 38 */	"%0",	/* rc: reg */
/* 39 */	" #%a",	/* rc: CNSTI1 */
/* 40 */	" #%a",	/* rc: CNSTU1 */
/* 41 */	" #%a",	/* rc: CNSTI2 */
/* 42 */	" #%a",	/* rc: CNSTU2 */
/* 43 */	" #%a",	/* rc: CNSTI4 */
/* 44 */	" #%a",	/* rc: CNSTU4 */
/* 45 */	" #%a",	/* rc: CNSTP4 */
/* 46 */	" #%a",	/* rc5: CNSTI1 */
/* 47 */	" #%a",	/* rc5: CNSTU1 */
/* 48 */	" #%a",	/* rc5: CNSTI2 */
/* 49 */	" #%a",	/* rc5: CNSTU2 */
/* 50 */	" #%a",	/* rc5: CNSTI4 */
/* 51 */	" #%a",	/* rc5: CNSTU4 */
/* 52 */	"%0",	/* rc5: reg */
/* 53 */	"%0, asl %1",	/* rc: LSHI4(reg,rc5) */
/* 54 */	"%0, lsl %1",	/* rc: LSHU4(reg,rc5) */
/* 55 */	"%0, asr %1",	/* rc: RSHI4(reg,rc5) */
/* 56 */	"%0, lsr %1",	/* rc: RSHU4(reg,rc5) */
/* 57 */	"%a",	/* bra: ADDRGP4 */
/* 58 */	"%0",	/* bra: con */
/* 59 */	"\tmov\t%c, %0, lsl#8*(4-%a)\n\tmov\t%c, %c, asr#8*(4-%a)\n",	/* reg: CVII4(reg) */
/* 60 */	"\tldrb\t%c, [%0, #0]\n\tmov\t%c, %c, lsl#24\n\tmov\t%c, %c, asr#24\n",	/* reg: CVII4(INDIRI1(reg)) */
/* 61 */	"\tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n\tmov\t%c, %c, lsl#16\n\tmov\t%c, %c, asr#16\n",	/* reg: CVII4(INDIRI2(reg)) */
/* 62 */	"\tand\t%c, %0, #&ff\n",	/* reg: CVUI4(reg) */
/* 63 */	"\tand\t%c, %0, #&ff\n\tand\t%c, %0, #&ff00\n",	/* reg: CVUI4(reg) */
/* 64 */	"\tldrb\t%c, [%0, #0]\n",	/* reg: CVUI4(INDIRU1(reg)) */
/* 65 */	"\tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n",	/* reg: CVUI4(INDIRU2(reg)) */
/* 66 */	"\tand\t%c, %0, #&ff\n",	/* reg: CVUU4(reg) */
/* 67 */	"\tand\t%c, %0, #&ff\n\tand\t%c, %0, #&ff00\n",	/* reg: CVUU4(reg) */
/* 68 */	"\tldrb\t%c, [%0, #0]\n",	/* reg: CVUU4(INDIRU1(reg)) */
/* 69 */	"\tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n",	/* reg: CVUU4(INDIRU2(reg)) */
/* 70 */	"%0",	/* reg: CVFF4(reg) */
/* 71 */	"\tmvfs\t%c, %0\n",	/* reg: CVFF4(reg) */
/* 72 */	"%0",	/* reg: CVFF8(reg) */
/* 73 */	"\tmvfd\t%c, %0\n",	/* reg: CVFF8(reg) */
/* 74 */	"\tfix\t%c, %0\n",	/* reg: CVFI4(reg) */
/* 75 */	"\tflts\t%c, %0\n",	/* reg: CVIF4(reg) */
/* 76 */	"\tfltd\t%c, %0\n",	/* reg: CVIF8(reg) */
/* 77 */	"%0, #0",	/* addr: reg */
/* 78 */	"%0, #%1",	/* addr: ADDI4(reg,con12) */
/* 79 */	"%0, #%1",	/* addr: ADDU4(reg,con12) */
/* 80 */	"%0, #%1",	/* addr: ADDP4(reg,con12) */
/* 81 */	"# arbitrary offset\n",	/* addr: ADDRFP4 */
/* 82 */	"sp, #%a+%F",	/* addr: ADDRLP4 */
/* 83 */	"%0, %1",	/* addr: ADDI4(reg,reg) */
/* 84 */	"%0, %1",	/* addr: ADDU4(reg,reg) */
/* 85 */	"%0, %1",	/* addr: ADDP4(reg,reg) */
/* 86 */	"\tldrb\t%c, [%0, #0]\n\tmov\t%c, %c, lsl#24\n\tmov\t%c, %c, asr#24\n",	/* reg: INDIRI1(addr) */
/* 87 */	"\tldrb\t%c, [%0, #0]\n",	/* reg: INDIRU1(addr) */
/* 88 */	"\tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n\tmov\t%c, %c, lsl#16\n\tmov\t%c, %c, asr#16\n",	/* reg: INDIRI2(addr) */
/* 89 */	"\tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n",	/* reg: INDIRU2(addr) */
/* 90 */	"\tldr\t%c, [%0, #0]\n",	/* reg: INDIRI4(addr) */
/* 91 */	"\tldr\t%c, [%0, #0]\n",	/* reg: INDIRU4(addr) */
/* 92 */	"\tldr\t%c, [%0, #0]\n",	/* reg: INDIRP4(addr) */
/* 93 */	"\tldfs\t%c, [%0, #0]\n",	/* reg: INDIRF4(addr) */
/* 94 */	"\tldfd\t%c, [%0, #0]\n",	/* reg: INDIRF8(addr) */
/* 95 */	"\tstrb\t%1, [%0, #0]\n",	/* stmt: ASGNI1(addr,reg) */
/* 96 */	"\tstrb\t%1, [%0, #0]\n",	/* stmt: ASGNU1(addr,reg) */
/* 97 */	"\tstrb\t%1, [%0, #0]\n\tmov\tip, %1, lsr#8\n\tstrb\tip, [%0, #1]\n",	/* stmt: ASGNI2(addr,reg) */
/* 98 */	"\tstrb\t%1, [%0, #0]\n\tmov\tip, %1, lsr#8\n\tstrb\tip, [%0, #1]\n",	/* stmt: ASGNU2(addr,reg) */
/* 99 */	"\tstr\t%1, [%0, #0]\n",	/* stmt: ASGNI4(addr,reg) */
/* 100 */	"\tstr\t%1, [%0, #0]\n",	/* stmt: ASGNU4(addr,reg) */
/* 101 */	"\tstr\t%1, [%0, #0]\n",	/* stmt: ASGNP4(addr,reg) */
/* 102 */	"\tstfs\t%1, [%0, #0]\n",	/* stmt: ASGNF4(addr,reg) */
/* 103 */	"\tstfd\t%1, [%0, #0]\n",	/* stmt: ASGNF8(addr,reg) */
/* 104 */	"# asgnb %0 %1\n",	/* stmt: ASGNB(reg,INDIRB(reg)) */
/* 105 */	"\tmov\t%c, %0\n",	/* reg: LOADI1(reg) */
/* 106 */	"\tmov\t%c, %0\n",	/* reg: LOADU1(reg) */
/* 107 */	"\tmov\t%c, %0\n",	/* reg: LOADI2(reg) */
/* 108 */	"\tmov\t%c, %0\n",	/* reg: LOADU2(reg) */
/* 109 */	"\tmov\t%c, %0\n",	/* reg: LOADI4(reg) */
/* 110 */	"\tmov\t%c, %0\n",	/* reg: LOADP4(reg) */
/* 111 */	"\tmov\t%c, %0\n",	/* reg: LOADU4(reg) */
/* 112 */	"\tmvfs\t%c, %0\n",	/* reg: LOADF4(reg) */
/* 113 */	"\tmvfd\t%c, %0\n",	/* reg: LOADF8(reg) */
/* 114 */	"\trsb\t%c, %0, #0\n",	/* reg: NEGI4(reg) */
/* 115 */	"\tmnfs\t%c, %0\n",	/* reg: NEGF4(reg) */
/* 116 */	"\tmnfd\t%c, %0\n",	/* reg: NEGF8(reg) */
/* 117 */	"\tmvn\t%c, %0\n",	/* reg: BCOMI4(rc) */
/* 118 */	"\tmvn\t%c, %0\n",	/* reg: BCOMU4(rc) */
/* 119 */	"\tand\t%c, %0, %1\n",	/* reg: BANDI4(reg,rc) */
/* 120 */	"\tand\t%c, %0, %1\n",	/* reg: BANDU4(reg,rc) */
/* 121 */	"\torr\t%c, %0, %1\n",	/* reg: BORI4(reg,rc) */
/* 122 */	"\torr\t%c, %0, %1\n",	/* reg: BORU4(reg,rc) */
/* 123 */	"\teor\t%c, %0, %1\n",	/* reg: BXORI4(reg,rc) */
/* 124 */	"\teor\t%c, %0, %1\n",	/* reg: BXORU4(reg,rc) */
/* 125 */	"\tmov\t%c, %0, asl %1\n",	/* reg: LSHI4(reg,rc) */
/* 126 */	"\tmov\t%c, %0, lsl %1\n",	/* reg: LSHU4(reg,rc) */
/* 127 */	"\tmov\t%c, %0, asr %1\n",	/* reg: RSHI4(reg,rc) */
/* 128 */	"\tmov\t%c, %0, lsr %1\n",	/* reg: RSHU4(reg,rc) */
/* 129 */	"\tadd\t%c, %0, %1\n",	/* reg: ADDI4(reg,rc) */
/* 130 */	"\tadd\t%c, %0, %1\n",	/* reg: ADDP4(reg,rc) */
/* 131 */	"\tadd\t%c, %0, %1\n",	/* reg: ADDU4(reg,rc) */
/* 132 */	"\tadfs\t%c, %0, %1\n",	/* reg: ADDF4(reg,reg) */
/* 133 */	"\tadfd\t%c, %0, %1\n",	/* reg: ADDF8(reg,reg) */
/* 134 */	"\tsub\t%c, %0, %1\n",	/* reg: SUBI4(reg,rc) */
/* 135 */	"\tsub\t%c, %0, %1\n",	/* reg: SUBP4(reg,rc) */
/* 136 */	"\tsub\t%c, %0, %1\n",	/* reg: SUBU4(reg,rc) */
/* 137 */	"\tsufs\t%c, %0, %1\n",	/* reg: SUBF4(reg,reg) */
/* 138 */	"\tsufd\t%c, %0, %1\n",	/* reg: SUBF8(reg,reg) */
/* 139 */	"# mul\n",	/* reg: MULI4(reg,reg) */
/* 140 */	"# mul\n",	/* reg: MULU4(reg,reg) */
/* 141 */	"\tfmls\t%c, %0, %1\n",	/* reg: MULF4(reg,reg) */
/* 142 */	"\tmufd\t%c, %0, %1\n",	/* reg: MULF8(reg,reg) */
/* 143 */	"\tbl\t|x$divide|\n",	/* reg: DIVI4(reg,reg) */
/* 144 */	"\tbl\t|x$udivide|\n",	/* reg: DIVU4(reg,reg) */
/* 145 */	"\tfdvs\t%c, %0, %1\n",	/* reg: DIVF4(reg,reg) */
/* 146 */	"\tdvfd\t%c, %0, %1\n",	/* reg: DIVF8(reg,reg) */
/* 147 */	"\tbl\t|x$remainder|\n",	/* reg: MODI4(reg,reg) */
/* 148 */	"\tbl\t|x$uremainder|\n",	/* reg: MODU4(reg,reg) */
/* 149 */	"%a\n",	/* stmt: LABELV */
/* 150 */	"\tb\t%0\n",	/* stmt: JUMPV(bra) */
/* 151 */	"\tmov\tpc, %0\n",	/* stmt: JUMPV(reg) */
/* 152 */	"\tcmp\t%0, %1\n\tbeq\t%a\n",	/* stmt: EQI4(reg,rc) */
/* 153 */	"\tcmp\t%0, %1\n\tbeq\t%a\n",	/* stmt: EQU4(reg,rc) */
/* 154 */	"\tcmp\t%0, %1\n\tbge\t%a\n",	/* stmt: GEI4(reg,rc) */
/* 155 */	"\tcmp\t%0, %1\n\tbhs\t%a\n",	/* stmt: GEU4(reg,rc) */
/* 156 */	"\tcmp\t%0, %1\n\tbgt\t%a\n",	/* stmt: GTI4(reg,rc) */
/* 157 */	"\tcmp\t%0, %1\n\tbhi\t%a\n",	/* stmt: GTU4(reg,rc) */
/* 158 */	"\tcmp\t%0, %1\n\tble\t%a\n",	/* stmt: LEI4(reg,rc) */
/* 159 */	"\tcmp\t%0, %1\n\tbls\t%a\n",	/* stmt: LEU4(reg,rc) */
/* 160 */	"\tcmp\t%0, %1\n\tblt\t%a\n",	/* stmt: LTI4(reg,rc) */
/* 161 */	"\tcmp\t%0, %1\n\tblo\t%a\n",	/* stmt: LTU4(reg,rc) */
/* 162 */	"\tcmp\t%0, %1\n\tbne\t%a\n",	/* stmt: NEI4(reg,rc) */
/* 163 */	"\tcmp\t%0, %1\n\tbne\t%a\n",	/* stmt: NEU4(reg,rc) */
/* 164 */	"\tcmf\t%0, %1\n\tbeq\t%a\n",	/* stmt: EQF4(reg,reg) */
/* 165 */	"\tcmf\t%0, %1\n\tbeq\t%a\n",	/* stmt: EQF8(reg,reg) */
/* 166 */	"\tcmfe\t%0, %1\n\tble\t%a\n",	/* stmt: LEF4(reg,reg) */
/* 167 */	"\tcmfe\t%0, %1\n\tble\t%a\n",	/* stmt: LEF8(reg,reg) */
/* 168 */	"\tcmfe\t%0, %1\n\tblt\t%a\n",	/* stmt: LTF4(reg,reg) */
/* 169 */	"\tcmfe\t%0, %1\n\tblt\t%a\n",	/* stmt: LTF8(reg,reg) */
/* 170 */	"\tcmfe\t%0, %1\n\tbge\t%a\n",	/* stmt: GEF4(reg,reg) */
/* 171 */	"\tcmfe\t%0, %1\n\tbge\t%a\n",	/* stmt: GEF8(reg,reg) */
/* 172 */	"\tcmfe\t%0, %1\n\tbgt\t%a\n",	/* stmt: GTF4(reg,reg) */
/* 173 */	"\tcmfe\t%0, %1\n\tbgt\t%a\n",	/* stmt: GTF8(reg,reg) */
/* 174 */	"\tcmf\t%0, %1\n\tbne\t%a\n",	/* stmt: NEF4(reg,reg) */
/* 175 */	"\tcmf\t%0, %1\n\tbne\t%a\n",	/* stmt: NEF8(reg,reg) */
/* 176 */	"# arg\n",	/* stmt: ARGI4(reg) */
/* 177 */	"# arg\n",	/* stmt: ARGP4(reg) */
/* 178 */	"# arg\n",	/* stmt: ARGU4(reg) */
/* 179 */	"# arg\n",	/* stmt: ARGF4(reg) */
/* 180 */	"# arg\n",	/* stmt: ARGF8(reg) */
/* 181 */	"# argb %0\n",	/* stmt: ARGB(INDIRB(reg)) */
/* 182 */	"\tbl\t%0\n",	/* stmt: CALLV(bra) */
/* 183 */	"\tbl\t%0\n",	/* reg: CALLI4(bra) */
/* 184 */	"\tbl\t%0\n",	/* reg: CALLP4(bra) */
/* 185 */	"\tbl\t%0\n",	/* reg: CALLU4(bra) */
/* 186 */	"\tbl\t%0\n",	/* reg: CALLF4(bra) */
/* 187 */	"\tbl\t%0\n",	/* reg: CALLF8(bra) */
/* 188 */	"\tmov\tlr, pc\n\tmov\tpc, %0\n",	/* stmt: CALLV(reg) */
/* 189 */	"\tmov\tlr, pc\n\tmov\tpc, %0\n",	/* reg: CALLI4(reg) */
/* 190 */	"\tmov\tlr, pc\n\tmov\tpc, %0\n",	/* reg: CALLP4(reg) */
/* 191 */	"\tmov\tlr, pc\n\tmov\tpc, %0\n",	/* reg: CALLU4(reg) */
/* 192 */	"\tmov\tlr, pc\n\tmov\tpc, %0\n",	/* reg: CALLF4(reg) */
/* 193 */	"\tmov\tlr, pc\n\tmov\tpc, %0\n",	/* reg: CALLF8(reg) */
/* 194 */	"# ret\n",	/* stmt: RETV(reg) */
/* 195 */	"# ret\n",	/* stmt: RETI4(reg) */
/* 196 */	"# ret\n",	/* stmt: RETP4(reg) */
/* 197 */	"# ret\n",	/* stmt: RETU4(reg) */
/* 198 */	"# ret\n",	/* stmt: RETF4(reg) */
/* 199 */	"# ret\n",	/* stmt: RETF8(reg) */
/* 200 */	"%a+%F",	/* spill: ADDRLP4 */
/* 201 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstrb\t%1, [sp, ip]\n",	/* stmt: ASGNI1(spill,reg) */
/* 202 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstrb\t%1, [sp, ip]\n",	/* stmt: ASGNU1(spill,reg) */
/* 203 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstr\ta1, [sp, #-4]!\n\tstrb\t%1, [ip, #0]\n\tmov\ta1, %1, lsr#8\n\tstrb\ta1, [ip, #1]\n\tldr\ta1, [sp], #4\n",	/* stmt: ASGNI2(spill,reg) */
/* 204 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstr\ta1, [sp, #-4]!\n\tstrb\t%1, [ip, #0]\n\tmov\ta1, %1, lsr#8\n\tstrb\ta1, [ip, #1]\n\tldr\ta1, [sp], #4\n",	/* stmt: ASGNU2(spill,reg) */
/* 205 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstr\t%1, [sp, ip]\n",	/* stmt: ASGNI4(spill,reg) */
/* 206 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstr\t%1, [sp, ip]\n",	/* stmt: ASGNP4(spill,reg) */
/* 207 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstr\t%1, [sp, ip]\n",	/* stmt: ASGNU4(spill,reg) */
/* 208 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstfs\t%1, [ip, #0]\n",	/* stmt: ASGNF4(spill,reg) */
/* 209 */	"\tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstfd\t%1, [ip, #0]\n",	/* stmt: ASGNF8(spill,reg) */
};

static char _isinstruction[] = {
/* 0 */	0,
/* 1 */	0,	/*  */
/* 2 */	1,	/* # read register\n */
/* 3 */	1,	/* # read register\n */
/* 4 */	1,	/* # read register\n */
/* 5 */	1,	/* # read register\n */
/* 6 */	1,	/* # read register\n */
/* 7 */	1,	/* # read register\n */
/* 8 */	1,	/* # read register\n */
/* 9 */	1,	/* # read register\n */
/* 10 */	1,	/* # read register\n */
/* 11 */	1,	/* # write register\n */
/* 12 */	1,	/* # write register\n */
/* 13 */	1,	/* # write register\n */
/* 14 */	1,	/* # write register\n */
/* 15 */	1,	/* # write register\n */
/* 16 */	1,	/* # write register\n */
/* 17 */	1,	/* # write register\n */
/* 18 */	1,	/* # write register\n */
/* 19 */	1,	/* # write register\n */
/* 20 */	0,	/* %a */
/* 21 */	0,	/* %a */
/* 22 */	0,	/* %a */
/* 23 */	0,	/* %a */
/* 24 */	0,	/* %a */
/* 25 */	0,	/* %a */
/* 26 */	0,	/* %a */
/* 27 */	0,	/* %a */
/* 28 */	0,	/* %a */
/* 29 */	0,	/* %a */
/* 30 */	0,	/* %a */
/* 31 */	0,	/* %a */
/* 32 */	0,	/* %a */
/* 33 */	0,	/* %a */
/* 34 */	1,	/* # arbitrary constant\n */
/* 35 */	1,	/* \tldr\t%c, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%a\n */
/* 36 */	1,	/* # arbitrary offset\n */
/* 37 */	0,	/* sp, #%a+%F */
/* 38 */	0,	/* %0 */
/* 39 */	0,	/*  #%a */
/* 40 */	0,	/*  #%a */
/* 41 */	0,	/*  #%a */
/* 42 */	0,	/*  #%a */
/* 43 */	0,	/*  #%a */
/* 44 */	0,	/*  #%a */
/* 45 */	0,	/*  #%a */
/* 46 */	0,	/*  #%a */
/* 47 */	0,	/*  #%a */
/* 48 */	0,	/*  #%a */
/* 49 */	0,	/*  #%a */
/* 50 */	0,	/*  #%a */
/* 51 */	0,	/*  #%a */
/* 52 */	0,	/* %0 */
/* 53 */	0,	/* %0, asl %1 */
/* 54 */	0,	/* %0, lsl %1 */
/* 55 */	0,	/* %0, asr %1 */
/* 56 */	0,	/* %0, lsr %1 */
/* 57 */	0,	/* %a */
/* 58 */	0,	/* %0 */
/* 59 */	1,	/* \tmov\t%c, %0, lsl#8*(4-%a)\n\tmov\t%c, %c, asr#8*(4-%a)\n */
/* 60 */	1,	/* \tldrb\t%c, [%0, #0]\n\tmov\t%c, %c, lsl#24\n\tmov\t%c, %c, asr#24\n */
/* 61 */	1,	/* \tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n\tmov\t%c, %c, lsl#16\n\tmov\t%c, %c, asr#16\n */
/* 62 */	1,	/* \tand\t%c, %0, #&ff\n */
/* 63 */	1,	/* \tand\t%c, %0, #&ff\n\tand\t%c, %0, #&ff00\n */
/* 64 */	1,	/* \tldrb\t%c, [%0, #0]\n */
/* 65 */	1,	/* \tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n */
/* 66 */	1,	/* \tand\t%c, %0, #&ff\n */
/* 67 */	1,	/* \tand\t%c, %0, #&ff\n\tand\t%c, %0, #&ff00\n */
/* 68 */	1,	/* \tldrb\t%c, [%0, #0]\n */
/* 69 */	1,	/* \tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n */
/* 70 */	0,	/* %0 */
/* 71 */	1,	/* \tmvfs\t%c, %0\n */
/* 72 */	0,	/* %0 */
/* 73 */	1,	/* \tmvfd\t%c, %0\n */
/* 74 */	1,	/* \tfix\t%c, %0\n */
/* 75 */	1,	/* \tflts\t%c, %0\n */
/* 76 */	1,	/* \tfltd\t%c, %0\n */
/* 77 */	0,	/* %0, #0 */
/* 78 */	0,	/* %0, #%1 */
/* 79 */	0,	/* %0, #%1 */
/* 80 */	0,	/* %0, #%1 */
/* 81 */	1,	/* # arbitrary offset\n */
/* 82 */	0,	/* sp, #%a+%F */
/* 83 */	0,	/* %0, %1 */
/* 84 */	0,	/* %0, %1 */
/* 85 */	0,	/* %0, %1 */
/* 86 */	1,	/* \tldrb\t%c, [%0, #0]\n\tmov\t%c, %c, lsl#24\n\tmov\t%c, %c, asr#24\n */
/* 87 */	1,	/* \tldrb\t%c, [%0, #0]\n */
/* 88 */	1,	/* \tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n\tmov\t%c, %c, lsl#16\n\tmov\t%c, %c, asr#16\n */
/* 89 */	1,	/* \tldrb\tip, [%0, #1]\n\tldrb\t%c, [%0, #0]\n\tadd\t%c, %c, ip, lsl#8\n */
/* 90 */	1,	/* \tldr\t%c, [%0, #0]\n */
/* 91 */	1,	/* \tldr\t%c, [%0, #0]\n */
/* 92 */	1,	/* \tldr\t%c, [%0, #0]\n */
/* 93 */	1,	/* \tldfs\t%c, [%0, #0]\n */
/* 94 */	1,	/* \tldfd\t%c, [%0, #0]\n */
/* 95 */	1,	/* \tstrb\t%1, [%0, #0]\n */
/* 96 */	1,	/* \tstrb\t%1, [%0, #0]\n */
/* 97 */	1,	/* \tstrb\t%1, [%0, #0]\n\tmov\tip, %1, lsr#8\n\tstrb\tip, [%0, #1]\n */
/* 98 */	1,	/* \tstrb\t%1, [%0, #0]\n\tmov\tip, %1, lsr#8\n\tstrb\tip, [%0, #1]\n */
/* 99 */	1,	/* \tstr\t%1, [%0, #0]\n */
/* 100 */	1,	/* \tstr\t%1, [%0, #0]\n */
/* 101 */	1,	/* \tstr\t%1, [%0, #0]\n */
/* 102 */	1,	/* \tstfs\t%1, [%0, #0]\n */
/* 103 */	1,	/* \tstfd\t%1, [%0, #0]\n */
/* 104 */	1,	/* # asgnb %0 %1\n */
/* 105 */	1,	/* \tmov\t%c, %0\n */
/* 106 */	1,	/* \tmov\t%c, %0\n */
/* 107 */	1,	/* \tmov\t%c, %0\n */
/* 108 */	1,	/* \tmov\t%c, %0\n */
/* 109 */	1,	/* \tmov\t%c, %0\n */
/* 110 */	1,	/* \tmov\t%c, %0\n */
/* 111 */	1,	/* \tmov\t%c, %0\n */
/* 112 */	1,	/* \tmvfs\t%c, %0\n */
/* 113 */	1,	/* \tmvfd\t%c, %0\n */
/* 114 */	1,	/* \trsb\t%c, %0, #0\n */
/* 115 */	1,	/* \tmnfs\t%c, %0\n */
/* 116 */	1,	/* \tmnfd\t%c, %0\n */
/* 117 */	1,	/* \tmvn\t%c, %0\n */
/* 118 */	1,	/* \tmvn\t%c, %0\n */
/* 119 */	1,	/* \tand\t%c, %0, %1\n */
/* 120 */	1,	/* \tand\t%c, %0, %1\n */
/* 121 */	1,	/* \torr\t%c, %0, %1\n */
/* 122 */	1,	/* \torr\t%c, %0, %1\n */
/* 123 */	1,	/* \teor\t%c, %0, %1\n */
/* 124 */	1,	/* \teor\t%c, %0, %1\n */
/* 125 */	1,	/* \tmov\t%c, %0, asl %1\n */
/* 126 */	1,	/* \tmov\t%c, %0, lsl %1\n */
/* 127 */	1,	/* \tmov\t%c, %0, asr %1\n */
/* 128 */	1,	/* \tmov\t%c, %0, lsr %1\n */
/* 129 */	1,	/* \tadd\t%c, %0, %1\n */
/* 130 */	1,	/* \tadd\t%c, %0, %1\n */
/* 131 */	1,	/* \tadd\t%c, %0, %1\n */
/* 132 */	1,	/* \tadfs\t%c, %0, %1\n */
/* 133 */	1,	/* \tadfd\t%c, %0, %1\n */
/* 134 */	1,	/* \tsub\t%c, %0, %1\n */
/* 135 */	1,	/* \tsub\t%c, %0, %1\n */
/* 136 */	1,	/* \tsub\t%c, %0, %1\n */
/* 137 */	1,	/* \tsufs\t%c, %0, %1\n */
/* 138 */	1,	/* \tsufd\t%c, %0, %1\n */
/* 139 */	1,	/* # mul\n */
/* 140 */	1,	/* # mul\n */
/* 141 */	1,	/* \tfmls\t%c, %0, %1\n */
/* 142 */	1,	/* \tmufd\t%c, %0, %1\n */
/* 143 */	1,	/* \tbl\t|x$divide|\n */
/* 144 */	1,	/* \tbl\t|x$udivide|\n */
/* 145 */	1,	/* \tfdvs\t%c, %0, %1\n */
/* 146 */	1,	/* \tdvfd\t%c, %0, %1\n */
/* 147 */	1,	/* \tbl\t|x$remainder|\n */
/* 148 */	1,	/* \tbl\t|x$uremainder|\n */
/* 149 */	1,	/* %a\n */
/* 150 */	1,	/* \tb\t%0\n */
/* 151 */	1,	/* \tmov\tpc, %0\n */
/* 152 */	1,	/* \tcmp\t%0, %1\n\tbeq\t%a\n */
/* 153 */	1,	/* \tcmp\t%0, %1\n\tbeq\t%a\n */
/* 154 */	1,	/* \tcmp\t%0, %1\n\tbge\t%a\n */
/* 155 */	1,	/* \tcmp\t%0, %1\n\tbhs\t%a\n */
/* 156 */	1,	/* \tcmp\t%0, %1\n\tbgt\t%a\n */
/* 157 */	1,	/* \tcmp\t%0, %1\n\tbhi\t%a\n */
/* 158 */	1,	/* \tcmp\t%0, %1\n\tble\t%a\n */
/* 159 */	1,	/* \tcmp\t%0, %1\n\tbls\t%a\n */
/* 160 */	1,	/* \tcmp\t%0, %1\n\tblt\t%a\n */
/* 161 */	1,	/* \tcmp\t%0, %1\n\tblo\t%a\n */
/* 162 */	1,	/* \tcmp\t%0, %1\n\tbne\t%a\n */
/* 163 */	1,	/* \tcmp\t%0, %1\n\tbne\t%a\n */
/* 164 */	1,	/* \tcmf\t%0, %1\n\tbeq\t%a\n */
/* 165 */	1,	/* \tcmf\t%0, %1\n\tbeq\t%a\n */
/* 166 */	1,	/* \tcmfe\t%0, %1\n\tble\t%a\n */
/* 167 */	1,	/* \tcmfe\t%0, %1\n\tble\t%a\n */
/* 168 */	1,	/* \tcmfe\t%0, %1\n\tblt\t%a\n */
/* 169 */	1,	/* \tcmfe\t%0, %1\n\tblt\t%a\n */
/* 170 */	1,	/* \tcmfe\t%0, %1\n\tbge\t%a\n */
/* 171 */	1,	/* \tcmfe\t%0, %1\n\tbge\t%a\n */
/* 172 */	1,	/* \tcmfe\t%0, %1\n\tbgt\t%a\n */
/* 173 */	1,	/* \tcmfe\t%0, %1\n\tbgt\t%a\n */
/* 174 */	1,	/* \tcmf\t%0, %1\n\tbne\t%a\n */
/* 175 */	1,	/* \tcmf\t%0, %1\n\tbne\t%a\n */
/* 176 */	1,	/* # arg\n */
/* 177 */	1,	/* # arg\n */
/* 178 */	1,	/* # arg\n */
/* 179 */	1,	/* # arg\n */
/* 180 */	1,	/* # arg\n */
/* 181 */	1,	/* # argb %0\n */
/* 182 */	1,	/* \tbl\t%0\n */
/* 183 */	1,	/* \tbl\t%0\n */
/* 184 */	1,	/* \tbl\t%0\n */
/* 185 */	1,	/* \tbl\t%0\n */
/* 186 */	1,	/* \tbl\t%0\n */
/* 187 */	1,	/* \tbl\t%0\n */
/* 188 */	1,	/* \tmov\tlr, pc\n\tmov\tpc, %0\n */
/* 189 */	1,	/* \tmov\tlr, pc\n\tmov\tpc, %0\n */
/* 190 */	1,	/* \tmov\tlr, pc\n\tmov\tpc, %0\n */
/* 191 */	1,	/* \tmov\tlr, pc\n\tmov\tpc, %0\n */
/* 192 */	1,	/* \tmov\tlr, pc\n\tmov\tpc, %0\n */
/* 193 */	1,	/* \tmov\tlr, pc\n\tmov\tpc, %0\n */
/* 194 */	1,	/* # ret\n */
/* 195 */	1,	/* # ret\n */
/* 196 */	1,	/* # ret\n */
/* 197 */	1,	/* # ret\n */
/* 198 */	1,	/* # ret\n */
/* 199 */	1,	/* # ret\n */
/* 200 */	0,	/* %a+%F */
/* 201 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstrb\t%1, [sp, ip]\n */
/* 202 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstrb\t%1, [sp, ip]\n */
/* 203 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstr\ta1, [sp, #-4]!\n\tstrb\t%1, [ip, #0]\n\tmov\ta1, %1, lsr#8\n\tstrb\ta1, [ip, #1]\n\tldr\ta1, [sp], #4\n */
/* 204 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstr\ta1, [sp, #-4]!\n\tstrb\t%1, [ip, #0]\n\tmov\ta1, %1, lsr#8\n\tstrb\ta1, [ip, #1]\n\tldr\ta1, [sp], #4\n */
/* 205 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstr\t%1, [sp, ip]\n */
/* 206 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstr\t%1, [sp, ip]\n */
/* 207 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tstr\t%1, [sp, ip]\n */
/* 208 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstfs\t%1, [ip, #0]\n */
/* 209 */	1,	/* \tldr\tip, [pc, #0]\n\tmov\tpc, pc\n\tdcd\t%0\n\tadd\tip, ip, sp\n\tstfd\t%1, [ip, #0]\n */
};

static char *_string[] = {
/* 0 */	0,
/* 1 */	"stmt: reg",
/* 2 */	"reg: INDIRI1(VREGP)",
/* 3 */	"reg: INDIRU1(VREGP)",
/* 4 */	"reg: INDIRI2(VREGP)",
/* 5 */	"reg: INDIRU2(VREGP)",
/* 6 */	"reg: INDIRF4(VREGP)",
/* 7 */	"reg: INDIRI4(VREGP)",
/* 8 */	"reg: INDIRP4(VREGP)",
/* 9 */	"reg: INDIRU4(VREGP)",
/* 10 */	"reg: INDIRF8(VREGP)",
/* 11 */	"stmt: ASGNI1(VREGP,reg)",
/* 12 */	"stmt: ASGNU1(VREGP,reg)",
/* 13 */	"stmt: ASGNI2(VREGP,reg)",
/* 14 */	"stmt: ASGNU2(VREGP,reg)",
/* 15 */	"stmt: ASGNF4(VREGP,reg)",
/* 16 */	"stmt: ASGNI4(VREGP,reg)",
/* 17 */	"stmt: ASGNP4(VREGP,reg)",
/* 18 */	"stmt: ASGNU4(VREGP,reg)",
/* 19 */	"stmt: ASGNF8(VREGP,reg)",
/* 20 */	"con: CNSTI1",
/* 21 */	"con: CNSTU1",
/* 22 */	"con: CNSTI2",
/* 23 */	"con: CNSTU2",
/* 24 */	"con: CNSTI4",
/* 25 */	"con: CNSTU4",
/* 26 */	"con: CNSTP4",
/* 27 */	"con12: CNSTI1",
/* 28 */	"con12: CNSTU1",
/* 29 */	"con12: CNSTI2",
/* 30 */	"con12: CNSTU2",
/* 31 */	"con12: CNSTI4",
/* 32 */	"con12: CNSTU4",
/* 33 */	"con12: CNSTP4",
/* 34 */	"reg: con",
/* 35 */	"reg: ADDRGP4",
/* 36 */	"reg: ADDRFP4",
/* 37 */	"reg: ADDRLP4",
/* 38 */	"rc: reg",
/* 39 */	"rc: CNSTI1",
/* 40 */	"rc: CNSTU1",
/* 41 */	"rc: CNSTI2",
/* 42 */	"rc: CNSTU2",
/* 43 */	"rc: CNSTI4",
/* 44 */	"rc: CNSTU4",
/* 45 */	"rc: CNSTP4",
/* 46 */	"rc5: CNSTI1",
/* 47 */	"rc5: CNSTU1",
/* 48 */	"rc5: CNSTI2",
/* 49 */	"rc5: CNSTU2",
/* 50 */	"rc5: CNSTI4",
/* 51 */	"rc5: CNSTU4",
/* 52 */	"rc5: reg",
/* 53 */	"rc: LSHI4(reg,rc5)",
/* 54 */	"rc: LSHU4(reg,rc5)",
/* 55 */	"rc: RSHI4(reg,rc5)",
/* 56 */	"rc: RSHU4(reg,rc5)",
/* 57 */	"bra: ADDRGP4",
/* 58 */	"bra: con",
/* 59 */	"reg: CVII4(reg)",
/* 60 */	"reg: CVII4(INDIRI1(reg))",
/* 61 */	"reg: CVII4(INDIRI2(reg))",
/* 62 */	"reg: CVUI4(reg)",
/* 63 */	"reg: CVUI4(reg)",
/* 64 */	"reg: CVUI4(INDIRU1(reg))",
/* 65 */	"reg: CVUI4(INDIRU2(reg))",
/* 66 */	"reg: CVUU4(reg)",
/* 67 */	"reg: CVUU4(reg)",
/* 68 */	"reg: CVUU4(INDIRU1(reg))",
/* 69 */	"reg: CVUU4(INDIRU2(reg))",
/* 70 */	"reg: CVFF4(reg)",
/* 71 */	"reg: CVFF4(reg)",
/* 72 */	"reg: CVFF8(reg)",
/* 73 */	"reg: CVFF8(reg)",
/* 74 */	"reg: CVFI4(reg)",
/* 75 */	"reg: CVIF4(reg)",
/* 76 */	"reg: CVIF8(reg)",
/* 77 */	"addr: reg",
/* 78 */	"addr: ADDI4(reg,con12)",
/* 79 */	"addr: ADDU4(reg,con12)",
/* 80 */	"addr: ADDP4(reg,con12)",
/* 81 */	"addr: ADDRFP4",
/* 82 */	"addr: ADDRLP4",
/* 83 */	"addr: ADDI4(reg,reg)",
/* 84 */	"addr: ADDU4(reg,reg)",
/* 85 */	"addr: ADDP4(reg,reg)",
/* 86 */	"reg: INDIRI1(addr)",
/* 87 */	"reg: INDIRU1(addr)",
/* 88 */	"reg: INDIRI2(addr)",
/* 89 */	"reg: INDIRU2(addr)",
/* 90 */	"reg: INDIRI4(addr)",
/* 91 */	"reg: INDIRU4(addr)",
/* 92 */	"reg: INDIRP4(addr)",
/* 93 */	"reg: INDIRF4(addr)",
/* 94 */	"reg: INDIRF8(addr)",
/* 95 */	"stmt: ASGNI1(addr,reg)",
/* 96 */	"stmt: ASGNU1(addr,reg)",
/* 97 */	"stmt: ASGNI2(addr,reg)",
/* 98 */	"stmt: ASGNU2(addr,reg)",
/* 99 */	"stmt: ASGNI4(addr,reg)",
/* 100 */	"stmt: ASGNU4(addr,reg)",
/* 101 */	"stmt: ASGNP4(addr,reg)",
/* 102 */	"stmt: ASGNF4(addr,reg)",
/* 103 */	"stmt: ASGNF8(addr,reg)",
/* 104 */	"stmt: ASGNB(reg,INDIRB(reg))",
/* 105 */	"reg: LOADI1(reg)",
/* 106 */	"reg: LOADU1(reg)",
/* 107 */	"reg: LOADI2(reg)",
/* 108 */	"reg: LOADU2(reg)",
/* 109 */	"reg: LOADI4(reg)",
/* 110 */	"reg: LOADP4(reg)",
/* 111 */	"reg: LOADU4(reg)",
/* 112 */	"reg: LOADF4(reg)",
/* 113 */	"reg: LOADF8(reg)",
/* 114 */	"reg: NEGI4(reg)",
/* 115 */	"reg: NEGF4(reg)",
/* 116 */	"reg: NEGF8(reg)",
/* 117 */	"reg: BCOMI4(rc)",
/* 118 */	"reg: BCOMU4(rc)",
/* 119 */	"reg: BANDI4(reg,rc)",
/* 120 */	"reg: BANDU4(reg,rc)",
/* 121 */	"reg: BORI4(reg,rc)",
/* 122 */	"reg: BORU4(reg,rc)",
/* 123 */	"reg: BXORI4(reg,rc)",
/* 124 */	"reg: BXORU4(reg,rc)",
/* 125 */	"reg: LSHI4(reg,rc)",
/* 126 */	"reg: LSHU4(reg,rc)",
/* 127 */	"reg: RSHI4(reg,rc)",
/* 128 */	"reg: RSHU4(reg,rc)",
/* 129 */	"reg: ADDI4(reg,rc)",
/* 130 */	"reg: ADDP4(reg,rc)",
/* 131 */	"reg: ADDU4(reg,rc)",
/* 132 */	"reg: ADDF4(reg,reg)",
/* 133 */	"reg: ADDF8(reg,reg)",
/* 134 */	"reg: SUBI4(reg,rc)",
/* 135 */	"reg: SUBP4(reg,rc)",
/* 136 */	"reg: SUBU4(reg,rc)",
/* 137 */	"reg: SUBF4(reg,reg)",
/* 138 */	"reg: SUBF8(reg,reg)",
/* 139 */	"reg: MULI4(reg,reg)",
/* 140 */	"reg: MULU4(reg,reg)",
/* 141 */	"reg: MULF4(reg,reg)",
/* 142 */	"reg: MULF8(reg,reg)",
/* 143 */	"reg: DIVI4(reg,reg)",
/* 144 */	"reg: DIVU4(reg,reg)",
/* 145 */	"reg: DIVF4(reg,reg)",
/* 146 */	"reg: DIVF8(reg,reg)",
/* 147 */	"reg: MODI4(reg,reg)",
/* 148 */	"reg: MODU4(reg,reg)",
/* 149 */	"stmt: LABELV",
/* 150 */	"stmt: JUMPV(bra)",
/* 151 */	"stmt: JUMPV(reg)",
/* 152 */	"stmt: EQI4(reg,rc)",
/* 153 */	"stmt: EQU4(reg,rc)",
/* 154 */	"stmt: GEI4(reg,rc)",
/* 155 */	"stmt: GEU4(reg,rc)",
/* 156 */	"stmt: GTI4(reg,rc)",
/* 157 */	"stmt: GTU4(reg,rc)",
/* 158 */	"stmt: LEI4(reg,rc)",
/* 159 */	"stmt: LEU4(reg,rc)",
/* 160 */	"stmt: LTI4(reg,rc)",
/* 161 */	"stmt: LTU4(reg,rc)",
/* 162 */	"stmt: NEI4(reg,rc)",
/* 163 */	"stmt: NEU4(reg,rc)",
/* 164 */	"stmt: EQF4(reg,reg)",
/* 165 */	"stmt: EQF8(reg,reg)",
/* 166 */	"stmt: LEF4(reg,reg)",
/* 167 */	"stmt: LEF8(reg,reg)",
/* 168 */	"stmt: LTF4(reg,reg)",
/* 169 */	"stmt: LTF8(reg,reg)",
/* 170 */	"stmt: GEF4(reg,reg)",
/* 171 */	"stmt: GEF8(reg,reg)",
/* 172 */	"stmt: GTF4(reg,reg)",
/* 173 */	"stmt: GTF8(reg,reg)",
/* 174 */	"stmt: NEF4(reg,reg)",
/* 175 */	"stmt: NEF8(reg,reg)",
/* 176 */	"stmt: ARGI4(reg)",
/* 177 */	"stmt: ARGP4(reg)",
/* 178 */	"stmt: ARGU4(reg)",
/* 179 */	"stmt: ARGF4(reg)",
/* 180 */	"stmt: ARGF8(reg)",
/* 181 */	"stmt: ARGB(INDIRB(reg))",
/* 182 */	"stmt: CALLV(bra)",
/* 183 */	"reg: CALLI4(bra)",
/* 184 */	"reg: CALLP4(bra)",
/* 185 */	"reg: CALLU4(bra)",
/* 186 */	"reg: CALLF4(bra)",
/* 187 */	"reg: CALLF8(bra)",
/* 188 */	"stmt: CALLV(reg)",
/* 189 */	"reg: CALLI4(reg)",
/* 190 */	"reg: CALLP4(reg)",
/* 191 */	"reg: CALLU4(reg)",
/* 192 */	"reg: CALLF4(reg)",
/* 193 */	"reg: CALLF8(reg)",
/* 194 */	"stmt: RETV(reg)",
/* 195 */	"stmt: RETI4(reg)",
/* 196 */	"stmt: RETP4(reg)",
/* 197 */	"stmt: RETU4(reg)",
/* 198 */	"stmt: RETF4(reg)",
/* 199 */	"stmt: RETF8(reg)",
/* 200 */	"spill: ADDRLP4",
/* 201 */	"stmt: ASGNI1(spill,reg)",
/* 202 */	"stmt: ASGNU1(spill,reg)",
/* 203 */	"stmt: ASGNI2(spill,reg)",
/* 204 */	"stmt: ASGNU2(spill,reg)",
/* 205 */	"stmt: ASGNI4(spill,reg)",
/* 206 */	"stmt: ASGNP4(spill,reg)",
/* 207 */	"stmt: ASGNU4(spill,reg)",
/* 208 */	"stmt: ASGNF4(spill,reg)",
/* 209 */	"stmt: ASGNF8(spill,reg)",
};

static short _decode_stmt[] = {
	0,
	1,
	11,
	12,
	13,
	14,
	15,
	16,
	17,
	18,
	19,
	95,
	96,
	97,
	98,
	99,
	100,
	101,
	102,
	103,
	104,
	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,
	188,
	194,
	195,
	196,
	197,
	198,
	199,
	201,
	202,
	203,
	204,
	205,
	206,
	207,
	208,
	209,
};

static short _decode_reg[] = {
	0,
	2,
	3,
	4,
	5,
	6,
	7,
	8,
	9,
	10,
	34,
	35,
	36,
	37,
	59,
	60,
	61,
	62,
	63,
	64,
	65,
	66,
	67,
	68,
	69,
	70,
	71,
	72,
	73,
	74,
	75,
	76,
	86,
	87,
	88,
	89,
	90,
	91,
	92,
	93,
	94,
	105,
	106,
	107,
	108,
	109,
	110,
	111,
	112,
	113,
	114,
	115,
	116,
	117,
	118,
	119,
	120,
	121,
	122,
	123,
	124,
	125,
	126,
	127,
	128,
	129,
	130,
	131,
	132,
	133,
	134,
	135,
	136,
	137,
	138,
	139,
	140,
	141,
	142,
	143,
	144,
	145,
	146,
	147,
	148,
	183,
	184,
	185,
	186,
	187,
	189,
	190,
	191,
	192,
	193,
};

static short _decode_con[] = {
	0,
	20,
	21,
	22,
	23,
	24,
	25,
	26,
};

static short _decode_con12[] = {
	0,
	27,
	28,
	29,
	30,
	31,
	32,
	33,
};

static short _decode_rc[] = {
	0,
	38,
	39,
	40,
	41,
	42,
	43,
	44,
	45,
	53,
	54,
	55,
	56,
};

static short _decode_rc5[] = {
	0,
	46,
	47,
	48,
	49,
	50,
	51,
	52,
};

static short _decode_bra[] = {
	0,
	57,
	58,
};

static short _decode_addr[] = {
	0,
	77,
	78,
	79,
	80,
	81,
	82,
	83,
	84,
	85,
};

static short _decode_spill[] = {
	0,
	200,
};

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 9)
		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 _con12_NT:	return _decode_con12[((struct _state *)state)->rule._con12];
	case _rc_NT:	return _decode_rc[((struct _state *)state)->rule._rc];
	case _rc5_NT:	return _decode_rc5[((struct _state *)state)->rule._rc5];
	case _bra_NT:	return _decode_bra[((struct _state *)state)->rule._bra];
	case _addr_NT:	return _decode_addr[((struct _state *)state)->rule._addr];
	case _spill_NT:	return _decode_spill[((struct _state *)state)->rule._spill];
	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_reg(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;
	}
	if (c + 0 < p->cost[_rc5_NT]) {
		p->cost[_rc5_NT] = c + 0;
		p->rule._rc5 = 7;
	}
	if (c + 0 < p->cost[_rc_NT]) {
		p->cost[_rc_NT] = c + 0;
		p->rule._rc = 1;
	}
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 1;
	}
}

static void _closure_con(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_bra_NT]) {
		p->cost[_bra_NT] = c + 0;
		p->rule._bra = 2;
	}
	if (c + 2 < p->cost[_reg_NT]) {
		p->cost[_reg_NT] = c + 2;
		p->rule._reg = 10;
		_closure_reg(a, c + 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] =
		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] + 1;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 53;
			}
		}
		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] + 3;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 20;
			}
		}
		break;
	case 73: /* INDIRB */
		_label(LEFT_CHILD(a));
		break;
	case 216: /* CALLV */
		_label(LEFT_CHILD(a));
		/* stmt: CALLV(bra) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_bra_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 54;
		}
		/* stmt: CALLV(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 55;
		}
		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] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 56;
		}
		break;
	case 584: /* JUMPV */
		_label(LEFT_CHILD(a));
		/* stmt: JUMPV(bra) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_bra_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 22;
		}
		/* stmt: JUMPV(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 = 23;
		}
		break;
	case 600: /* LABELV */
		/* stmt: LABELV */
		if (0 + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = 0 + 0;
			p->rule._stmt = 21;
		}
		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);
		}
		/* con12: CNSTI1 */
		c = (range(a, -4095, 4094));
		if (c + 0 < p->cost[_con12_NT]) {
			p->cost[_con12_NT] = c + 0;
			p->rule._con12 = 1;
		}
		/* rc: CNSTI1 */
		if (0 + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = 0 + 0;
			p->rule._rc = 2;
		}
		/* rc5: CNSTI1 */
		c = (range(a,1,32));
		if (c + 0 < p->cost[_rc5_NT]) {
			p->cost[_rc5_NT] = c + 0;
			p->rule._rc5 = 1;
		}
		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);
		}
		/* con12: CNSTU1 */
		c = (range(a, -4095, 4094));
		if (c + 0 < p->cost[_con12_NT]) {
			p->cost[_con12_NT] = c + 0;
			p->rule._con12 = 2;
		}
		/* rc: CNSTU1 */
		if (0 + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = 0 + 0;
			p->rule._rc = 3;
		}
		/* rc5: CNSTU1 */
		c = (range(a,1,32));
		if (c + 0 < p->cost[_rc5_NT]) {
			p->cost[_rc5_NT] = c + 0;
			p->rule._rc5 = 2;
		}
		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 = 2;
			}
		}
		/* stmt: ASGNI1(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 11;
		}
		/* stmt: ASGNI1(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 62;
		}
		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 = 3;
			}
		}
		/* stmt: ASGNU1(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 12;
		}
		/* stmt: ASGNU1(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 63;
		}
		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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 1;
				_closure_reg(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 = 32;
			_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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 2;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRU1(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 33;
			_closure_reg(a, c + 0);
		}
		break;
	case 1157: /* CVII1 */
		break;
	case 1158: /* CVIU1 */
		break;
	case 1205: /* CVUI1 */
		break;
	case 1206: /* CVUU1 */
		break;
	case 1253: /* LOADI1 */
		_label(LEFT_CHILD(a));
		/* reg: LOADI1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 41;
			_closure_reg(a, c + 0);
		}
		break;
	case 1254: /* LOADU1 */
		_label(LEFT_CHILD(a));
		/* reg: LOADU1(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 42;
			_closure_reg(a, c + 0);
		}
		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);
		}
		/* con12: CNSTI2 */
		c = (range(a, -4095, 4094));
		if (c + 0 < p->cost[_con12_NT]) {
			p->cost[_con12_NT] = c + 0;
			p->rule._con12 = 3;
		}
		/* rc: CNSTI2 */
		c = (imm(a));
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 4;
		}
		/* rc5: CNSTI2 */
		c = (range(a,1,32));
		if (c + 0 < p->cost[_rc5_NT]) {
			p->cost[_rc5_NT] = c + 0;
			p->rule._rc5 = 3;
		}
		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);
		}
		/* con12: CNSTU2 */
		c = (range(a, -4095, 4094));
		if (c + 0 < p->cost[_con12_NT]) {
			p->cost[_con12_NT] = c + 0;
			p->rule._con12 = 4;
		}
		/* rc: CNSTU2 */
		c = (imm(a));
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 5;
		}
		/* rc5: CNSTU2 */
		c = (range(a,1,32));
		if (c + 0 < p->cost[_rc5_NT]) {
			p->cost[_rc5_NT] = c + 0;
			p->rule._rc5 = 4;
		}
		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 = 4;
			}
		}
		/* stmt: ASGNI2(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 5;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 13;
		}
		/* stmt: ASGNI2(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 64;
		}
		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 = 5;
			}
		}
		/* stmt: ASGNU2(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 5;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 14;
		}
		/* stmt: ASGNU2(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 65;
		}
		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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			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] + 8;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 34;
			_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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			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] + 6;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 35;
			_closure_reg(a, c + 0);
		}
		break;
	case 2181: /* CVII2 */
		break;
	case 2182: /* CVIU2 */
		break;
	case 2229: /* CVUI2 */
		break;
	case 2230: /* CVUU2 */
		break;
	case 2277: /* LOADI2 */
		_label(LEFT_CHILD(a));
		/* reg: LOADI2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 43;
			_closure_reg(a, c + 0);
		}
		break;
	case 2278: /* LOADU2 */
		_label(LEFT_CHILD(a));
		/* reg: LOADU2(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 44;
			_closure_reg(a, c + 0);
		}
		break;
	case 4113: /* CNSTF4 */
		break;
	case 4117: /* CNSTI4 */
		/* con: CNSTI4 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 5;
			_closure_con(a, 0 + 0);
		}
		/* con12: CNSTI4 */
		c = (range(a, -4095, 4094));
		if (c + 0 < p->cost[_con12_NT]) {
			p->cost[_con12_NT] = c + 0;
			p->rule._con12 = 5;
		}
		/* rc: CNSTI4 */
		c = (imm(a));
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 6;
		}
		/* rc5: CNSTI4 */
		c = (range(a,1,32));
		if (c + 0 < p->cost[_rc5_NT]) {
			p->cost[_rc5_NT] = c + 0;
			p->rule._rc5 = 5;
		}
		break;
	case 4118: /* CNSTU4 */
		/* con: CNSTU4 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 6;
			_closure_con(a, 0 + 0);
		}
		/* con12: CNSTU4 */
		c = (range(a, -4095, 4094));
		if (c + 0 < p->cost[_con12_NT]) {
			p->cost[_con12_NT] = c + 0;
			p->rule._con12 = 6;
		}
		/* rc: CNSTU4 */
		c = (imm(a));
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 7;
		}
		/* rc5: CNSTU4 */
		c = (range(a,1,32));
		if (c + 0 < p->cost[_rc5_NT]) {
			p->cost[_rc5_NT] = c + 0;
			p->rule._rc5 = 6;
		}
		break;
	case 4119: /* CNSTP4 */
		/* con: CNSTP4 */
		if (0 + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = 0 + 0;
			p->rule._con = 7;
			_closure_con(a, 0 + 0);
		}
		/* con12: CNSTP4 */
		c = (range(a, -4095, 4094));
		if (c + 0 < p->cost[_con12_NT]) {
			p->cost[_con12_NT] = c + 0;
			p->rule._con12 = 7;
		}
		/* rc: CNSTP4 */
		c = (imm(a));
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 8;
		}
		break;
	case 4129: /* ARGF4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGF4(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 = 51;
		}
		break;
	case 4133: /* ARGI4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGI4(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 = 48;
		}
		break;
	case 4134: /* ARGU4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGU4(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 = 50;
		}
		break;
	case 4135: /* ARGP4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGP4(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 = 49;
		}
		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 = 6;
			}
		}
		/* stmt: ASGNF4(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 18;
		}
		/* stmt: ASGNF4(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 69;
		}
		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 = 7;
			}
		}
		/* stmt: ASGNI4(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 15;
		}
		/* stmt: ASGNI4(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 66;
		}
		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 = 9;
			}
		}
		/* stmt: ASGNU4(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 16;
		}
		/* stmt: ASGNU4(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 68;
		}
		break;
	case 4151: /* ASGNP4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNP4(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 = 8;
			}
		}
		/* stmt: ASGNP4(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 17;
		}
		/* stmt: ASGNP4(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 67;
		}
		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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			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: INDIRF4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 39;
			_closure_reg(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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 6;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRI4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 36;
			_closure_reg(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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 8;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRU4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 37;
			_closure_reg(a, c + 0);
		}
		break;
	case 4167: /* INDIRP4 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRP4(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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 7;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRP4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 38;
			_closure_reg(a, c + 0);
		}
		break;
	case 4209: /* CVFF4 */
		_label(LEFT_CHILD(a));
		/* reg: CVFF4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 25;
			_closure_reg(a, c + 0);
		}
		/* reg: CVFF4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 26;
			_closure_reg(a, c + 0);
		}
		break;
	case 4213: /* CVFI4 */
		_label(LEFT_CHILD(a));
		/* reg: CVFI4(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 = 29;
			_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] + 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 4229: /* CVII4 */
		_label(LEFT_CHILD(a));
		/* reg: CVII4(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 = 14;
			_closure_reg(a, c + 0);
		}
		if (	/* reg: CVII4(INDIRI1(reg)) */
			LEFT_CHILD(a)->op == 1093 /* INDIRI1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 2;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 15;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: CVII4(INDIRI2(reg)) */
			LEFT_CHILD(a)->op == 2117 /* INDIRI2 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 8;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 16;
				_closure_reg(a, c + 0);
			}
		}
		break;
	case 4230: /* CVIU4 */
		break;
	case 4246: /* CVPU4 */
		break;
	case 4277: /* CVUI4 */
		_label(LEFT_CHILD(a));
		/* reg: CVUI4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((a->syms[0]->u.c.v.i == 1 ? 1 : LBURG_MAX));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 17;
			_closure_reg(a, c + 0);
		}
		/* reg: CVUI4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 18;
			_closure_reg(a, c + 0);
		}
		if (	/* reg: CVUI4(INDIRU1(reg)) */
			LEFT_CHILD(a)->op == 1094 /* INDIRU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 2;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 19;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: CVUI4(INDIRU2(reg)) */
			LEFT_CHILD(a)->op == 2118 /* INDIRU2 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 6;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 20;
				_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] + ((a->syms[0]->u.c.v.i == 1 ? 1 : LBURG_MAX));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 21;
			_closure_reg(a, c + 0);
		}
		/* reg: CVUU4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 22;
			_closure_reg(a, c + 0);
		}
		if (	/* reg: CVUU4(INDIRU1(reg)) */
			LEFT_CHILD(a)->op == 1094 /* INDIRU1 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 2;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 23;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: CVUU4(INDIRU2(reg)) */
			LEFT_CHILD(a)->op == 2118 /* INDIRU2 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 6;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 24;
				_closure_reg(a, c + 0);
			}
		}
		break;
	case 4279: /* CVUP4 */
		break;
	case 4289: /* NEGF4 */
		_label(LEFT_CHILD(a));
		/* reg: NEGF4(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 = 51;
			_closure_reg(a, c + 0);
		}
		break;
	case 4293: /* NEGI4 */
		_label(LEFT_CHILD(a));
		/* reg: NEGI4(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 = 50;
			_closure_reg(a, c + 0);
		}
		break;
	case 4305: /* CALLF4 */
		_label(LEFT_CHILD(a));
		/* reg: CALLF4(bra) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_bra_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 88;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLF4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 93;
			_closure_reg(a, c + 0);
		}
		break;
	case 4309: /* CALLI4 */
		_label(LEFT_CHILD(a));
		/* reg: CALLI4(bra) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_bra_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 85;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLI4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 90;
			_closure_reg(a, c + 0);
		}
		break;
	case 4310: /* CALLU4 */
		_label(LEFT_CHILD(a));
		/* reg: CALLU4(bra) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_bra_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 87;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLU4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 92;
			_closure_reg(a, c + 0);
		}
		break;
	case 4311: /* CALLP4 */
		_label(LEFT_CHILD(a));
		/* reg: CALLP4(bra) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_bra_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 86;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLP4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 91;
			_closure_reg(a, c + 0);
		}
		break;
	case 4321: /* LOADF4 */
		_label(LEFT_CHILD(a));
		/* reg: LOADF4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 48;
			_closure_reg(a, c + 0);
		}
		break;
	case 4325: /* LOADI4 */
		_label(LEFT_CHILD(a));
		/* reg: LOADI4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 45;
			_closure_reg(a, c + 0);
		}
		break;
	case 4326: /* LOADU4 */
		_label(LEFT_CHILD(a));
		/* reg: LOADU4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 47;
			_closure_reg(a, c + 0);
		}
		break;
	case 4327: /* LOADP4 */
		_label(LEFT_CHILD(a));
		/* reg: LOADP4(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 46;
			_closure_reg(a, c + 0);
		}
		break;
	case 4337: /* RETF4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETF4(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 = 60;
		}
		break;
	case 4341: /* RETI4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETI4(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 = 57;
		}
		break;
	case 4342: /* RETU4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETU4(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 = 59;
		}
		break;
	case 4343: /* RETP4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETP4(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 = 58;
		}
		break;
	case 4359: /* ADDRGP4 */
		/* reg: ADDRGP4 */
		if (2 + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = 2 + 0;
			p->rule._reg = 11;
			_closure_reg(a, 2 + 0);
		}
		/* bra: ADDRGP4 */
		if (0 + 0 < p->cost[_bra_NT]) {
			p->cost[_bra_NT] = 0 + 0;
			p->rule._bra = 1;
		}
		break;
	case 4375: /* ADDRFP4 */
		/* reg: ADDRFP4 */
		if (2 + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = 2 + 0;
			p->rule._reg = 12;
			_closure_reg(a, 2 + 0);
		}
		/* addr: ADDRFP4 */
		if (2 + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = 2 + 0;
			p->rule._addr = 5;
		}
		break;
	case 4391: /* ADDRLP4 */
		/* reg: ADDRLP4 */
		c = (range(a,-4096,4095));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 13;
			_closure_reg(a, c + 0);
		}
		/* addr: ADDRLP4 */
		c = (range(a,-4095,4096));
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 6;
		}
		/* spill: ADDRLP4 */
		c = (!range(a,-4096,4095));
		if (c + 0 < p->cost[_spill_NT]) {
			p->cost[_spill_NT] = c + 0;
			p->rule._spill = 1;
		}
		break;
	case 4401: /* ADDF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 68;
			_closure_reg(a, c + 0);
		}
		break;
	case 4405: /* ADDI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* addr: ADDI4(reg,con12) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con12_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 2;
		}
		/* addr: ADDI4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 7;
		}
		/* reg: ADDI4(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 = 65;
			_closure_reg(a, c + 0);
		}
		break;
	case 4406: /* ADDU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* addr: ADDU4(reg,con12) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con12_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 3;
		}
		/* addr: ADDU4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 8;
		}
		/* reg: ADDU4(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 = 67;
			_closure_reg(a, c + 0);
		}
		break;
	case 4407: /* ADDP4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* addr: ADDP4(reg,con12) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con12_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 4;
		}
		/* addr: ADDP4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 9;
		}
		/* reg: ADDP4(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 = 66;
			_closure_reg(a, c + 0);
		}
		break;
	case 4417: /* SUBF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_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 4421: /* SUBI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBI4(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 = 70;
			_closure_reg(a, c + 0);
		}
		break;
	case 4422: /* SUBU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBU4(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 = 72;
			_closure_reg(a, c + 0);
		}
		break;
	case 4423: /* SUBP4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBP4(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 = 71;
			_closure_reg(a, c + 0);
		}
		break;
	case 4437: /* LSHI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* rc: LSHI4(reg,rc5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_NT] + 0;
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 9;
		}
		/* reg: LSHI4(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 = 61;
			_closure_reg(a, c + 0);
		}
		break;
	case 4438: /* LSHU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* rc: LSHU4(reg,rc5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_NT] + 0;
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 10;
		}
		/* reg: LSHU4(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 = 62;
			_closure_reg(a, c + 0);
		}
		break;
	case 4453: /* MODI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODI4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 83;
			_closure_reg(a, c + 0);
		}
		break;
	case 4454: /* MODU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODU4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 84;
			_closure_reg(a, c + 0);
		}
		break;
	case 4469: /* RSHI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* rc: RSHI4(reg,rc5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_NT] + 0;
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 11;
		}
		/* reg: RSHI4(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 = 63;
			_closure_reg(a, c + 0);
		}
		break;
	case 4470: /* RSHU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* rc: RSHU4(reg,rc5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_NT] + 0;
		if (c + 0 < p->cost[_rc_NT]) {
			p->cost[_rc_NT] = c + 0;
			p->rule._rc = 12;
		}
		/* reg: RSHU4(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 = 64;
			_closure_reg(a, c + 0);
		}
		break;
	case 4485: /* BANDI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDI4(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 = 55;
			_closure_reg(a, c + 0);
		}
		break;
	case 4486: /* BANDU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDU4(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 = 56;
			_closure_reg(a, c + 0);
		}
		break;
	case 4501: /* BCOMI4 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMI4(rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 53;
			_closure_reg(a, c + 0);
		}
		break;
	case 4502: /* BCOMU4 */
		_label(LEFT_CHILD(a));
		/* reg: BCOMU4(rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 54;
			_closure_reg(a, c + 0);
		}
		break;
	case 4517: /* BORI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORI4(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 = 57;
			_closure_reg(a, c + 0);
		}
		break;
	case 4518: /* BORU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORU4(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 = 58;
			_closure_reg(a, c + 0);
		}
		break;
	case 4533: /* BXORI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORI4(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 = 59;
			_closure_reg(a, c + 0);
		}
		break;
	case 4534: /* BXORU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORU4(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 = 60;
			_closure_reg(a, c + 0);
		}
		break;
	case 4545: /* DIVF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 81;
			_closure_reg(a, c + 0);
		}
		break;
	case 4549: /* DIVI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVI4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 79;
			_closure_reg(a, c + 0);
		}
		break;
	case 4550: /* DIVU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVU4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 80;
			_closure_reg(a, c + 0);
		}
		break;
	case 4561: /* MULF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_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 4565: /* MULI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULI4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_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 4566: /* MULU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULU4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_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 4577: /* EQF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 36;
		}
		break;
	case 4581: /* EQI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQI4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 24;
		}
		break;
	case 4582: /* EQU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQU4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 25;
		}
		break;
	case 4593: /* GEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 42;
		}
		break;
	case 4597: /* GEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEI4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 26;
		}
		break;
	case 4598: /* GEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEU4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 27;
		}
		break;
	case 4609: /* GTF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 44;
		}
		break;
	case 4613: /* GTI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTI4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 28;
		}
		break;
	case 4614: /* GTU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTU4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 29;
		}
		break;
	case 4625: /* LEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 38;
		}
		break;
	case 4629: /* LEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEI4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 30;
		}
		break;
	case 4630: /* LEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEU4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 31;
		}
		break;
	case 4641: /* LTF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 40;
		}
		break;
	case 4645: /* LTI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTI4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 32;
		}
		break;
	case 4646: /* LTU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTU4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 33;
		}
		break;
	case 4657: /* NEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEF4(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 46;
		}
		break;
	case 4661: /* NEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEI4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 34;
		}
		break;
	case 4662: /* NEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEU4(reg,rc) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 35;
		}
		break;
	case 8209: /* CNSTF8 */
		break;
	case 8225: /* ARGF8 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGF8(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 = 52;
		}
		break;
	case 8241: /* ASGNF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNF8(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 = 10;
			}
		}
		/* stmt: ASGNF8(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 19;
		}
		/* stmt: ASGNF8(spill,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((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 = 70;
		}
		break;
	case 8257: /* INDIRF8 */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRF8(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[_con12_NT] == 0) {
					p->cost[_con12_NT] = 0;
					p->rule._con12 = q->rule._con12;
				}
				if (q->cost[_rc_NT] == 0) {
					p->cost[_rc_NT] = 0;
					p->rule._rc = q->rule._rc;
				}
				if (q->cost[_rc5_NT] == 0) {
					p->cost[_rc5_NT] = 0;
					p->rule._rc5 = q->rule._rc5;
				}
				if (q->cost[_bra_NT] == 0) {
					p->cost[_bra_NT] = 0;
					p->rule._bra = q->rule._bra;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_spill_NT] == 0) {
					p->cost[_spill_NT] = 0;
					p->rule._spill = q->rule._spill;
				}
			}
			c = 0;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 9;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: INDIRF8(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 40;
			_closure_reg(a, c + 0);
		}
		break;
	case 8305: /* CVFF8 */
		_label(LEFT_CHILD(a));
		/* reg: CVFF8(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (notarget(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 27;
			_closure_reg(a, c + 0);
		}
		/* reg: CVFF8(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 28;
			_closure_reg(a, c + 0);
		}
		break;
	case 8321: /* CVIF8 */
		_label(LEFT_CHILD(a));
		/* reg: CVIF8(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 = 31;
			_closure_reg(a, c + 0);
		}
		break;
	case 8385: /* NEGF8 */
		_label(LEFT_CHILD(a));
		/* reg: NEGF8(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 = 52;
			_closure_reg(a, c + 0);
		}
		break;
	case 8401: /* CALLF8 */
		_label(LEFT_CHILD(a));
		/* reg: CALLF8(bra) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_bra_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 89;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLF8(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 94;
			_closure_reg(a, c + 0);
		}
		break;
	case 8417: /* LOADF8 */
		_label(LEFT_CHILD(a));
		/* reg: LOADF8(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + (move(a));
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 49;
			_closure_reg(a, c + 0);
		}
		break;
	case 8433: /* RETF8 */
		_label(LEFT_CHILD(a));
		/* stmt: RETF8(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 = 61;
		}
		break;
	case 8497: /* ADDF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_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 8513: /* SUBF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_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 8641: /* DIVF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 82;
			_closure_reg(a, c + 0);
		}
		break;
	case 8657: /* MULF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_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 8673: /* EQF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 37;
		}
		break;
	case 8689: /* GEF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 43;
		}
		break;
	case 8705: /* GTF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 45;
		}
		break;
	case 8721: /* LEF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 39;
		}
		break;
	case 8737: /* LTF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 41;
		}
		break;
	case 8753: /* NEF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEF8(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 47;
		}
		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 77: /* addr: reg */
	case 58: /* bra: con */
	case 52: /* rc5: reg */
	case 38: /* rc: reg */
	case 34: /* reg: con */
	case 1: /* stmt: reg */
		kids[0] = p;
		break;
	case 200: /* spill: ADDRLP4 */
	case 149: /* stmt: LABELV */
	case 82: /* addr: ADDRLP4 */
	case 81: /* addr: ADDRFP4 */
	case 57: /* bra: ADDRGP4 */
	case 51: /* rc5: CNSTU4 */
	case 50: /* rc5: CNSTI4 */
	case 49: /* rc5: CNSTU2 */
	case 48: /* rc5: CNSTI2 */
	case 47: /* rc5: CNSTU1 */
	case 46: /* rc5: CNSTI1 */
	case 45: /* rc: CNSTP4 */
	case 44: /* rc: CNSTU4 */
	case 43: /* rc: CNSTI4 */
	case 42: /* rc: CNSTU2 */
	case 41: /* rc: CNSTI2 */
	case 40: /* rc: CNSTU1 */
	case 39: /* rc: CNSTI1 */
	case 37: /* reg: ADDRLP4 */
	case 36: /* reg: ADDRFP4 */
	case 35: /* reg: ADDRGP4 */
	case 33: /* con12: CNSTP4 */
	case 32: /* con12: CNSTU4 */
	case 31: /* con12: CNSTI4 */
	case 30: /* con12: CNSTU2 */
	case 29: /* con12: CNSTI2 */
	case 28: /* con12: CNSTU1 */
	case 27: /* con12: CNSTI1 */
	case 26: /* con: CNSTP4 */
	case 25: /* con: CNSTU4 */
	case 24: /* con: CNSTI4 */
	case 23: /* con: CNSTU2 */
	case 22: /* con: CNSTI2 */
	case 21: /* con: CNSTU1 */
	case 20: /* con: CNSTI1 */
	case 10: /* reg: INDIRF8(VREGP) */
	case 9: /* reg: INDIRU4(VREGP) */
	case 8: /* reg: INDIRP4(VREGP) */
	case 7: /* reg: INDIRI4(VREGP) */
	case 6: /* reg: INDIRF4(VREGP) */
	case 5: /* reg: INDIRU2(VREGP) */
	case 4: /* reg: INDIRI2(VREGP) */
	case 3: /* reg: INDIRU1(VREGP) */
	case 2: /* reg: INDIRI1(VREGP) */
		break;
	case 19: /* stmt: ASGNF8(VREGP,reg) */
	case 18: /* stmt: ASGNU4(VREGP,reg) */
	case 17: /* stmt: ASGNP4(VREGP,reg) */
	case 16: /* stmt: ASGNI4(VREGP,reg) */
	case 15: /* stmt: ASGNF4(VREGP,reg) */
	case 14: /* stmt: ASGNU2(VREGP,reg) */
	case 13: /* stmt: ASGNI2(VREGP,reg) */
	case 12: /* stmt: ASGNU1(VREGP,reg) */
	case 11: /* stmt: ASGNI1(VREGP,reg) */
		kids[0] = RIGHT_CHILD(p);
		break;
	case 209: /* stmt: ASGNF8(spill,reg) */
	case 208: /* stmt: ASGNF4(spill,reg) */
	case 207: /* stmt: ASGNU4(spill,reg) */
	case 206: /* stmt: ASGNP4(spill,reg) */
	case 205: /* stmt: ASGNI4(spill,reg) */
	case 204: /* stmt: ASGNU2(spill,reg) */
	case 203: /* stmt: ASGNI2(spill,reg) */
	case 202: /* stmt: ASGNU1(spill,reg) */
	case 201: /* stmt: ASGNI1(spill,reg) */
	case 175: /* stmt: NEF8(reg,reg) */
	case 174: /* stmt: NEF4(reg,reg) */
	case 173: /* stmt: GTF8(reg,reg) */
	case 172: /* stmt: GTF4(reg,reg) */
	case 171: /* stmt: GEF8(reg,reg) */
	case 170: /* stmt: GEF4(reg,reg) */
	case 169: /* stmt: LTF8(reg,reg) */
	case 168: /* stmt: LTF4(reg,reg) */
	case 167: /* stmt: LEF8(reg,reg) */
	case 166: /* stmt: LEF4(reg,reg) */
	case 165: /* stmt: EQF8(reg,reg) */
	case 164: /* stmt: EQF4(reg,reg) */
	case 163: /* stmt: NEU4(reg,rc) */
	case 162: /* stmt: NEI4(reg,rc) */
	case 161: /* stmt: LTU4(reg,rc) */
	case 160: /* stmt: LTI4(reg,rc) */
	case 159: /* stmt: LEU4(reg,rc) */
	case 158: /* stmt: LEI4(reg,rc) */
	case 157: /* stmt: GTU4(reg,rc) */
	case 156: /* stmt: GTI4(reg,rc) */
	case 155: /* stmt: GEU4(reg,rc) */
	case 154: /* stmt: GEI4(reg,rc) */
	case 153: /* stmt: EQU4(reg,rc) */
	case 152: /* stmt: EQI4(reg,rc) */
	case 148: /* reg: MODU4(reg,reg) */
	case 147: /* reg: MODI4(reg,reg) */
	case 146: /* reg: DIVF8(reg,reg) */
	case 145: /* reg: DIVF4(reg,reg) */
	case 144: /* reg: DIVU4(reg,reg) */
	case 143: /* reg: DIVI4(reg,reg) */
	case 142: /* reg: MULF8(reg,reg) */
	case 141: /* reg: MULF4(reg,reg) */
	case 140: /* reg: MULU4(reg,reg) */
	case 139: /* reg: MULI4(reg,reg) */
	case 138: /* reg: SUBF8(reg,reg) */
	case 137: /* reg: SUBF4(reg,reg) */
	case 136: /* reg: SUBU4(reg,rc) */
	case 135: /* reg: SUBP4(reg,rc) */
	case 134: /* reg: SUBI4(reg,rc) */
	case 133: /* reg: ADDF8(reg,reg) */
	case 132: /* reg: ADDF4(reg,reg) */
	case 131: /* reg: ADDU4(reg,rc) */
	case 130: /* reg: ADDP4(reg,rc) */
	case 129: /* reg: ADDI4(reg,rc) */
	case 128: /* reg: RSHU4(reg,rc) */
	case 127: /* reg: RSHI4(reg,rc) */
	case 126: /* reg: LSHU4(reg,rc) */
	case 125: /* reg: LSHI4(reg,rc) */
	case 124: /* reg: BXORU4(reg,rc) */
	case 123: /* reg: BXORI4(reg,rc) */
	case 122: /* reg: BORU4(reg,rc) */
	case 121: /* reg: BORI4(reg,rc) */
	case 120: /* reg: BANDU4(reg,rc) */
	case 119: /* reg: BANDI4(reg,rc) */
	case 103: /* stmt: ASGNF8(addr,reg) */
	case 102: /* stmt: ASGNF4(addr,reg) */
	case 101: /* stmt: ASGNP4(addr,reg) */
	case 100: /* stmt: ASGNU4(addr,reg) */
	case 99: /* stmt: ASGNI4(addr,reg) */
	case 98: /* stmt: ASGNU2(addr,reg) */
	case 97: /* stmt: ASGNI2(addr,reg) */
	case 96: /* stmt: ASGNU1(addr,reg) */
	case 95: /* stmt: ASGNI1(addr,reg) */
	case 85: /* addr: ADDP4(reg,reg) */
	case 84: /* addr: ADDU4(reg,reg) */
	case 83: /* addr: ADDI4(reg,reg) */
	case 80: /* addr: ADDP4(reg,con12) */
	case 79: /* addr: ADDU4(reg,con12) */
	case 78: /* addr: ADDI4(reg,con12) */
	case 56: /* rc: RSHU4(reg,rc5) */
	case 55: /* rc: RSHI4(reg,rc5) */
	case 54: /* rc: LSHU4(reg,rc5) */
	case 53: /* rc: LSHI4(reg,rc5) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = RIGHT_CHILD(p);
		break;
	case 199: /* stmt: RETF8(reg) */
	case 198: /* stmt: RETF4(reg) */
	case 197: /* stmt: RETU4(reg) */
	case 196: /* stmt: RETP4(reg) */
	case 195: /* stmt: RETI4(reg) */
	case 194: /* stmt: RETV(reg) */
	case 193: /* reg: CALLF8(reg) */
	case 192: /* reg: CALLF4(reg) */
	case 191: /* reg: CALLU4(reg) */
	case 190: /* reg: CALLP4(reg) */
	case 189: /* reg: CALLI4(reg) */
	case 188: /* stmt: CALLV(reg) */
	case 187: /* reg: CALLF8(bra) */
	case 186: /* reg: CALLF4(bra) */
	case 185: /* reg: CALLU4(bra) */
	case 184: /* reg: CALLP4(bra) */
	case 183: /* reg: CALLI4(bra) */
	case 182: /* stmt: CALLV(bra) */
	case 180: /* stmt: ARGF8(reg) */
	case 179: /* stmt: ARGF4(reg) */
	case 178: /* stmt: ARGU4(reg) */
	case 177: /* stmt: ARGP4(reg) */
	case 176: /* stmt: ARGI4(reg) */
	case 151: /* stmt: JUMPV(reg) */
	case 150: /* stmt: JUMPV(bra) */
	case 118: /* reg: BCOMU4(rc) */
	case 117: /* reg: BCOMI4(rc) */
	case 116: /* reg: NEGF8(reg) */
	case 115: /* reg: NEGF4(reg) */
	case 114: /* reg: NEGI4(reg) */
	case 113: /* reg: LOADF8(reg) */
	case 112: /* reg: LOADF4(reg) */
	case 111: /* reg: LOADU4(reg) */
	case 110: /* reg: LOADP4(reg) */
	case 109: /* reg: LOADI4(reg) */
	case 108: /* reg: LOADU2(reg) */
	case 107: /* reg: LOADI2(reg) */
	case 106: /* reg: LOADU1(reg) */
	case 105: /* reg: LOADI1(reg) */
	case 94: /* reg: INDIRF8(addr) */
	case 93: /* reg: INDIRF4(addr) */
	case 92: /* reg: INDIRP4(addr) */
	case 91: /* reg: INDIRU4(addr) */
	case 90: /* reg: INDIRI4(addr) */
	case 89: /* reg: INDIRU2(addr) */
	case 88: /* reg: INDIRI2(addr) */
	case 87: /* reg: INDIRU1(addr) */
	case 86: /* reg: INDIRI1(addr) */
	case 76: /* reg: CVIF8(reg) */
	case 75: /* reg: CVIF4(reg) */
	case 74: /* reg: CVFI4(reg) */
	case 73: /* reg: CVFF8(reg) */
	case 72: /* reg: CVFF8(reg) */
	case 71: /* reg: CVFF4(reg) */
	case 70: /* reg: CVFF4(reg) */
	case 67: /* reg: CVUU4(reg) */
	case 66: /* reg: CVUU4(reg) */
	case 63: /* reg: CVUI4(reg) */
	case 62: /* reg: CVUI4(reg) */
	case 59: /* reg: CVII4(reg) */
		kids[0] = LEFT_CHILD(p);
		break;
	case 181: /* stmt: ARGB(INDIRB(reg)) */
	case 69: /* reg: CVUU4(INDIRU2(reg)) */
	case 68: /* reg: CVUU4(INDIRU1(reg)) */
	case 65: /* reg: CVUI4(INDIRU2(reg)) */
	case 64: /* reg: CVUI4(INDIRU1(reg)) */
	case 61: /* reg: CVII4(INDIRI2(reg)) */
	case 60: /* reg: CVII4(INDIRI1(reg)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		break;
	case 104: /* stmt: ASGNB(reg,INDIRB(reg)) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = LEFT_CHILD(RIGHT_CHILD(p));
		break;
	default:
		fatal("_kids", "Bad rule number %d\n", eruleno);
	}
}

static void progend() {
	print("\tALIGN\t4\n");
	print("\tEND\n");
}
static void progbeg(argc, argv) int argc; char *argv[]; {
	int i;

	{
		union {
			char c;
			int i;
		} u;
		u.i = 0;
		u.c = 1;
		swap = ((int)(u.i == 1)) != ((int)IR->little_endian);
	}
	parseflags(argc, argv);
	for (i = 0; i < 8; i ++)
		freg[i] = mkreg("f%d", i, 1, FREG);
	for (i = 0; i < 16; i++) {
		if (i < 4)
			ireg[i] = mkreg(stringf("a%d", i + 1), i, 1, IREG);
		else if (i < 10)
			ireg[i] = mkreg(stringf("v%d", i - 3), i, 1, IREG);
		else
			ireg[i] = mkreg(NULL, i, 1, IREG);
	}
	ireg[10]->x.name = "sl";
	ireg[11]->x.name = "fp";
	ireg[12]->x.name = "ip";
	ireg[13]->x.name = "sp";
	ireg[14]->x.name = "lr";
	ireg[15]->x.name = "pc";
        fregw = mkwildcard(freg);
        iregw = mkwildcard(ireg);
	tmask[IREG] = INTTMP; tmask[FREG] = FLTTMP;
	vmask[IREG] = INTVAR; vmask[FREG] = FLTVAR;
}
static Symbol rmap(int opk) {
        switch (optype(opk)) {
        case I: case U: case P: case B:
                return iregw;
        case F:
                return fregw;
        default:
                return 0;
        }
}
static void target(p) Node p; {
	int n;

	assert(p);
	switch (specific(p->op)) {
	case CALL+F:
		setreg(p, freg[0]);     break;
	case CALL+I: case CALL+U: case CALL+P:
		setreg(p, ireg[0]);     break;
	case RET+F:
		rtarget(p, 0, freg[0]); break;
	case RET+I: case RET+U: case RET+P:
		rtarget(p, 0, ireg[0]);
		p->kids[0]->x.registered = 1;
		break;
	case ARG+I: case ARG+U: case ARG+P:
		n = p->x.argno;
		if (n < 4) {
			rtarget(p, 0, ireg[n]);
			setreg(p, ireg[n]);
		}
		break;
	case DIV+I: case DIV+U: case MOD+I: case MOD+U:
		setreg(p, ireg[0]);
		rtarget(p, 1, ireg[0]);
		rtarget(p, 0, ireg[1]);
		break;
	}
}
static void clobber(p) Node p; {
	int n;

	assert(p);
	switch (specific(p->op)) {
	case CALL+F: case CALL+I: case CALL+U: case CALL+P: case CALL+V:
		spill(0xf, FREG, p);
		break;
	}
}
static int imm(p) Node p; {
	unsigned long v;
	Symbol s = p->syms[0];

	switch (specific(p->op)) {
		case CNST+I:  v = s->u.c.v.i; break;
		case CNST+U:  v = s->u.c.v.u; break;
		case CNST+P:  if (s->u.c.v.p == 0) return 0;
		default:  return LBURG_MAX;
	}
	return imm_const(v);
}
static int imm_const(v) unsigned v; {
	int i;

	for (i = 0; i < 32; i += 2) {
		v = (v << 2) + (v >> 30);
		if (v < 0x100) return 0;
	}
	return LBURG_MAX;
}
static void emit2(p) Node p; {
	int src, dst, n, tmp;

	switch (specific(p->op)) {
	case ARG+I: case ARG+U: case ARG+P:
		n = p->x.argno;
		if (n >= 4) {
			src = getregnum(p->x.kids[0]);
			print("\tstr\t%s, [sp, #%d]\n",
				ireg[src]->x.name, n * 4 - 16);
		}
		break;
	case ARG+F:
		n = p->x.argno;
		src = getregnum(p->x.kids[0]);
		if (opsize(p->op) == 4) {
			print("\tstfs\t%s, [sp, #%d]\n",
				freg[src]->x.name, n * 4 - 16);
			if (n < 4)
				print("\tldr\t%s, [sp, #%d]\n",
					ireg[n]->x.name, n * 4 - 16);
		} else {
			print("\tstfd\t%s, [sp, #%d]\n",
				freg[src]->x.name, n * 4 - 16);
			if (n < 4)
				print("\tldr\t%s, [sp, #%d]\n",
					ireg[n]->x.name, n * 4 - 16);
			if (n < 3)
				print("\tldr\t%s, [sp, #%d]\n",
					ireg[n + 1]->x.name,
					(n + 1) * 4 - 16);
		}
		break;
	case ARG+B:
		{
			int size, offset;
			n = p->syms[RX]->u.c.v.i;
			size = roundup(p->syms[0]->u.c.v.i, 4);
			offset = max(16 - n, 0);
			if (offset < size)
				arm_blkcopy(13, n - 16 + offset + 16,
					getregnum(p->x.kids[0]), offset,
					size - offset);
			if (p->x.argno < 4) {
				tmp = min(p->x.argno + (size - 1) / 4, 3);
				if (tmp > p->x.argno)
					print("\tldmia\t%s, {%s-%s}\n",
						ireg[getregnum(p->x.kids[0])]->x.name,
						ireg[p->x.argno]->x.name,
						ireg[tmp]->x.name);
				else
					print("\tldr\t%s, [%s, #0]\n",
						ireg[p->x.argno]->x.name,
						ireg[getregnum(p->x.kids[0])]->x.name);
			}
		}
		break;
	case ASGN+B:
		arm_blkcopy(getregnum(p->x.kids[0]), 0,
			getregnum(p->x.kids[1]), 0,
			p->syms[0]->u.c.v.i);
		break;
	case CNST+I: case CNST+U: case CNST+P:
		dst = getregnum(p);
		arm_mov(dst, p->syms[0]->u.c.v.i);
		break;
	case ADDRF+P:
		arm_add(getregnum(p), 11, 4 - (bigargs ? 0 : sizeisave) +
			p->syms[0]->x.offset);
		break;
	case ADDRL+P:
		arm_add(getregnum(p), 13, framesize + p->syms[0]->x.offset);
		break;
	case MUL+I: case MUL+U:
		src = getregnum(p->x.kids[0]);
		n = getregnum(p->x.kids[1]);
		dst = getregnum(p);
		if (src == dst && dst == n) {
			print("\tmov\tip, %s\n", ireg[src]->x.name);
			src = 12;
		}
		if (src == dst) {
			tmp = src; src = n; n = tmp;
		}
		print("\tmul\t%s, %s, %s\n", ireg[dst]->x.name,
			ireg[src]->x.name, ireg[n]->x.name);
		break;
	}
}

static void arm_mov(dest, con) int dest; int con; {
	int inv = bitcount(con) > 16, n = 24;
	unsigned v;

	if (inv) con = ~con;
	while (n > 0 && (con & (0xc0 << n)) == 0)
		n -= 2;
	v = con & (0xff << n);
	if (inv) {
		print("\tmvn\t%s, #%d\n", ireg[dest]->x.name, v);
		con = (~con) - (~v);
	} else {
		print("\tmov\t%s, #%d\n", ireg[dest]->x.name, v);
		con -= v;
	}
	arm_add(dest, dest, con);
}
static void arm_add(dest, src, con) int dest, src; int con; {
	int n = 0;

	if (con == 0 && dest == src)
		return;
	if (con == 0) {
		print("\tmov\t%s, %s\n", ireg[dest]->x.name,
			ireg[src]->x.name);
		return;
	}
	do {
		for (; (con & 3) == 0; con >>= 2, n += 2);
		if (!(con & 0x100)) {
			print("\tadd\t%s, %s, #&%x\n",
				ireg[dest]->x.name, ireg[src]->x.name,
				(con & 0xff) << n);
			con -= con & 0xff;
		} else {
			print("\tsub\t%s, %s, #&%x\n",
				ireg[dest]->x.name, ireg[src]->x.name,
				(-con & 0xff) << n);
			con += -con & 0xff;
		}
		src = dest;
	} while (con);
}

static char *reglist(mask) unsigned mask; {
	int i, first = 1;
	static char list[16 * 4 + 1];

	list[0] = '\0';
	for (i = 0; i < 16; i++) {
		if (mask & (1<<i)) {
			if (first)
				first = 0;
			else
				strcat(list, ", ");
			strcat(list, ireg[i]->x.name);
		}
	}
	return list;
}


static void doarg(Node p) {
	assert(p && p->syms[0]);
	p->syms[RX] = intconst(mkactual(4, p->syms[0]->u.c.v.i));
	p->x.argno = p->syms[RX]->u.c.v.i / 4;
}
static void local(Symbol p) {
	if (askregvar(p, rmap(ttob(p->type))) == 0)
		mkauto(p);
}
static void function(Symbol f, Symbol caller[], Symbol callee[], int ncalls)
{
	int i, sizefsave, varargs, dumpmask = 0, reg = 0;

	for (i = 0; callee[i]; i++)
		;
	varargs = variadic(f->type)
		|| i > 0 && strcmp(callee[i-1]->name,
			"__builtin_va_alist") == 0;
	usedmask[0] = usedmask[1] = 0;
	freemask[0] = freemask[1] = ~(unsigned)0;
	offset = maxoffset = maxargoffset = 0;
	for (i = 0; callee[i]; i++) {
		Symbol p = callee[i], q = caller[i];
		int size = roundup(q->type->size, 4);
		assert(q);
		if (isfloat(p->type) || reg >= 4) {
			p->x.offset = q->x.offset = offset;
			p->x.name = q->x.name = stringd(offset);
			p->sclass = q->sclass = AUTO;
			dumpmask |= 0xffff>>(15 - reg);
			if (p->type->size == 8)
				dumpmask |= 1<<(reg + 1);
		}
		else if (p->addressed || varargs || isstruct(p->type)) {
				p->x.offset = offset;
				p->x.name = stringd(offset);
				p->sclass = q->sclass = AUTO;
				dumpmask |= 0xffff>>(16 - reg - size / 4);
		} else {
			q->type = p->type;
	        	p->sclass = q->sclass = REGISTER;
			if (askregvar(p, rmap(ttob(p->type))))
	        		q->x.name = ireg[reg]->x.name;
			else {
				p->sclass = q->sclass = AUTO;
				p->x.offset = offset;
				p->x.name = stringd(offset);
				dumpmask |= 0xffff>>(15 - reg);
			}
		}
		offset += size;
		reg += size / 4;
	}
	dumpmask &= 0xf;
	bigargs = (varargs || reg > 4) ? 1 : 0;
	assert(!caller[i]);
	offset = 0;
	gencode(caller, callee);
	maxargoffset = max(roundup(maxargoffset, 4) - 16, 0);
	sizefsave = 12*bitcount(usedmask[FREG] & 0xf0);
	sizeisave = 16 + 4*bitcount(usedmask[IREG] & 0x3f0) +
		4*bitcount(dumpmask);
	framesize = roundup(sizefsave + sizeisave + maxargoffset + maxoffset,
		4);
	segment(CODE);
	if (glevel) {
		print("\tALIGN\t4\n");
		defstring(strlen(f->x.name) + 1, f->x.name);
		print("\tALIGN\t4\n");
		print("\tdcd\t&%x\n", 0xff000000 | ((strlen(f->x.name) + 4) &
~3));
	}
	print("\tALIGN\t4\n");
	print("%s\n", f->x.name);
	print("\tmov\tip, sp\n");
	if (bigargs) {
		print("\tstmfd\tsp!, {a1-a4}\n");
		print("\tstmfd\tsp!, {%s}\n",
			reglist((usedmask[IREG] & 0x3f0) | savelist));
	} else {
		print("\tstmfd\tsp!, {%s}\n",
			reglist(dumpmask | (usedmask[IREG] & 0x3f0)
				| savelist));
	}
	for (i = 7; i >= 4; i--)
		if (usedmask[FREG] & (1<<i))
			print("\tstfe\t%s, [sp, #-12]!\n", freg[i]->x.name);
	print("\tsub\tfp, ip, #%d\n", bigargs ? 20 : 4);
	if (framesize + 16 > 256) {
		arm_add(12, 13, -(framesize + 16));
		print("\tcmp\tip, sl\n");
	} else
	    	print("\tcmp\tsp, sl\n");
    	print("\tbllt\t|x$stack_overflow|\n");
	if (framesize - sizefsave - sizeisave > 0)
		arm_add(13, 13, -(framesize - sizefsave - sizeisave));
	for (i = 0; i < 4 && callee[i]; i++)
		if (caller[i]->sclass == REGISTER &&
			callee[i]->sclass == REGISTER &&
			caller[i]->type == callee[i]->type)
			print("\tmov\t%s, %s\n", callee[i]->x.name,
				caller[i]->x.name);
	i = framesize;
	framesize -= sizefsave + sizeisave;
	emitcode();
	framesize = i;
	for (i = 4; i <= 7; i++)
		if (usedmask[FREG] & (1<<i))
			print("\tldfe\t%s, [fp, #-%d]\n", freg[i]->x.name,
				sizeisave - 4 * bitcount(dumpmask) +
				(8 - i) * 12 - 4);
	print("\tldmea\tfp, {%s}^\n",
		reglist((usedmask[IREG] & 0x3f0) | reslist));
}
static void defconst(int suffix, int size, Value v) {
	if (suffix == F && size == 4) {
 		float f = v.d;
 		print("\tdcd\t&%x\n", *(unsigned *)&f); return;
	}
	else if (suffix == F && size == 8) {
  		double d = v.d;
  		unsigned *p = (unsigned *)&d;
  		print("\tdcd\t&%x, &%x\n", p[swap], p[!swap]);
	}
	else if (suffix == P)
		print("\tdcd\t&%x\n", v.p);
	else if (size == 1)
		print("\tdcb\t%d\n", suffix == I ? (signed char)v.i : (unsigned char)v.u);
	else if (size == 2)
		print("\tdcw\t%d\n", suffix == I ? (short)v.i : (unsigned short)v.u);
	else if (size == 4)
		print("\tdcd\t%d\n", suffix == I ? (int)v.i : (unsigned)v.u);
}
static void defaddress(Symbol p) {
	print("\tdcd\t%s\n", p->x.name);
}
static void defstring(int n, char *str) {
	int mode, oldmode = 0;
	char *s, c;

	print("\t=\t");
	for (s = str; s < str + n; s++) {
	    	c = (*s) & 0xff;
	    	mode = (isprint(c) && c != '\"' && c != '\\') ? 1 : 0;
	    	if (oldmode && !mode)
	    		print("\",");
	    	else if (!oldmode && mode)
	    		print("\"");
	    	print(mode ? "%c" : "&%x", c);
	    	if (!mode && s < str + n - 1)
	    		print(",");
	    	oldmode = mode;
	}
	if (mode)
		print("\"");
	print("\n");
}
static void export(Symbol p) {
	print("\tEXPORT\t%s\n", p->x.name);
}
static void import(Symbol p) {}
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
		assert(p->scope != CONSTANTS || isint(p->type) || isptr(p->type)),
		p->x.name = p->name;
}
static void address(Symbol q, Symbol p, int n) {
	q->x.offset = p->x.offset + 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
		q->x.name = stringf("%d", q->x.offset);
}
static void global(Symbol p) {
	if (p->u.seg == BSS) {
		if (p->sclass == STATIC || Aflag >= 2) {
			if (cseg != BSS)
				print("\tAREA\t|C$$zidata|, DATA, NOINIT\n");
			if (p->type->align > 1)
				print("\tALIGN\t%d\n", p->type->align);
			print("%s\n\t%%\t%d\n", p->x.name, p->type->size);
		} else {
			print("\tAREA\t%s, COMMON, NOINIT\n", p->x.name);
			if (p->type->align > 1)
				print("\tALIGN\t%d\n", p->type->align);
			print("\t%%\t%d\n", p->type->size);
		}
		print("\tAREA\t|C$$code|, CODE, READONLY\n");
	} else {
		if (p->u.seg == DATA)
			print("\tAREA\t|C$$data|, DATA\n");
		if (p->type->align > 1)
			print("\tALIGN\t%d\n", p->type->align);
		print("%s\n", p->x.name);
	}
}
static void segment(int n) {
	if (cseg == n) return;
	cseg = n;
	switch (n) {
	case CODE: case LIT:
		print("\tAREA\t|C$$code|, CODE, READONLY\n"); break;
	case BSS:  print("\tAREA\t|C$$zidata|, DATA, NOINIT\n"); break;
	}
}
static void space(int n) {
	if (cseg != BSS)
		print("\t%%\t%d\n", n);
}
static void arm_blkcopy(int dreg, int doffset, int sreg, int soffset, int size)
{
	print("\tstmfd\tsp!, {a1-a4}\n");
	arm_add(0, dreg, doffset);
	arm_add(1, sreg, soffset);
	arm_mov(2, size);
	print("\tbl\tmemcpy\n");
	print("\tldmfd\tsp!, {a1-a4}\n");
}
static void blkloop(int dreg, int doff, int sreg, int soff, int size, int tmps[]) {}
static void blkfetch(int size, int off, int reg, int tmp) {}
static void blkstore(int size, int off, int reg, int tmp) {}

static int bitcount(unsigned mask) {
	unsigned i, n = 0;

	for (i = 1; i; i <<= 1)
		if (mask&i)
			n++;
	return n;
}

Interface armIR = {
	1, 1, 0,  /* char */
	2, 2, 0,  /* short */
	4, 4, 0,  /* int */
	4, 4, 0,  /* long */
	4, 4, 1,  /* float */
	8, 4, 1,  /* double */
	8, 4, 1,  /* long double */
	4, 4, 0,  /* T * */
	0, 4, 0,  /* struct */
	1,  /* little_endian */
	1,  /* mulops_calls */
	0,  /* wants_callb */
	1,  /* wants_argb */
	1,  /* left_to_right */
	0,  /* wants_dag */
	address,
	blockbeg,
	blockend,
	defaddress,
	defconst,
	defstring,
	defsymbol,
	emit,
	export,
	function,
	gen,
	global,
	import,
	local,
	progbeg,
	progend,
	segment,
	space,
	0, 0, 0, 0, 0, 0, 0,
	{
		1,	/* max_unaligned_load */
		rmap,
		blkfetch, blkstore, blkloop,
		_label,
		_rule,
		_nts,
		_kids,
		_string,
		_templates,
		_isinstruction,
		_ntname,
		emit2,
		doarg,
		target,
		clobber,

	}
};
