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

/* Platform specific assembler directives.  These macros allow  generation
   of the majority of the code that differs between the ARM and GNU assembler
   formats for ARM assembler.  The remainder of differences are dealt with
   on a case-by-case basis within code generation.                           */


#ifdef __riscos__

#define ASM_ALIGN          "\tALIGN\t4\n"
#define ASM_EXPORT         "\tEXPORT\t%s\n"
#define ASM_ALABEL         "%a"
#define ASM_SYMBOL_NUM     "|L..%d|"
#define ASM_SYMBOL_NAME    "|L..%s|"
#define ASM_CONST_WORD     "\tdcd\t"
#define ASM_CONST_BYTE     "\tdcb\t"
#define ASM_COMMENT        "\t; "
#define ASM_SPACE          "\t%%\t"
#define ASM_SDIVIDE        "\t|x$divide|"
#define ASM_UDIVIDE        "\t|x$udivide|"
#define ASM_SREMAINDER     "\t|x$remainder|"
#define ASM_UREMAINDER     "\t|x$uremainder|"


#else

#define ASM_ALIGN          "\t.align\t4\n"
#define ASM_EXPORT         "\t.global\t%s\n"
#define ASM_ALABEL         "%a:"
#define ASM_SYMBOL_NUM     ".L%d"
#define ASM_SYMBOL_NAME    ".L%s"
#define ASM_CONST_WORD     "\t.word\t"
#define ASM_CONST_BYTE     "\t.byte\t"
#define ASM_COMMENT        "\t@ "
#define ASM_SPACE          "\t.space\t"
#define ASM_SDIVIDE        "\t__divsi3"
#define ASM_SREMAINDER     "\t__modsi3"

#endif


#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, long);
static void blkfetch(int, int, int, int);
static void blkloop(int, int, int, int, int, int[]);
static void blkstore(int, int, int, int);
static void defaddress(Symbol);
static void defconst(int, int, Value);
static void defstring(int, char *);
static void defsymbol(Symbol);
static void doarg(Node);
static void emit2(Node);
static void export(Symbol);
static void clobber(Node);
static void function(Symbol, Symbol [], Symbol [], int);
static void global(Symbol);
static void import(Symbol);
static void local(Symbol);
static void progbeg(int, char **);
static void progend(void);
static void segment(int);
static void space(int);
static void target(Node);
static int  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 Sun Jun  9 11:27:53 2002
by $Id: lburg.c,v 1.1.1.2 2002/04/21 13:25:15 peter 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 _rc_NT 4
#define _rc5_NT 5
#define _bra_NT 6
#define _spill_NT 7

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

struct _state {
	short cost[8];
	struct {
		unsigned int _stmt:7;
		unsigned int _reg:7;
		unsigned int _con:3;
		unsigned int _rc:4;
		unsigned int _rc5:3;
		unsigned int _bra:2;
		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, _reg_NT, 0 };
static short _nts_5[] = { _rc_NT, 0 };
static short _nts_6[] = { _reg_NT, _rc_NT, 0 };
static short _nts_7[] = { _bra_NT, 0 };
static short _nts_8[] = { _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_2,	/* 27 */
	_nts_1,	/* 28 */
	_nts_1,	/* 29 */
	_nts_1,	/* 30 */
	_nts_0,	/* 31 */
	_nts_1,	/* 32 */
	_nts_1,	/* 33 */
	_nts_1,	/* 34 */
	_nts_1,	/* 35 */
	_nts_1,	/* 36 */
	_nts_1,	/* 37 */
	_nts_1,	/* 38 */
	_nts_1,	/* 39 */
	_nts_1,	/* 40 */
	_nts_1,	/* 41 */
	_nts_1,	/* 42 */
	_nts_1,	/* 43 */
	_nts_1,	/* 44 */
	_nts_0,	/* 45 */
	_nts_3,	/* 46 */
	_nts_3,	/* 47 */
	_nts_3,	/* 48 */
	_nts_3,	/* 49 */
	_nts_1,	/* 50 */
	_nts_2,	/* 51 */
	_nts_0,	/* 52 */
	_nts_0,	/* 53 */
	_nts_0,	/* 54 */
	_nts_0,	/* 55 */
	_nts_0,	/* 56 */
	_nts_0,	/* 57 */
	_nts_0,	/* 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_0,	/* 78 */
	_nts_4,	/* 79 */
	_nts_4,	/* 80 */
	_nts_4,	/* 81 */
	_nts_4,	/* 82 */
	_nts_4,	/* 83 */
	_nts_4,	/* 84 */
	_nts_4,	/* 85 */
	_nts_4,	/* 86 */
	_nts_4,	/* 87 */
	_nts_4,	/* 88 */
	_nts_0,	/* 89 */
	_nts_0,	/* 90 */
	_nts_0,	/* 91 */
	_nts_0,	/* 92 */
	_nts_0,	/* 93 */
	_nts_0,	/* 94 */
	_nts_0,	/* 95 */
	_nts_0,	/* 96 */
	_nts_0,	/* 97 */
	_nts_0,	/* 98 */
	_nts_0,	/* 99 */
	_nts_0,	/* 100 */
	_nts_5,	/* 101 */
	_nts_5,	/* 102 */
	_nts_6,	/* 103 */
	_nts_6,	/* 104 */
	_nts_6,	/* 105 */
	_nts_6,	/* 106 */
	_nts_6,	/* 107 */
	_nts_6,	/* 108 */
	_nts_6,	/* 109 */
	_nts_6,	/* 110 */
	_nts_6,	/* 111 */
	_nts_6,	/* 112 */
	_nts_6,	/* 113 */
	_nts_6,	/* 114 */
	_nts_6,	/* 115 */
	_nts_4,	/* 116 */
	_nts_4,	/* 117 */
	_nts_6,	/* 118 */
	_nts_6,	/* 119 */
	_nts_6,	/* 120 */
	_nts_4,	/* 121 */
	_nts_4,	/* 122 */
	_nts_4,	/* 123 */
	_nts_4,	/* 124 */
	_nts_4,	/* 125 */
	_nts_4,	/* 126 */
	_nts_4,	/* 127 */
	_nts_4,	/* 128 */
	_nts_4,	/* 129 */
	_nts_4,	/* 130 */
	_nts_4,	/* 131 */
	_nts_4,	/* 132 */
	_nts_1,	/* 133 */
	_nts_7,	/* 134 */
	_nts_0,	/* 135 */
	_nts_6,	/* 136 */
	_nts_6,	/* 137 */
	_nts_6,	/* 138 */
	_nts_6,	/* 139 */
	_nts_6,	/* 140 */
	_nts_6,	/* 141 */
	_nts_6,	/* 142 */
	_nts_6,	/* 143 */
	_nts_6,	/* 144 */
	_nts_6,	/* 145 */
	_nts_6,	/* 146 */
	_nts_6,	/* 147 */
	_nts_4,	/* 148 */
	_nts_4,	/* 149 */
	_nts_4,	/* 150 */
	_nts_4,	/* 151 */
	_nts_4,	/* 152 */
	_nts_4,	/* 153 */
	_nts_4,	/* 154 */
	_nts_4,	/* 155 */
	_nts_4,	/* 156 */
	_nts_4,	/* 157 */
	_nts_4,	/* 158 */
	_nts_4,	/* 159 */
	_nts_0,	/* 160 */
	_nts_0,	/* 161 */
	_nts_0,	/* 162 */
	_nts_0,	/* 163 */
	_nts_0,	/* 164 */
	_nts_0,	/* 165 */
	_nts_7,	/* 166 */
	_nts_7,	/* 167 */
	_nts_7,	/* 168 */
	_nts_7,	/* 169 */
	_nts_7,	/* 170 */
	_nts_7,	/* 171 */
	_nts_0,	/* 172 */
	_nts_0,	/* 173 */
	_nts_0,	/* 174 */
	_nts_0,	/* 175 */
	_nts_0,	/* 176 */
	_nts_0,	/* 177 */
	_nts_0,	/* 178 */
	_nts_0,	/* 179 */
	_nts_0,	/* 180 */
	_nts_0,	/* 181 */
	_nts_0,	/* 182 */
	_nts_0,	/* 183 */
	_nts_1,	/* 184 */
	_nts_8,	/* 185 */
	_nts_8,	/* 186 */
	_nts_8,	/* 187 */
	_nts_8,	/* 188 */
	_nts_8,	/* 189 */
	_nts_8,	/* 190 */
	_nts_8,	/* 191 */
	_nts_8,	/* 192 */
	_nts_8,	/* 193 */
};

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

static short _decode_stmt[] = {
	0,
	1,
	11,
	12,
	13,
	14,
	15,
	16,
	17,
	18,
	19,
	79,
	80,
	81,
	82,
	83,
	84,
	85,
	86,
	87,
	88,
	133,
	134,
	135,
	136,
	137,
	138,
	139,
	140,
	141,
	142,
	143,
	144,
	145,
	146,
	147,
	148,
	149,
	150,
	151,
	152,
	153,
	154,
	155,
	156,
	157,
	158,
	159,
	160,
	161,
	162,
	163,
	164,
	165,
	166,
	172,
	178,
	179,
	180,
	181,
	182,
	183,
	185,
	186,
	187,
	188,
	189,
	190,
	191,
	192,
	193,
};

static short _decode_reg[] = {
	0,
	2,
	3,
	4,
	5,
	6,
	7,
	8,
	9,
	10,
	27,
	28,
	29,
	30,
	52,
	53,
	54,
	55,
	56,
	57,
	58,
	59,
	60,
	61,
	62,
	63,
	64,
	65,
	66,
	67,
	68,
	69,
	70,
	71,
	72,
	73,
	74,
	75,
	76,
	77,
	78,
	89,
	90,
	91,
	92,
	93,
	94,
	95,
	96,
	97,
	98,
	99,
	100,
	101,
	102,
	103,
	104,
	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,
	167,
	168,
	169,
	170,
	171,
	173,
	174,
	175,
	176,
	177,
};

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

static short _decode_rc[] = {
	0,
	31,
	32,
	33,
	34,
	35,
	36,
	37,
	38,
	46,
	47,
	48,
	49,
};

static short _decode_rc5[] = {
	0,
	39,
	40,
	41,
	42,
	43,
	44,
	45,
};

static short _decode_bra[] = {
	0,
	50,
	51,
};

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

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 7)
		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 _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 _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[_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] =
		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);
		}
		/* 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);
		}
		/* 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(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 = 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(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 = 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[_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[_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(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_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[_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[_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(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 = 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);
		}
		/* 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);
		}
		/* 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(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_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(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_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[_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[_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(reg) */
		c = ((struct _state *)(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 = 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[_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[_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(reg) */
		c = ((struct _state *)(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 = 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);
		}
		/* 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);
		}
		/* 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);
		}
		/* 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(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 = 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(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 = 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(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 = 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(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 = 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[_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[_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(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 = 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[_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[_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(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 = 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[_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[_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(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 = 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[_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[_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(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 = 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);
		}
		break;
	case 4391: /* ADDRLP4 */
		/* reg: ADDRLP4 */
		if (2 + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = 2 + 0;
			p->rule._reg = 13;
			_closure_reg(a, 2 + 0);
		}
		/* spill: ADDRLP4 */
		if (0 + 0 < p->cost[_spill_NT]) {
			p->cost[_spill_NT] = 0 + 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));
		/* 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));
		/* 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));
		/* 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(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 = 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[_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[_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(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 = 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 51: /* bra: con */
	case 45: /* rc5: reg */
	case 31: /* rc: reg */
	case 27: /* reg: con */
	case 1: /* stmt: reg */
		kids[0] = p;
		break;
	case 184: /* spill: ADDRLP4 */
	case 133: /* stmt: LABELV */
	case 50: /* bra: ADDRGP4 */
	case 44: /* rc5: CNSTU4 */
	case 43: /* rc5: CNSTI4 */
	case 42: /* rc5: CNSTU2 */
	case 41: /* rc5: CNSTI2 */
	case 40: /* rc5: CNSTU1 */
	case 39: /* rc5: CNSTI1 */
	case 38: /* rc: CNSTP4 */
	case 37: /* rc: CNSTU4 */
	case 36: /* rc: CNSTI4 */
	case 35: /* rc: CNSTU2 */
	case 34: /* rc: CNSTI2 */
	case 33: /* rc: CNSTU1 */
	case 32: /* rc: CNSTI1 */
	case 30: /* reg: ADDRLP4 */
	case 29: /* reg: ADDRFP4 */
	case 28: /* reg: ADDRGP4 */
	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 193: /* stmt: ASGNF8(spill,reg) */
	case 192: /* stmt: ASGNF4(spill,reg) */
	case 191: /* stmt: ASGNU4(spill,reg) */
	case 190: /* stmt: ASGNP4(spill,reg) */
	case 189: /* stmt: ASGNI4(spill,reg) */
	case 188: /* stmt: ASGNU2(spill,reg) */
	case 187: /* stmt: ASGNI2(spill,reg) */
	case 186: /* stmt: ASGNU1(spill,reg) */
	case 185: /* stmt: ASGNI1(spill,reg) */
	case 159: /* stmt: NEF8(reg,reg) */
	case 158: /* stmt: NEF4(reg,reg) */
	case 157: /* stmt: GTF8(reg,reg) */
	case 156: /* stmt: GTF4(reg,reg) */
	case 155: /* stmt: GEF8(reg,reg) */
	case 154: /* stmt: GEF4(reg,reg) */
	case 153: /* stmt: LTF8(reg,reg) */
	case 152: /* stmt: LTF4(reg,reg) */
	case 151: /* stmt: LEF8(reg,reg) */
	case 150: /* stmt: LEF4(reg,reg) */
	case 149: /* stmt: EQF8(reg,reg) */
	case 148: /* stmt: EQF4(reg,reg) */
	case 147: /* stmt: NEU4(reg,rc) */
	case 146: /* stmt: NEI4(reg,rc) */
	case 145: /* stmt: LTU4(reg,rc) */
	case 144: /* stmt: LTI4(reg,rc) */
	case 143: /* stmt: LEU4(reg,rc) */
	case 142: /* stmt: LEI4(reg,rc) */
	case 141: /* stmt: GTU4(reg,rc) */
	case 140: /* stmt: GTI4(reg,rc) */
	case 139: /* stmt: GEU4(reg,rc) */
	case 138: /* stmt: GEI4(reg,rc) */
	case 137: /* stmt: EQU4(reg,rc) */
	case 136: /* stmt: EQI4(reg,rc) */
	case 132: /* reg: MODU4(reg,reg) */
	case 131: /* reg: MODI4(reg,reg) */
	case 130: /* reg: DIVF8(reg,reg) */
	case 129: /* reg: DIVF4(reg,reg) */
	case 128: /* reg: DIVU4(reg,reg) */
	case 127: /* reg: DIVI4(reg,reg) */
	case 126: /* reg: MULF8(reg,reg) */
	case 125: /* reg: MULF4(reg,reg) */
	case 124: /* reg: MULU4(reg,reg) */
	case 123: /* reg: MULI4(reg,reg) */
	case 122: /* reg: SUBF8(reg,reg) */
	case 121: /* reg: SUBF4(reg,reg) */
	case 120: /* reg: SUBU4(reg,rc) */
	case 119: /* reg: SUBP4(reg,rc) */
	case 118: /* reg: SUBI4(reg,rc) */
	case 117: /* reg: ADDF8(reg,reg) */
	case 116: /* reg: ADDF4(reg,reg) */
	case 115: /* reg: ADDU4(reg,rc) */
	case 114: /* reg: ADDP4(reg,rc) */
	case 113: /* reg: ADDI4(reg,rc) */
	case 112: /* reg: RSHU4(reg,rc) */
	case 111: /* reg: RSHI4(reg,rc) */
	case 110: /* reg: LSHU4(reg,rc) */
	case 109: /* reg: LSHI4(reg,rc) */
	case 108: /* reg: BXORU4(reg,rc) */
	case 107: /* reg: BXORI4(reg,rc) */
	case 106: /* reg: BORU4(reg,rc) */
	case 105: /* reg: BORI4(reg,rc) */
	case 104: /* reg: BANDU4(reg,rc) */
	case 103: /* reg: BANDI4(reg,rc) */
	case 87: /* stmt: ASGNF8(reg,reg) */
	case 86: /* stmt: ASGNF4(reg,reg) */
	case 85: /* stmt: ASGNP4(reg,reg) */
	case 84: /* stmt: ASGNU4(reg,reg) */
	case 83: /* stmt: ASGNI4(reg,reg) */
	case 82: /* stmt: ASGNU2(reg,reg) */
	case 81: /* stmt: ASGNI2(reg,reg) */
	case 80: /* stmt: ASGNU1(reg,reg) */
	case 79: /* stmt: ASGNI1(reg,reg) */
	case 49: /* rc: RSHU4(reg,rc5) */
	case 48: /* rc: RSHI4(reg,rc5) */
	case 47: /* rc: LSHU4(reg,rc5) */
	case 46: /* rc: LSHI4(reg,rc5) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = RIGHT_CHILD(p);
		break;
	case 183: /* stmt: RETF8(reg) */
	case 182: /* stmt: RETF4(reg) */
	case 181: /* stmt: RETU4(reg) */
	case 180: /* stmt: RETP4(reg) */
	case 179: /* stmt: RETI4(reg) */
	case 178: /* stmt: RETV(reg) */
	case 177: /* reg: CALLF8(reg) */
	case 176: /* reg: CALLF4(reg) */
	case 175: /* reg: CALLU4(reg) */
	case 174: /* reg: CALLP4(reg) */
	case 173: /* reg: CALLI4(reg) */
	case 172: /* stmt: CALLV(reg) */
	case 171: /* reg: CALLF8(bra) */
	case 170: /* reg: CALLF4(bra) */
	case 169: /* reg: CALLU4(bra) */
	case 168: /* reg: CALLP4(bra) */
	case 167: /* reg: CALLI4(bra) */
	case 166: /* stmt: CALLV(bra) */
	case 164: /* stmt: ARGF8(reg) */
	case 163: /* stmt: ARGF4(reg) */
	case 162: /* stmt: ARGU4(reg) */
	case 161: /* stmt: ARGP4(reg) */
	case 160: /* stmt: ARGI4(reg) */
	case 135: /* stmt: JUMPV(reg) */
	case 134: /* stmt: JUMPV(bra) */
	case 102: /* reg: BCOMU4(rc) */
	case 101: /* reg: BCOMI4(rc) */
	case 100: /* reg: NEGF8(reg) */
	case 99: /* reg: NEGF4(reg) */
	case 98: /* reg: NEGI4(reg) */
	case 97: /* reg: LOADF8(reg) */
	case 96: /* reg: LOADF4(reg) */
	case 95: /* reg: LOADU4(reg) */
	case 94: /* reg: LOADP4(reg) */
	case 93: /* reg: LOADI4(reg) */
	case 92: /* reg: LOADU2(reg) */
	case 91: /* reg: LOADI2(reg) */
	case 90: /* reg: LOADU1(reg) */
	case 89: /* reg: LOADI1(reg) */
	case 78: /* reg: INDIRF8(reg) */
	case 77: /* reg: INDIRF4(reg) */
	case 76: /* reg: INDIRP4(reg) */
	case 75: /* reg: INDIRU4(reg) */
	case 74: /* reg: INDIRI4(reg) */
	case 73: /* reg: INDIRU2(reg) */
	case 72: /* reg: INDIRI2(reg) */
	case 71: /* reg: INDIRU1(reg) */
	case 70: /* reg: INDIRI1(reg) */
	case 69: /* reg: CVIF8(reg) */
	case 68: /* reg: CVIF4(reg) */
	case 67: /* reg: CVFI4(reg) */
	case 66: /* reg: CVFF8(reg) */
	case 65: /* reg: CVFF8(reg) */
	case 64: /* reg: CVFF4(reg) */
	case 63: /* reg: CVFF4(reg) */
	case 60: /* reg: CVUU4(reg) */
	case 59: /* reg: CVUU4(reg) */
	case 56: /* reg: CVUI4(reg) */
	case 55: /* reg: CVUI4(reg) */
	case 52: /* reg: CVII4(reg) */
		kids[0] = LEFT_CHILD(p);
		break;
	case 165: /* stmt: ARGB(INDIRB(reg)) */
	case 62: /* reg: CVUU4(INDIRU2(reg)) */
	case 61: /* reg: CVUU4(INDIRU1(reg)) */
	case 58: /* reg: CVUI4(INDIRU2(reg)) */
	case 57: /* reg: CVUI4(INDIRU1(reg)) */
	case 54: /* reg: CVII4(INDIRI2(reg)) */
	case 53: /* reg: CVII4(INDIRI1(reg)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		break;
	case 88: /* 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() {
#ifdef __riscos__
	print(ASM_ALIGN);
	print("\tEND\n");
#else
	print("\t.ident \"lcc ARM backend\"\n");
#endif
}
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("", 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, #0x%x\n",
				ireg[dest]->x.name, ireg[src]->x.name,
				(con & 0xff) << n);
			con -= con & 0xff;
		} else {
			print("\tsub\t%s, %s, #0x%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(ASM_ALIGN);
		defstring(strlen(f->x.name) + 1, f->x.name);
		print(ASM_ALIGN);
		print("\tdcd\t&%x\n", 0xff000000 | ((strlen(f->x.name) + 4) &
~3));
	}
	print(ASM_ALIGN);
#ifdef __riscos__
	print("|%s|\n", f->x.name);
#else
	print("%s:\n", f->x.name);
#endif

        /* APCS Function header to save registers */
	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);


       /* Output APCS stack overflow check */
#ifdef __riscos__
        if (framesize + 16 > 256) {
                arm_add(12, 13, -(framesize + 16));
                print("\tcmp\tip, sl\n");
                print("\tbllt\t|x$stack_overflow_1|\n");
        } else {
                print("\tcmp\tsp, sl\n");
                print("\tbllt\t|x$stack_overflow|\n");
        }
#endif

	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);

        /* Restore saved registers used by function */
	print("\tldmea\tfp, {%s}^\n",
		reglist((usedmask[IREG] & 0x3f0) | reslist));
}


/**
 * Output a constant inline in assmebler of the given type and value
 */
static void defconst(int suffix, int size, Value v) {
        /* float */
	if (suffix == F && size == 4) {
 		float f = v.d;
 		print(ASM_CONST_WORD "0x%x" ASM_COMMENT "float %f\n", *(unsigned *)&f, f); return;
	}
	/* double */
	else if (suffix == F && size == 8) {
  		double d = v.d;
  		unsigned *p = (unsigned *)&d;
  		print(ASM_CONST_WORD "0x%x, 0x%x" ASM_COMMENT "double %f\n", p[swap], p[!swap], d);
	}
        /* pointer */
	else if (suffix == P)
		print(ASM_CONST_WORD "0x%x\n", v.p);
        /* byte */
	else if (size == 1)
		print(ASM_CONST_BYTE "%d\n", suffix == I ? (signed char)v.i : (unsigned char)v.u);
        /* short */
	else if (size == 2)
		print("\tdcw\t%d\n", suffix == I ? (short)v.i : (unsigned short)v.u);
        /* int */        
	else if (size == 4)
		print(ASM_CONST_WORD "%d\n", suffix == I ? (int)v.i : (unsigned)v.u);
}


/**
 * Output address of a given symbol
 */
static void defaddress(Symbol p) {
	print(ASM_CONST_WORD "%s\n", p->x.name);
}


/**
 * Output a counted string suitable for assembler
 */
static void defstring(int n, char *str) {
	int mode, oldmode = 0;
	char *s, c;

#ifdef __riscos__
	print("\t=\t");
#else
	print("\t.ascii \"");
#endif
	for (s = str; s < str + n; s++) {
	    	c = (*s) & 0xff;
	    	mode = (isprint(c) && c != '\"' && c != '\\') ? 1 : 0;
#ifdef __riscos__
                if (oldmode && !mode)
                	print("\",");
                else if (!oldmode && mode)
                	print("\"");
                print(mode ? "%c" : "&%x", c);
                if (!mode && s < str + n - 1)
                	print(",");
#else
                if (mode)
                        print("%c", c);
                else
	    	        print("\\%d%d%d", c >> 6, (c >> 3) & 3, c & 3);
#endif
	    	oldmode = mode;
	}
#ifdef __riscos__
	if (mode)
#endif
		print("\"");
	print("\n");
}


static void export(Symbol p) {
	print(ASM_EXPORT, p->x.name);
}


static void import(Symbol p) {
#if 0
#ifdef __riscos__
	print("\tIMPORT\t|%s|\n", p->x.name);
#endif
#endif
}


static void defsymbol(Symbol p) {
	if (p->scope >= LOCAL && p->sclass == STATIC)
		p->x.name = stringf(ASM_SYMBOL_NUM, genlabel(1));
	else if (p->generated)
		p->x.name = stringf(ASM_SYMBOL_NAME, 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, long 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) {
#ifdef __riscos__
	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);
	}
#else
        assert(p->u.seg);
        if (!p->generated) {
                print(".type %s,#%s\n", p->x.name,
                          isfunc(p->type) ? "function" : "object");
                if (p->type->size > 0)
                        print(".size %s,%d\n", p->x.name, p->type->size);

                /* else
                         prevg = p; */
        }
        if (p->u.seg == BSS && p->sclass == STATIC)
                print(".local %s\n.common %s,%d,%d\n", p->x.name, p->x.name,
                          p->type->size, p->type->align);
        else if (p->u.seg == BSS && Aflag >= 2)
                print(".align %d\n%s:.skip %d\n", p->type->align, p->x.name,
                          p->type->size);
        else if (p->u.seg == BSS)
                print(".common %s,%d,%d\n", p->x.name, p->type->size, p->type->align);
        else
                print(".align %d\n%s:\n", p->type->align, p->x.name);
#endif
}


static void segment(int n) {
#ifdef __riscos__
	if (cseg == n) return;
#endif
	cseg = n;
	switch (n) {
#ifdef __riscos__
	case CODE: case LIT:
		print("\tAREA\t|C$$code|, CODE, READONLY\n"); break;
	case BSS:  print("\tAREA\t|C$$zidata|, DATA, NOINIT\n"); break;
#else
        case CODE: print(".text\n");   break;
        case BSS:  print(".bss\n");    break;
        case DATA: print(".data\n");   break;
        case LIT:  print(".section\t.rodata\n"); break;
#endif
	}
}


static void space(int n) {
	if (cseg != BSS)
		print(ASM_SPACE "%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, 0,  /* long 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 */
	0,  /* unsigned_char */ 
	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,

	}
};
