/* R0, R3-R12 are scratch at a call site, with R3-R10 as register parms.  We 
 * must reserve R1 (SP) and R2 (TOC).  Return value in R3; structure return
 * passes a hidden extra parameter.  We use R0, R11, and R12 for block copies,
 * and R31 for a Frame Pointer (FP).  We intermingle temps & register vars. 
 * Temps from register 31 down to 13 and reg-vars from 31 down to 20.
 */
#define    INTTMP 0x7fffe000
#define    INTVAR 0x7ff00000

/* Float registers 14-31 are preserved across calls, with F1-F13 for arguments.
 * Use registers 14-31 as temps and 20-31 as reg vars.
 */
#define FLTTMP 0xffffc000
#define FLTVAR 0xfff00000

#define readsreg(p) \
	(generic((p)->op)==INDIR && (p)->kids[0]->op==VREG+P)

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

#include "c.h"

#define TOC_SEG 5		/* Special Power ABI segment */
#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     ARGS((Symbol, Symbol, int));
static void blkfetch    ARGS((int, int, int, int));
static void blkloop     ARGS((int, int, int, int, int, int[]));
static void blkstore    ARGS((int, int, int, int));
static void defaddress  ARGS((Symbol));
static void defconst    ARGS((int, Value));
static void defstring   ARGS((int, char *));
static void defsymbol   ARGS((Symbol));
static void doarg       ARGS((Node));
static void emit2       ARGS((Node));
static void export      ARGS((Symbol));
static void clobber     ARGS((Node));
static void function    ARGS((Symbol, Symbol [], Symbol [], int));
static void global      ARGS((Symbol));
static void import      ARGS((Symbol));
static void local       ARGS((Symbol));
static void progbeg     ARGS((int, char **));
static void progend     ARGS((void));
static void segment     ARGS((int));
static void space       ARGS((int));
static void target      ARGS((Node));
static int  is_varargs_called ARGS((Node));
static int  ff1         ARGS((unsigned));
static int  hibits( Node p );
static int  bitrun( Node p );
static int  bins( Node p );

static Symbol ireg[32], freg2[32];
static int tmpregs[] = {0, 11, 12}; /* Regs for block copies */

static int gnum = 8;

static int cseg = 0;		/* Current segment */
static int pretty_print = 0;	/* Annotate assembler with comments? */

/*
generated at Mon Dec  4 16:04:48 1995
by $Id: ppc.c,v 1.1.1.1 2002/04/21 13:25:24 peter Exp $
*/
static void _kids ARGS((NODEPTR_TYPE, int, NODEPTR_TYPE[]));
static void _label ARGS((NODEPTR_TYPE));
static int _rule ARGS((void*, int));

#define _stmt_NT 1
#define _reg_NT 2
#define _con_NT 3
#define _con16_NT 4
#define _conhi_NT 5
#define _addr_NT 6
#define _idx_NT 7
#define _mcon16_NT 8
#define _lcon16_NT 9
#define _ucon16_NT 10
#define _bitrun_NT 11
#define _and_mask_NT 12
#define _con5_NT 13
#define _zero_NT 14
#define _ar_NT 15

static char *_ntname[] = {
	0,
	"stmt",
	"reg",
	"con",
	"con16",
	"conhi",
	"addr",
	"idx",
	"mcon16",
	"lcon16",
	"ucon16",
	"bitrun",
	"and_mask",
	"con5",
	"zero",
	"ar",
	0
};

struct _state {
	short cost[16];
	struct {
		unsigned int _stmt:7;
		unsigned int _reg:8;
		unsigned int _con:3;
		unsigned int _con16:3;
		unsigned int _conhi:1;
		unsigned int _addr:4;
		unsigned int _idx:2;
		unsigned int _mcon16:3;
		unsigned int _lcon16:3;
		unsigned int _ucon16:3;
		unsigned int _bitrun:3;
		unsigned int _and_mask:1;
		unsigned int _con5:3;
		unsigned int _zero:3;
		unsigned int _ar:2;
	} rule;
};

static short _nts_0[] = { 0 };
static short _nts_1[] = { _reg_NT, 0 };
static short _nts_2[] = { _con16_NT, 0 };
static short _nts_3[] = { _con_NT, 0 };
static short _nts_4[] = { _conhi_NT, 0 };
static short _nts_5[] = { _reg_NT, _con16_NT, 0 };
static short _nts_6[] = { _reg_NT, _reg_NT, 0 };
static short _nts_7[] = { _addr_NT, _reg_NT, 0 };
static short _nts_8[] = { _idx_NT, _reg_NT, 0 };
static short _nts_9[] = { _addr_NT, 0 };
static short _nts_10[] = { _idx_NT, 0 };
static short _nts_11[] = { _reg_NT, _con_NT, 0 };
static short _nts_12[] = { _reg_NT, _mcon16_NT, 0 };
static short _nts_13[] = { _reg_NT, _lcon16_NT, 0 };
static short _nts_14[] = { _reg_NT, _ucon16_NT, 0 };
static short _nts_15[] = { _reg_NT, _bitrun_NT, 0 };
static short _nts_16[] = { _and_mask_NT, 0 };
static short _nts_17[] = { _and_mask_NT, _and_mask_NT, 0 };
static short _nts_18[] = { _reg_NT, _con5_NT, 0 };
static short _nts_19[] = { _reg_NT, _lcon16_NT, _zero_NT, 0 };
static short _nts_20[] = { _reg_NT, _zero_NT, 0 };
static short _nts_21[] = { _reg_NT, _reg_NT, _zero_NT, 0 };
static short _nts_22[] = { _ar_NT, 0 };

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

static char _arity[] = {
	0,	/* 0 */
	0,	/* 1 */
	0,	/* 2 */
	0,	/* 3 */
	0,	/* 4 */
	0,	/* 5 */
	0,	/* 6 */
	0,	/* 7 */
	0,	/* 8 */
	0,	/* 9 */
	0,	/* 10 */
	0,	/* 11 */
	0,	/* 12 */
	0,	/* 13 */
	0,	/* 14 */
	0,	/* 15 */
	0,	/* 16 */
	0,	/* 17=CNSTF */
	0,	/* 18=CNSTD */
	0,	/* 19=CNSTC */
	0,	/* 20=CNSTS */
	0,	/* 21=CNSTI */
	0,	/* 22=CNSTU */
	0,	/* 23=CNSTP */
	0,	/* 24 */
	0,	/* 25 */
	0,	/* 26 */
	0,	/* 27 */
	0,	/* 28 */
	0,	/* 29 */
	0,	/* 30 */
	0,	/* 31 */
	0,	/* 32 */
	1,	/* 33=ARGF */
	1,	/* 34=ARGD */
	0,	/* 35 */
	0,	/* 36 */
	1,	/* 37=ARGI */
	0,	/* 38 */
	1,	/* 39=ARGP */
	0,	/* 40 */
	1,	/* 41=ARGB */
	0,	/* 42 */
	0,	/* 43 */
	0,	/* 44 */
	0,	/* 45 */
	0,	/* 46 */
	0,	/* 47 */
	0,	/* 48 */
	2,	/* 49=ASGNF */
	2,	/* 50=ASGND */
	2,	/* 51=ASGNC */
	2,	/* 52=ASGNS */
	2,	/* 53=ASGNI */
	0,	/* 54 */
	2,	/* 55=ASGNP */
	0,	/* 56 */
	2,	/* 57=ASGNB */
	0,	/* 58 */
	0,	/* 59 */
	0,	/* 60 */
	0,	/* 61 */
	0,	/* 62 */
	0,	/* 63 */
	0,	/* 64 */
	1,	/* 65=INDIRF */
	1,	/* 66=INDIRD */
	1,	/* 67=INDIRC */
	1,	/* 68=INDIRS */
	1,	/* 69=INDIRI */
	0,	/* 70 */
	1,	/* 71=INDIRP */
	0,	/* 72 */
	1,	/* 73=INDIRB */
	0,	/* 74 */
	0,	/* 75 */
	0,	/* 76 */
	0,	/* 77 */
	0,	/* 78 */
	0,	/* 79 */
	0,	/* 80 */
	0,	/* 81 */
	0,	/* 82 */
	0,	/* 83 */
	0,	/* 84 */
	1,	/* 85=CVCI */
	1,	/* 86=CVCU */
	0,	/* 87 */
	0,	/* 88 */
	0,	/* 89 */
	0,	/* 90 */
	0,	/* 91 */
	0,	/* 92 */
	0,	/* 93 */
	0,	/* 94 */
	0,	/* 95 */
	0,	/* 96 */
	1,	/* 97=CVDF */
	0,	/* 98 */
	0,	/* 99 */
	0,	/* 100 */
	1,	/* 101=CVDI */
	0,	/* 102 */
	0,	/* 103 */
	0,	/* 104 */
	0,	/* 105 */
	0,	/* 106 */
	0,	/* 107 */
	0,	/* 108 */
	0,	/* 109 */
	0,	/* 110 */
	0,	/* 111 */
	0,	/* 112 */
	0,	/* 113 */
	1,	/* 114=CVFD */
	0,	/* 115 */
	0,	/* 116 */
	0,	/* 117 */
	0,	/* 118 */
	0,	/* 119 */
	0,	/* 120 */
	0,	/* 121 */
	0,	/* 122 */
	0,	/* 123 */
	0,	/* 124 */
	0,	/* 125 */
	0,	/* 126 */
	0,	/* 127 */
	0,	/* 128 */
	0,	/* 129 */
	1,	/* 130=CVID */
	1,	/* 131=CVIC */
	1,	/* 132=CVIS */
	0,	/* 133 */
	1,	/* 134=CVIU */
	0,	/* 135 */
	0,	/* 136 */
	0,	/* 137 */
	0,	/* 138 */
	0,	/* 139 */
	0,	/* 140 */
	0,	/* 141 */
	0,	/* 142 */
	0,	/* 143 */
	0,	/* 144 */
	0,	/* 145 */
	0,	/* 146 */
	0,	/* 147 */
	0,	/* 148 */
	0,	/* 149 */
	1,	/* 150=CVPU */
	0,	/* 151 */
	0,	/* 152 */
	0,	/* 153 */
	0,	/* 154 */
	0,	/* 155 */
	0,	/* 156 */
	0,	/* 157 */
	0,	/* 158 */
	0,	/* 159 */
	0,	/* 160 */
	0,	/* 161 */
	0,	/* 162 */
	0,	/* 163 */
	0,	/* 164 */
	1,	/* 165=CVSI */
	1,	/* 166=CVSU */
	0,	/* 167 */
	0,	/* 168 */
	0,	/* 169 */
	0,	/* 170 */
	0,	/* 171 */
	0,	/* 172 */
	0,	/* 173 */
	0,	/* 174 */
	0,	/* 175 */
	0,	/* 176 */
	0,	/* 177 */
	0,	/* 178 */
	1,	/* 179=CVUC */
	1,	/* 180=CVUS */
	1,	/* 181=CVUI */
	0,	/* 182 */
	1,	/* 183=CVUP */
	0,	/* 184 */
	0,	/* 185 */
	0,	/* 186 */
	0,	/* 187 */
	0,	/* 188 */
	0,	/* 189 */
	0,	/* 190 */
	0,	/* 191 */
	0,	/* 192 */
	1,	/* 193=NEGF */
	1,	/* 194=NEGD */
	0,	/* 195 */
	0,	/* 196 */
	1,	/* 197=NEGI */
	0,	/* 198 */
	0,	/* 199 */
	0,	/* 200 */
	0,	/* 201 */
	0,	/* 202 */
	0,	/* 203 */
	0,	/* 204 */
	0,	/* 205 */
	0,	/* 206 */
	0,	/* 207 */
	0,	/* 208 */
	1,	/* 209=CALLF */
	1,	/* 210=CALLD */
	0,	/* 211 */
	0,	/* 212 */
	1,	/* 213=CALLI */
	0,	/* 214 */
	0,	/* 215 */
	1,	/* 216=CALLV */
	0,	/* 217=CALLB */
	0,	/* 218 */
	0,	/* 219 */
	0,	/* 220 */
	0,	/* 221 */
	0,	/* 222 */
	0,	/* 223 */
	0,	/* 224 */
	1,	/* 225=LOADF */
	1,	/* 226=LOADD */
	1,	/* 227=LOADC */
	1,	/* 228=LOADS */
	1,	/* 229=LOADI */
	1,	/* 230=LOADU */
	1,	/* 231=LOADP */
	0,	/* 232 */
	0,	/* 233=LOADB */
	0,	/* 234 */
	0,	/* 235 */
	0,	/* 236 */
	0,	/* 237 */
	0,	/* 238 */
	0,	/* 239 */
	0,	/* 240 */
	1,	/* 241=RETF */
	1,	/* 242=RETD */
	0,	/* 243 */
	0,	/* 244 */
	1,	/* 245=RETI */
	0,	/* 246 */
	0,	/* 247 */
	0,	/* 248 */
	0,	/* 249 */
	0,	/* 250 */
	0,	/* 251 */
	0,	/* 252 */
	0,	/* 253 */
	0,	/* 254 */
	0,	/* 255 */
	0,	/* 256 */
	0,	/* 257 */
	0,	/* 258 */
	0,	/* 259 */
	0,	/* 260 */
	0,	/* 261 */
	0,	/* 262 */
	0,	/* 263=ADDRGP */
	0,	/* 264 */
	0,	/* 265 */
	0,	/* 266 */
	0,	/* 267 */
	0,	/* 268 */
	0,	/* 269 */
	0,	/* 270 */
	0,	/* 271 */
	0,	/* 272 */
	0,	/* 273 */
	0,	/* 274 */
	0,	/* 275 */
	0,	/* 276 */
	0,	/* 277 */
	0,	/* 278 */
	0,	/* 279=ADDRFP */
	0,	/* 280 */
	0,	/* 281 */
	0,	/* 282 */
	0,	/* 283 */
	0,	/* 284 */
	0,	/* 285 */
	0,	/* 286 */
	0,	/* 287 */
	0,	/* 288 */
	0,	/* 289 */
	0,	/* 290 */
	0,	/* 291 */
	0,	/* 292 */
	0,	/* 293 */
	0,	/* 294 */
	0,	/* 295=ADDRLP */
	0,	/* 296 */
	0,	/* 297 */
	0,	/* 298 */
	0,	/* 299 */
	0,	/* 300 */
	0,	/* 301 */
	0,	/* 302 */
	0,	/* 303 */
	0,	/* 304 */
	2,	/* 305=ADDF */
	2,	/* 306=ADDD */
	0,	/* 307 */
	0,	/* 308 */
	2,	/* 309=ADDI */
	2,	/* 310=ADDU */
	2,	/* 311=ADDP */
	0,	/* 312 */
	0,	/* 313 */
	0,	/* 314 */
	0,	/* 315 */
	0,	/* 316 */
	0,	/* 317 */
	0,	/* 318 */
	0,	/* 319 */
	0,	/* 320 */
	2,	/* 321=SUBF */
	2,	/* 322=SUBD */
	0,	/* 323 */
	0,	/* 324 */
	2,	/* 325=SUBI */
	2,	/* 326=SUBU */
	2,	/* 327=SUBP */
	0,	/* 328 */
	0,	/* 329 */
	0,	/* 330 */
	0,	/* 331 */
	0,	/* 332 */
	0,	/* 333 */
	0,	/* 334 */
	0,	/* 335 */
	0,	/* 336 */
	0,	/* 337 */
	0,	/* 338 */
	0,	/* 339 */
	0,	/* 340 */
	2,	/* 341=LSHI */
	2,	/* 342=LSHU */
	0,	/* 343 */
	0,	/* 344 */
	0,	/* 345 */
	0,	/* 346 */
	0,	/* 347 */
	0,	/* 348 */
	0,	/* 349 */
	0,	/* 350 */
	0,	/* 351 */
	0,	/* 352 */
	0,	/* 353 */
	0,	/* 354 */
	0,	/* 355 */
	0,	/* 356 */
	2,	/* 357=MODI */
	2,	/* 358=MODU */
	0,	/* 359 */
	0,	/* 360 */
	0,	/* 361 */
	0,	/* 362 */
	0,	/* 363 */
	0,	/* 364 */
	0,	/* 365 */
	0,	/* 366 */
	0,	/* 367 */
	0,	/* 368 */
	0,	/* 369 */
	0,	/* 370 */
	0,	/* 371 */
	0,	/* 372 */
	2,	/* 373=RSHI */
	2,	/* 374=RSHU */
	0,	/* 375 */
	0,	/* 376 */
	0,	/* 377 */
	0,	/* 378 */
	0,	/* 379 */
	0,	/* 380 */
	0,	/* 381 */
	0,	/* 382 */
	0,	/* 383 */
	0,	/* 384 */
	0,	/* 385 */
	0,	/* 386 */
	0,	/* 387 */
	0,	/* 388 */
	0,	/* 389 */
	2,	/* 390=BANDU */
	0,	/* 391 */
	0,	/* 392 */
	0,	/* 393 */
	0,	/* 394 */
	0,	/* 395 */
	0,	/* 396 */
	0,	/* 397 */
	0,	/* 398 */
	0,	/* 399 */
	0,	/* 400 */
	0,	/* 401 */
	0,	/* 402 */
	0,	/* 403 */
	0,	/* 404 */
	0,	/* 405 */
	1,	/* 406=BCOMU */
	0,	/* 407 */
	0,	/* 408 */
	0,	/* 409 */
	0,	/* 410 */
	0,	/* 411 */
	0,	/* 412 */
	0,	/* 413 */
	0,	/* 414 */
	0,	/* 415 */
	0,	/* 416 */
	0,	/* 417 */
	0,	/* 418 */
	0,	/* 419 */
	0,	/* 420 */
	0,	/* 421 */
	2,	/* 422=BORU */
	0,	/* 423 */
	0,	/* 424 */
	0,	/* 425 */
	0,	/* 426 */
	0,	/* 427 */
	0,	/* 428 */
	0,	/* 429 */
	0,	/* 430 */
	0,	/* 431 */
	0,	/* 432 */
	0,	/* 433 */
	0,	/* 434 */
	0,	/* 435 */
	0,	/* 436 */
	0,	/* 437 */
	2,	/* 438=BXORU */
	0,	/* 439 */
	0,	/* 440 */
	0,	/* 441 */
	0,	/* 442 */
	0,	/* 443 */
	0,	/* 444 */
	0,	/* 445 */
	0,	/* 446 */
	0,	/* 447 */
	0,	/* 448 */
	2,	/* 449=DIVF */
	2,	/* 450=DIVD */
	0,	/* 451 */
	0,	/* 452 */
	2,	/* 453=DIVI */
	2,	/* 454=DIVU */
	0,	/* 455 */
	0,	/* 456 */
	0,	/* 457 */
	0,	/* 458 */
	0,	/* 459 */
	0,	/* 460 */
	0,	/* 461 */
	0,	/* 462 */
	0,	/* 463 */
	0,	/* 464 */
	2,	/* 465=MULF */
	2,	/* 466=MULD */
	0,	/* 467 */
	0,	/* 468 */
	2,	/* 469=MULI */
	2,	/* 470=MULU */
	0,	/* 471 */
	0,	/* 472 */
	0,	/* 473 */
	0,	/* 474 */
	0,	/* 475 */
	0,	/* 476 */
	0,	/* 477 */
	0,	/* 478 */
	0,	/* 479 */
	0,	/* 480 */
	2,	/* 481=EQF */
	2,	/* 482=EQD */
	0,	/* 483 */
	0,	/* 484 */
	2,	/* 485=EQI */
	0,	/* 486 */
	0,	/* 487 */
	0,	/* 488 */
	0,	/* 489 */
	0,	/* 490 */
	0,	/* 491 */
	0,	/* 492 */
	0,	/* 493 */
	0,	/* 494 */
	0,	/* 495 */
	0,	/* 496 */
	2,	/* 497=GEF */
	2,	/* 498=GED */
	0,	/* 499 */
	0,	/* 500 */
	2,	/* 501=GEI */
	2,	/* 502=GEU */
	0,	/* 503 */
	0,	/* 504 */
	0,	/* 505 */
	0,	/* 506 */
	0,	/* 507 */
	0,	/* 508 */
	0,	/* 509 */
	0,	/* 510 */
	0,	/* 511 */
	0,	/* 512 */
	2,	/* 513=GTF */
	2,	/* 514=GTD */
	0,	/* 515 */
	0,	/* 516 */
	2,	/* 517=GTI */
	2,	/* 518=GTU */
	0,	/* 519 */
	0,	/* 520 */
	0,	/* 521 */
	0,	/* 522 */
	0,	/* 523 */
	0,	/* 524 */
	0,	/* 525 */
	0,	/* 526 */
	0,	/* 527 */
	0,	/* 528 */
	2,	/* 529=LEF */
	2,	/* 530=LED */
	0,	/* 531 */
	0,	/* 532 */
	2,	/* 533=LEI */
	2,	/* 534=LEU */
	0,	/* 535 */
	0,	/* 536 */
	0,	/* 537 */
	0,	/* 538 */
	0,	/* 539 */
	0,	/* 540 */
	0,	/* 541 */
	0,	/* 542 */
	0,	/* 543 */
	0,	/* 544 */
	2,	/* 545=LTF */
	2,	/* 546=LTD */
	0,	/* 547 */
	0,	/* 548 */
	2,	/* 549=LTI */
	2,	/* 550=LTU */
	0,	/* 551 */
	0,	/* 552 */
	0,	/* 553 */
	0,	/* 554 */
	0,	/* 555 */
	0,	/* 556 */
	0,	/* 557 */
	0,	/* 558 */
	0,	/* 559 */
	0,	/* 560 */
	2,	/* 561=NEF */
	2,	/* 562=NED */
	0,	/* 563 */
	0,	/* 564 */
	2,	/* 565=NEI */
	0,	/* 566 */
	0,	/* 567 */
	0,	/* 568 */
	0,	/* 569 */
	0,	/* 570 */
	0,	/* 571 */
	0,	/* 572 */
	0,	/* 573 */
	0,	/* 574 */
	0,	/* 575 */
	0,	/* 576 */
	0,	/* 577 */
	0,	/* 578 */
	0,	/* 579 */
	0,	/* 580 */
	0,	/* 581 */
	0,	/* 582 */
	0,	/* 583 */
	1,	/* 584=JUMPV */
	0,	/* 585 */
	0,	/* 586 */
	0,	/* 587 */
	0,	/* 588 */
	0,	/* 589 */
	0,	/* 590 */
	0,	/* 591 */
	0,	/* 592 */
	0,	/* 593 */
	0,	/* 594 */
	0,	/* 595 */
	0,	/* 596 */
	0,	/* 597 */
	0,	/* 598 */
	0,	/* 599 */
	0,	/* 600=LABELV */
	0,	/* 601 */
	0,	/* 602 */
	0,	/* 603 */
	0,	/* 604 */
	0,	/* 605 */
	0,	/* 606 */
	0,	/* 607 */
	0,	/* 608 */
	0,	/* 609 */
	0,	/* 610 */
	0,	/* 611 */
	0,	/* 612 */
	0,	/* 613 */
	0,	/* 614 */
	0,	/* 615=VREGP */
};

static char *_opname[] = {
/* 0 */	0,
/* 1 */	0,
/* 2 */	0,
/* 3 */	0,
/* 4 */	0,
/* 5 */	0,
/* 6 */	0,
/* 7 */	0,
/* 8 */	0,
/* 9 */	0,
/* 10 */	0,
/* 11 */	0,
/* 12 */	0,
/* 13 */	0,
/* 14 */	0,
/* 15 */	0,
/* 16 */	0,
/* 17 */	"CNSTF",
/* 18 */	"CNSTD",
/* 19 */	"CNSTC",
/* 20 */	"CNSTS",
/* 21 */	"CNSTI",
/* 22 */	"CNSTU",
/* 23 */	"CNSTP",
/* 24 */	0,
/* 25 */	0,
/* 26 */	0,
/* 27 */	0,
/* 28 */	0,
/* 29 */	0,
/* 30 */	0,
/* 31 */	0,
/* 32 */	0,
/* 33 */	"ARGF",
/* 34 */	"ARGD",
/* 35 */	0,
/* 36 */	0,
/* 37 */	"ARGI",
/* 38 */	0,
/* 39 */	"ARGP",
/* 40 */	0,
/* 41 */	"ARGB",
/* 42 */	0,
/* 43 */	0,
/* 44 */	0,
/* 45 */	0,
/* 46 */	0,
/* 47 */	0,
/* 48 */	0,
/* 49 */	"ASGNF",
/* 50 */	"ASGND",
/* 51 */	"ASGNC",
/* 52 */	"ASGNS",
/* 53 */	"ASGNI",
/* 54 */	0,
/* 55 */	"ASGNP",
/* 56 */	0,
/* 57 */	"ASGNB",
/* 58 */	0,
/* 59 */	0,
/* 60 */	0,
/* 61 */	0,
/* 62 */	0,
/* 63 */	0,
/* 64 */	0,
/* 65 */	"INDIRF",
/* 66 */	"INDIRD",
/* 67 */	"INDIRC",
/* 68 */	"INDIRS",
/* 69 */	"INDIRI",
/* 70 */	0,
/* 71 */	"INDIRP",
/* 72 */	0,
/* 73 */	"INDIRB",
/* 74 */	0,
/* 75 */	0,
/* 76 */	0,
/* 77 */	0,
/* 78 */	0,
/* 79 */	0,
/* 80 */	0,
/* 81 */	0,
/* 82 */	0,
/* 83 */	0,
/* 84 */	0,
/* 85 */	"CVCI",
/* 86 */	"CVCU",
/* 87 */	0,
/* 88 */	0,
/* 89 */	0,
/* 90 */	0,
/* 91 */	0,
/* 92 */	0,
/* 93 */	0,
/* 94 */	0,
/* 95 */	0,
/* 96 */	0,
/* 97 */	"CVDF",
/* 98 */	0,
/* 99 */	0,
/* 100 */	0,
/* 101 */	"CVDI",
/* 102 */	0,
/* 103 */	0,
/* 104 */	0,
/* 105 */	0,
/* 106 */	0,
/* 107 */	0,
/* 108 */	0,
/* 109 */	0,
/* 110 */	0,
/* 111 */	0,
/* 112 */	0,
/* 113 */	0,
/* 114 */	"CVFD",
/* 115 */	0,
/* 116 */	0,
/* 117 */	0,
/* 118 */	0,
/* 119 */	0,
/* 120 */	0,
/* 121 */	0,
/* 122 */	0,
/* 123 */	0,
/* 124 */	0,
/* 125 */	0,
/* 126 */	0,
/* 127 */	0,
/* 128 */	0,
/* 129 */	0,
/* 130 */	"CVID",
/* 131 */	"CVIC",
/* 132 */	"CVIS",
/* 133 */	0,
/* 134 */	"CVIU",
/* 135 */	0,
/* 136 */	0,
/* 137 */	0,
/* 138 */	0,
/* 139 */	0,
/* 140 */	0,
/* 141 */	0,
/* 142 */	0,
/* 143 */	0,
/* 144 */	0,
/* 145 */	0,
/* 146 */	0,
/* 147 */	0,
/* 148 */	0,
/* 149 */	0,
/* 150 */	"CVPU",
/* 151 */	0,
/* 152 */	0,
/* 153 */	0,
/* 154 */	0,
/* 155 */	0,
/* 156 */	0,
/* 157 */	0,
/* 158 */	0,
/* 159 */	0,
/* 160 */	0,
/* 161 */	0,
/* 162 */	0,
/* 163 */	0,
/* 164 */	0,
/* 165 */	"CVSI",
/* 166 */	"CVSU",
/* 167 */	0,
/* 168 */	0,
/* 169 */	0,
/* 170 */	0,
/* 171 */	0,
/* 172 */	0,
/* 173 */	0,
/* 174 */	0,
/* 175 */	0,
/* 176 */	0,
/* 177 */	0,
/* 178 */	0,
/* 179 */	"CVUC",
/* 180 */	"CVUS",
/* 181 */	"CVUI",
/* 182 */	0,
/* 183 */	"CVUP",
/* 184 */	0,
/* 185 */	0,
/* 186 */	0,
/* 187 */	0,
/* 188 */	0,
/* 189 */	0,
/* 190 */	0,
/* 191 */	0,
/* 192 */	0,
/* 193 */	"NEGF",
/* 194 */	"NEGD",
/* 195 */	0,
/* 196 */	0,
/* 197 */	"NEGI",
/* 198 */	0,
/* 199 */	0,
/* 200 */	0,
/* 201 */	0,
/* 202 */	0,
/* 203 */	0,
/* 204 */	0,
/* 205 */	0,
/* 206 */	0,
/* 207 */	0,
/* 208 */	0,
/* 209 */	"CALLF",
/* 210 */	"CALLD",
/* 211 */	0,
/* 212 */	0,
/* 213 */	"CALLI",
/* 214 */	0,
/* 215 */	0,
/* 216 */	"CALLV",
/* 217 */	"CALLB",
/* 218 */	0,
/* 219 */	0,
/* 220 */	0,
/* 221 */	0,
/* 222 */	0,
/* 223 */	0,
/* 224 */	0,
/* 225 */	"LOADF",
/* 226 */	"LOADD",
/* 227 */	"LOADC",
/* 228 */	"LOADS",
/* 229 */	"LOADI",
/* 230 */	"LOADU",
/* 231 */	"LOADP",
/* 232 */	0,
/* 233 */	"LOADB",
/* 234 */	0,
/* 235 */	0,
/* 236 */	0,
/* 237 */	0,
/* 238 */	0,
/* 239 */	0,
/* 240 */	0,
/* 241 */	"RETF",
/* 242 */	"RETD",
/* 243 */	0,
/* 244 */	0,
/* 245 */	"RETI",
/* 246 */	0,
/* 247 */	0,
/* 248 */	0,
/* 249 */	0,
/* 250 */	0,
/* 251 */	0,
/* 252 */	0,
/* 253 */	0,
/* 254 */	0,
/* 255 */	0,
/* 256 */	0,
/* 257 */	0,
/* 258 */	0,
/* 259 */	0,
/* 260 */	0,
/* 261 */	0,
/* 262 */	0,
/* 263 */	"ADDRGP",
/* 264 */	0,
/* 265 */	0,
/* 266 */	0,
/* 267 */	0,
/* 268 */	0,
/* 269 */	0,
/* 270 */	0,
/* 271 */	0,
/* 272 */	0,
/* 273 */	0,
/* 274 */	0,
/* 275 */	0,
/* 276 */	0,
/* 277 */	0,
/* 278 */	0,
/* 279 */	"ADDRFP",
/* 280 */	0,
/* 281 */	0,
/* 282 */	0,
/* 283 */	0,
/* 284 */	0,
/* 285 */	0,
/* 286 */	0,
/* 287 */	0,
/* 288 */	0,
/* 289 */	0,
/* 290 */	0,
/* 291 */	0,
/* 292 */	0,
/* 293 */	0,
/* 294 */	0,
/* 295 */	"ADDRLP",
/* 296 */	0,
/* 297 */	0,
/* 298 */	0,
/* 299 */	0,
/* 300 */	0,
/* 301 */	0,
/* 302 */	0,
/* 303 */	0,
/* 304 */	0,
/* 305 */	"ADDF",
/* 306 */	"ADDD",
/* 307 */	0,
/* 308 */	0,
/* 309 */	"ADDI",
/* 310 */	"ADDU",
/* 311 */	"ADDP",
/* 312 */	0,
/* 313 */	0,
/* 314 */	0,
/* 315 */	0,
/* 316 */	0,
/* 317 */	0,
/* 318 */	0,
/* 319 */	0,
/* 320 */	0,
/* 321 */	"SUBF",
/* 322 */	"SUBD",
/* 323 */	0,
/* 324 */	0,
/* 325 */	"SUBI",
/* 326 */	"SUBU",
/* 327 */	"SUBP",
/* 328 */	0,
/* 329 */	0,
/* 330 */	0,
/* 331 */	0,
/* 332 */	0,
/* 333 */	0,
/* 334 */	0,
/* 335 */	0,
/* 336 */	0,
/* 337 */	0,
/* 338 */	0,
/* 339 */	0,
/* 340 */	0,
/* 341 */	"LSHI",
/* 342 */	"LSHU",
/* 343 */	0,
/* 344 */	0,
/* 345 */	0,
/* 346 */	0,
/* 347 */	0,
/* 348 */	0,
/* 349 */	0,
/* 350 */	0,
/* 351 */	0,
/* 352 */	0,
/* 353 */	0,
/* 354 */	0,
/* 355 */	0,
/* 356 */	0,
/* 357 */	"MODI",
/* 358 */	"MODU",
/* 359 */	0,
/* 360 */	0,
/* 361 */	0,
/* 362 */	0,
/* 363 */	0,
/* 364 */	0,
/* 365 */	0,
/* 366 */	0,
/* 367 */	0,
/* 368 */	0,
/* 369 */	0,
/* 370 */	0,
/* 371 */	0,
/* 372 */	0,
/* 373 */	"RSHI",
/* 374 */	"RSHU",
/* 375 */	0,
/* 376 */	0,
/* 377 */	0,
/* 378 */	0,
/* 379 */	0,
/* 380 */	0,
/* 381 */	0,
/* 382 */	0,
/* 383 */	0,
/* 384 */	0,
/* 385 */	0,
/* 386 */	0,
/* 387 */	0,
/* 388 */	0,
/* 389 */	0,
/* 390 */	"BANDU",
/* 391 */	0,
/* 392 */	0,
/* 393 */	0,
/* 394 */	0,
/* 395 */	0,
/* 396 */	0,
/* 397 */	0,
/* 398 */	0,
/* 399 */	0,
/* 400 */	0,
/* 401 */	0,
/* 402 */	0,
/* 403 */	0,
/* 404 */	0,
/* 405 */	0,
/* 406 */	"BCOMU",
/* 407 */	0,
/* 408 */	0,
/* 409 */	0,
/* 410 */	0,
/* 411 */	0,
/* 412 */	0,
/* 413 */	0,
/* 414 */	0,
/* 415 */	0,
/* 416 */	0,
/* 417 */	0,
/* 418 */	0,
/* 419 */	0,
/* 420 */	0,
/* 421 */	0,
/* 422 */	"BORU",
/* 423 */	0,
/* 424 */	0,
/* 425 */	0,
/* 426 */	0,
/* 427 */	0,
/* 428 */	0,
/* 429 */	0,
/* 430 */	0,
/* 431 */	0,
/* 432 */	0,
/* 433 */	0,
/* 434 */	0,
/* 435 */	0,
/* 436 */	0,
/* 437 */	0,
/* 438 */	"BXORU",
/* 439 */	0,
/* 440 */	0,
/* 441 */	0,
/* 442 */	0,
/* 443 */	0,
/* 444 */	0,
/* 445 */	0,
/* 446 */	0,
/* 447 */	0,
/* 448 */	0,
/* 449 */	"DIVF",
/* 450 */	"DIVD",
/* 451 */	0,
/* 452 */	0,
/* 453 */	"DIVI",
/* 454 */	"DIVU",
/* 455 */	0,
/* 456 */	0,
/* 457 */	0,
/* 458 */	0,
/* 459 */	0,
/* 460 */	0,
/* 461 */	0,
/* 462 */	0,
/* 463 */	0,
/* 464 */	0,
/* 465 */	"MULF",
/* 466 */	"MULD",
/* 467 */	0,
/* 468 */	0,
/* 469 */	"MULI",
/* 470 */	"MULU",
/* 471 */	0,
/* 472 */	0,
/* 473 */	0,
/* 474 */	0,
/* 475 */	0,
/* 476 */	0,
/* 477 */	0,
/* 478 */	0,
/* 479 */	0,
/* 480 */	0,
/* 481 */	"EQF",
/* 482 */	"EQD",
/* 483 */	0,
/* 484 */	0,
/* 485 */	"EQI",
/* 486 */	0,
/* 487 */	0,
/* 488 */	0,
/* 489 */	0,
/* 490 */	0,
/* 491 */	0,
/* 492 */	0,
/* 493 */	0,
/* 494 */	0,
/* 495 */	0,
/* 496 */	0,
/* 497 */	"GEF",
/* 498 */	"GED",
/* 499 */	0,
/* 500 */	0,
/* 501 */	"GEI",
/* 502 */	"GEU",
/* 503 */	0,
/* 504 */	0,
/* 505 */	0,
/* 506 */	0,
/* 507 */	0,
/* 508 */	0,
/* 509 */	0,
/* 510 */	0,
/* 511 */	0,
/* 512 */	0,
/* 513 */	"GTF",
/* 514 */	"GTD",
/* 515 */	0,
/* 516 */	0,
/* 517 */	"GTI",
/* 518 */	"GTU",
/* 519 */	0,
/* 520 */	0,
/* 521 */	0,
/* 522 */	0,
/* 523 */	0,
/* 524 */	0,
/* 525 */	0,
/* 526 */	0,
/* 527 */	0,
/* 528 */	0,
/* 529 */	"LEF",
/* 530 */	"LED",
/* 531 */	0,
/* 532 */	0,
/* 533 */	"LEI",
/* 534 */	"LEU",
/* 535 */	0,
/* 536 */	0,
/* 537 */	0,
/* 538 */	0,
/* 539 */	0,
/* 540 */	0,
/* 541 */	0,
/* 542 */	0,
/* 543 */	0,
/* 544 */	0,
/* 545 */	"LTF",
/* 546 */	"LTD",
/* 547 */	0,
/* 548 */	0,
/* 549 */	"LTI",
/* 550 */	"LTU",
/* 551 */	0,
/* 552 */	0,
/* 553 */	0,
/* 554 */	0,
/* 555 */	0,
/* 556 */	0,
/* 557 */	0,
/* 558 */	0,
/* 559 */	0,
/* 560 */	0,
/* 561 */	"NEF",
/* 562 */	"NED",
/* 563 */	0,
/* 564 */	0,
/* 565 */	"NEI",
/* 566 */	0,
/* 567 */	0,
/* 568 */	0,
/* 569 */	0,
/* 570 */	0,
/* 571 */	0,
/* 572 */	0,
/* 573 */	0,
/* 574 */	0,
/* 575 */	0,
/* 576 */	0,
/* 577 */	0,
/* 578 */	0,
/* 579 */	0,
/* 580 */	0,
/* 581 */	0,
/* 582 */	0,
/* 583 */	0,
/* 584 */	"JUMPV",
/* 585 */	0,
/* 586 */	0,
/* 587 */	0,
/* 588 */	0,
/* 589 */	0,
/* 590 */	0,
/* 591 */	0,
/* 592 */	0,
/* 593 */	0,
/* 594 */	0,
/* 595 */	0,
/* 596 */	0,
/* 597 */	0,
/* 598 */	0,
/* 599 */	0,
/* 600 */	"LABELV",
/* 601 */	0,
/* 602 */	0,
/* 603 */	0,
/* 604 */	0,
/* 605 */	0,
/* 606 */	0,
/* 607 */	0,
/* 608 */	0,
/* 609 */	0,
/* 610 */	0,
/* 611 */	0,
/* 612 */	0,
/* 613 */	0,
/* 614 */	0,
/* 615 */	"VREGP",
};

static char *_templates[] = {
/* 0 */	0,
/* 1 */	"# read register\n",	/* reg: INDIRC(VREGP) */
/* 2 */	"# read register\n",	/* reg: INDIRD(VREGP) */
/* 3 */	"# read register\n",	/* reg: INDIRF(VREGP) */
/* 4 */	"# read register\n",	/* reg: INDIRI(VREGP) */
/* 5 */	"# read register\n",	/* reg: INDIRP(VREGP) */
/* 6 */	"# read register\n",	/* reg: INDIRS(VREGP) */
/* 7 */	"# write register\n",	/* stmt: ASGNC(VREGP,reg) */
/* 8 */	"# write register\n",	/* stmt: ASGND(VREGP,reg) */
/* 9 */	"# write register\n",	/* stmt: ASGNF(VREGP,reg) */
/* 10 */	"# write register\n",	/* stmt: ASGNI(VREGP,reg) */
/* 11 */	"# write register\n",	/* stmt: ASGNP(VREGP,reg) */
/* 12 */	"# write register\n",	/* stmt: ASGNS(VREGP,reg) */
/* 13 */	"%a",	/* con: CNSTC */
/* 14 */	"%a",	/* con: CNSTI */
/* 15 */	"%a",	/* con: CNSTP */
/* 16 */	"%a",	/* con: CNSTS */
/* 17 */	"%a",	/* con: CNSTU */
/* 18 */	"",	/* stmt: reg */
/* 19 */	"%0",	/* reg: CVIU(reg) */
/* 20 */	"%0",	/* reg: CVPU(reg) */
/* 21 */	"%0",	/* reg: CVUI(reg) */
/* 22 */	"%0",	/* reg: CVUP(reg) */
/* 23 */	"# toc access\n",	/* reg: ADDRGP */
/* 24 */	"%a",	/* con16: CNSTC */
/* 25 */	"%a",	/* con16: CNSTS */
/* 26 */	"%a",	/* con16: CNSTI */
/* 27 */	"%a",	/* con16: CNSTU */
/* 28 */	"%a",	/* con16: CNSTP */
/* 29 */	"\taddi \tr%c,r0,%0\n",	/* reg: con16 */
/* 30 */	"\taddis \tr%c,r0,(%a-((%a<16)>16))>16\n\taddi \tr%c,r%c,(%a<16)>16\t# Big constant %a\n",	/* reg: con */
/* 31 */	"\taddis \tr%c,r0,(%a-((%a<16)>16))>16\t# Big offset %a \n",	/* conhi: con */
/* 32 */	"((%a<16)>16)(r%0)",	/* addr: conhi */
/* 33 */	"\taddis \tr%c,FP,(%a-((%a<16)>16))>16\n\taddi \tr%c,r%c,(%a<16)>16\t# Big frame offset %a\n",	/* reg: ADDRFP */
/* 34 */	"%a(FP)",	/* addr: ADDRFP */
/* 35 */	"\taddi \tr%c,FP,%a\n",	/* reg: ADDRFP */
/* 36 */	"\taddis \tr%c,FP,(%a-((%a<16)>16))>16\n\taddi \tr%c,r%c,(%a<16)>16\t# Big local offset %a\n",	/* reg: ADDRLP */
/* 37 */	"%a(FP)",	/* addr: ADDRLP */
/* 38 */	"\taddi \tr%c,FP,%a\n",	/* reg: ADDRLP */
/* 39 */	"%0(r0)",	/* addr: con16 */
/* 40 */	"%1(r%0)",	/* addr: ADDI(reg,con16) */
/* 41 */	"%1(r%0)",	/* addr: ADDP(reg,con16) */
/* 42 */	"%1(r%0)",	/* addr: ADDU(reg,con16) */
/* 43 */	"0(r%0)",	/* addr: reg */
/* 44 */	"r%0,r%1",	/* idx: ADDI(reg,reg) */
/* 45 */	"r%0,r%1",	/* idx: ADDU(reg,reg) */
/* 46 */	"r%0,r%1",	/* idx: ADDP(reg,reg) */
/* 47 */	"\tstb \tr%1,%0\n",	/* stmt: ASGNC(addr,reg) */
/* 48 */	"\tsth \tr%1,%0\n",	/* stmt: ASGNS(addr,reg) */
/* 49 */	"\tstw \tr%1,%0\n",	/* stmt: ASGNI(addr,reg) */
/* 50 */	"\tstw \tr%1,%0\n",	/* stmt: ASGNP(addr,reg) */
/* 51 */	"\tstfd \tf%1,%0\n",	/* stmt: ASGND(addr,reg) */
/* 52 */	"\tstfs \tf%1,%0\n",	/* stmt: ASGNF(addr,reg) */
/* 53 */	"\tstbx \tr%1,%0\n",	/* stmt: ASGNC(idx,reg) */
/* 54 */	"\tsthx \tr%1,%0\n",	/* stmt: ASGNS(idx,reg) */
/* 55 */	"\tstwx \tr%1,%0\n",	/* stmt: ASGNI(idx,reg) */
/* 56 */	"\tstwx \tr%1,%0\n",	/* stmt: ASGNP(idx,reg) */
/* 57 */	"\tstfdx \tf%1,%0\n",	/* stmt: ASGND(idx,reg) */
/* 58 */	"\tstfsx \tf%1,%0\n",	/* stmt: ASGNF(idx,reg) */
/* 59 */	"\tlbz \tr%c,%0\n",	/* reg: INDIRC(addr) */
/* 60 */	"\tlha \tr%c,%0\n",	/* reg: INDIRS(addr) */
/* 61 */	"\tlwz \tr%c,%0\n",	/* reg: INDIRI(addr) */
/* 62 */	"\tlwz \tr%c,%0\n",	/* reg: INDIRP(addr) */
/* 63 */	"\tlfd \tf%c,%0\n",	/* reg: INDIRD(addr) */
/* 64 */	"\tlfs \tf%c,%0\n",	/* reg: INDIRF(addr) */
/* 65 */	"\tlbzx \tr%c,%0\n",	/* reg: INDIRC(idx) */
/* 66 */	"\tlhax \tr%c,%0\n",	/* reg: INDIRS(idx) */
/* 67 */	"\tlwzx \tr%c,%0\n",	/* reg: INDIRI(idx) */
/* 68 */	"\tlwzx \tr%c,%0\n",	/* reg: INDIRP(idx) */
/* 69 */	"\tlfdx \tf%c,%0\n",	/* reg: INDIRD(idx) */
/* 70 */	"\tlfsx \tf%c,%0\n",	/* reg: INDIRF(idx) */
/* 71 */	"\tlha \tr%c,%0\n",	/* reg: CVSI(INDIRS(addr)) */
/* 72 */	"\tlbz \tr%c,%0\n",	/* reg: CVCU(INDIRC(addr)) */
/* 73 */	"\tlhz \tr%c,%0\n",	/* reg: CVSU(INDIRS(addr)) */
/* 74 */	"\tlhax \tr%c,%0\n",	/* reg: CVSI(INDIRS(idx)) */
/* 75 */	"\tlbzx \tr%c,%0\n",	/* reg: CVCU(INDIRC(idx)) */
/* 76 */	"\tlhzx \tr%c,%0\n",	/* reg: CVSU(INDIRS(idx)) */
/* 77 */	"\tmr \tr%c,r%0\n",	/* reg: CVIC(reg) */
/* 78 */	"\tmr \tr%c,r%0\n",	/* reg: CVIS(reg) */
/* 79 */	"\tmr \tr%c,r%0\n",	/* reg: CVIU(reg) */
/* 80 */	"\tmr \tr%c,r%0\n",	/* reg: CVPU(reg) */
/* 81 */	"\tmr \tr%c,r%0\n",	/* reg: CVUC(reg) */
/* 82 */	"\tmr \tr%c,r%0\n",	/* reg: CVUI(reg) */
/* 83 */	"\tmr \tr%c,r%0\n",	/* reg: CVUP(reg) */
/* 84 */	"\tmr \tr%c,r%0\n",	/* reg: CVUS(reg) */
/* 85 */	"%0",	/* reg: CVIC(reg) */
/* 86 */	"%0",	/* reg: CVIS(reg) */
/* 87 */	"%0",	/* reg: CVUC(reg) */
/* 88 */	"%0",	/* reg: CVUS(reg) */
/* 89 */	"\tmr \tr%c,r%0\n",	/* reg: LOADC(reg) */
/* 90 */	"\tmr \tr%c,r%0\n",	/* reg: LOADI(reg) */
/* 91 */	"\tmr \tr%c,r%0\n",	/* reg: LOADP(reg) */
/* 92 */	"\tmr \tr%c,r%0\n",	/* reg: LOADS(reg) */
/* 93 */	"\tmr \tr%c,r%0\n",	/* reg: LOADU(reg) */
/* 94 */	"\tadd  \tr%c,r%0,r%1\n",	/* reg: ADDI(reg,reg) */
/* 95 */	"\taddi \tr%c,r%0,%1\n",	/* reg: ADDI(reg,con16) */
/* 96 */	"\taddis \tr%c,r%0,(%1-((%1<16)>16))>16\n\taddi \tr%c,r%c,(%1<16)>16\n",	/* reg: ADDI(reg,con) */
/* 97 */	"\taddi \tr%c,r%0,%1\n",	/* reg: ADDP(reg,con16) */
/* 98 */	"\tadd  \tr%c,r%0,r%1\n",	/* reg: ADDP(reg,reg) */
/* 99 */	"\tadd  \tr%c,r%0,r%1\n",	/* reg: ADDU(reg,reg) */
/* 100 */	"\taddi \tr%c,r%0,%1\n",	/* reg: ADDU(reg,con16) */
/* 101 */	"%a",	/* mcon16: CNSTC */
/* 102 */	"%a",	/* mcon16: CNSTS */
/* 103 */	"%a",	/* mcon16: CNSTI */
/* 104 */	"%a",	/* mcon16: CNSTU */
/* 105 */	"%a",	/* mcon16: CNSTP */
/* 106 */	"\tsubf \tr%c,r%1,r%0\n",	/* reg: SUBI(reg,reg) */
/* 107 */	"\taddi \tr%c,r%0,-%1\n",	/* reg: SUBI(reg,mcon16) */
/* 108 */	"\tsubf \tr%c,r%1,r%0\n",	/* reg: SUBP(reg,reg) */
/* 109 */	"\taddi \tr%c,r%0,-%1\n",	/* reg: SUBP(reg,mcon16) */
/* 110 */	"\tsubf \tr%c,r%1,r%0\n",	/* reg: SUBU(reg,reg) */
/* 111 */	"\taddi \tr%c,r%0,-%1\n",	/* reg: SUBU(reg,mcon16) */
/* 112 */	"%a",	/* lcon16: CNSTC */
/* 113 */	"%a",	/* lcon16: CNSTS */
/* 114 */	"%a",	/* lcon16: CNSTI */
/* 115 */	"%a",	/* lcon16: CNSTU */
/* 116 */	"%a",	/* lcon16: CNSTP */
/* 117 */	"%a",	/* ucon16: CNSTC */
/* 118 */	"%a",	/* ucon16: CNSTS */
/* 119 */	"%a",	/* ucon16: CNSTI */
/* 120 */	"%a",	/* ucon16: CNSTU */
/* 121 */	"%a",	/* ucon16: CNSTP */
/* 122 */	"\tnand \tr%c,r%0,r%0\n",	/* reg: BCOMU(reg) */
/* 123 */	"\tand    \tr%c,r%0,r%1\n",	/* reg: BANDU(reg,reg) */
/* 124 */	"\tandi.  \tr%c,r%0,%1\n",	/* reg: BANDU(reg,lcon16) */
/* 125 */	"\tandis. \tr%c,r%0,(%1>16)&0xffff\n",	/* reg: BANDU(reg,ucon16) */
/* 126 */	"\tandc \tr%c,r%0,r%1\n",	/* reg: BANDU(reg,BCOMU(reg)) */
/* 127 */	"\tandc \tr%c,r%1,r%0\n",	/* reg: BANDU(BCOMU(reg),reg) */
/* 128 */	"\tnand \tr%c,r%0,r%1\n",	/* reg: BCOMU(BANDU(reg,reg)) */
/* 129 */	"\torc \tr%c,r%1,r%0\n",	/* reg: BCOMU(BANDU(reg,BCOMU(reg))) */
/* 130 */	"\torc \tr%c,r%0,r%1\n",	/* reg: BCOMU(BANDU(BCOMU(reg),reg)) */
/* 131 */	"\tor   \tr%c,r%0,r%1\n",	/* reg: BORU(reg,reg) */
/* 132 */	"\tori  \tr%c,r%0,%1\n",	/* reg: BORU(reg,lcon16) */
/* 133 */	"\toris \tr%c,r%0,(%1>16)&0xffff\n",	/* reg: BORU(reg,ucon16) */
/* 134 */	"\torc \tr%c,r%0,r%1\n",	/* reg: BORU(reg,BCOMU(reg)) */
/* 135 */	"\torc \tr%c,r%1,r%0\n",	/* reg: BORU(BCOMU(reg),reg) */
/* 136 */	"\tnor \tr%c,r%0,r%1\n",	/* reg: BCOMU(BORU(reg,reg)) */
/* 137 */	"\tandc \tr%c,r%1,r%0\n",	/* reg: BCOMU(BORU(reg,BCOMU(reg))) */
/* 138 */	"\tandc \tr%c,r%0,r%1\n",	/* reg: BCOMU(BORU(BCOMU(reg),reg)) */
/* 139 */	"\toris \tr%c,r%0,(%1>16)&0xffff\n\tori \tr%c,r%c,%1&0xffff\n",	/* reg: BORU(reg,con) */
/* 140 */	"\txor  \tr%c,r%0,r%1\n",	/* reg: BXORU(reg,reg) */
/* 141 */	"\txori \tr%c,r%0,%1\n",	/* reg: BXORU(reg,lcon16) */
/* 142 */	"\txori \tr%c,r%0,(%1>16)&0xffff\n",	/* reg: BXORU(reg,ucon16) */
/* 143 */	"\txoris \tr%c,r%0,(%1>16)&0xffff\n\txori \tr%c,r%c,%1&0xffff\n",	/* reg: BXORU(reg,con) */
/* 144 */	"%a",	/* bitrun: CNSTC */
/* 145 */	"%a",	/* bitrun: CNSTS */
/* 146 */	"%a",	/* bitrun: CNSTI */
/* 147 */	"%a",	/* bitrun: CNSTU */
/* 148 */	"%a",	/* bitrun: CNSTP */
/* 149 */	"%0",	/* and_mask: BANDU(reg,bitrun) */
/* 150 */	"\trlwinm \tr%c,r%0,0,%B\t\t# And r%0 with mask (%B) into r%c\n",	/* reg: and_mask */
/* 151 */	"?\tmr \tr%c,r%0\n \trlwimi \tr%c,r%1,0,%B\t\t# (r%1 & %B) | (r%0 & ~%B)\n",	/* reg: BORU(and_mask,and_mask) */
/* 152 */	"\tdivw  \tr%c,r%0,r%1\n",	/* reg: DIVI(reg,reg) */
/* 153 */	"\tdivwu \tr%c,r%0,r%1\n",	/* reg: DIVU(reg,reg) */
/* 154 */	"\tdivw \tr0,r%0,r%1\t\t# Divide and truncate\n\tmullw \tr0,r0,r%1\t\t# Multiply back, rounded\n\tsubf \tr%c,r0,r%0\t\t# Compute signed remainder\n",	/* reg: MODI(reg,reg) */
/* 155 */	"\tdivwu \tr0,r%0,r%1\t\t# Divide and truncate\n\tmullw \tr0,r0,r%1\t\t# Multiply back, rounded\n\tsubf \tr%c,r0,r%0\t\t# Compute unsigned remainder\n",	/* reg: MODU(reg,reg) */
/* 156 */	"\tmullw \tr%c,r%0,r%1\n",	/* reg: MULI(reg,reg) */
/* 157 */	"\tmullw \tr%c,r%0,r%1\n",	/* reg: MULU(reg,reg) */
/* 158 */	"%a",	/* con5: CNSTC */
/* 159 */	"%a",	/* con5: CNSTS */
/* 160 */	"%a",	/* con5: CNSTI */
/* 161 */	"%a",	/* con5: CNSTU */
/* 162 */	"\trlwinm \tr%c,r%0,%1,0,31-%1\t# left shift r%0 by %1 into r%c\n",	/* reg: LSHI(reg,con5) */
/* 163 */	"\trlwinm \tr%c,r%0,%1,0,31-%1\t# left shift r%0 by %1 into r%c\n",	/* reg: LSHU(reg,con5) */
/* 164 */	"\tsrawi \tr%c,r%0,%1\t\t# Shift right arithmetic by %1\n",	/* reg: RSHI(reg,con5) */
/* 165 */	"\trlwinm \tr%c,r%0,32-%1,%1,31\t# Shift right logical r%0 by %1 into r%c\n",	/* reg: RSHU(reg,con5) */
/* 166 */	"\tslw \tr%c,r%0,r%1\t# Shift left logical by r%1\n",	/* reg: LSHI(reg,reg) */
/* 167 */	"\tslw \tr%c,r%0,r%1\t# Shift left logical by r%1\n",	/* reg: LSHU(reg,reg) */
/* 168 */	"\tsraw \tr%c,r%0,r%1\t# Shift right arithmetic by r%1\n",	/* reg: RSHI(reg,reg) */
/* 169 */	"\tsrw \tr%c,r%0,r%1\t# Shift right logical by r%1\n",	/* reg: RSHU(reg,reg) */
/* 170 */	"\tneg \tr%c,r%0\n",	/* reg: NEGI(reg) */
/* 171 */	"\tmr\tr%c,r%0\n",	/* reg: LOADC(reg) */
/* 172 */	"\tmr\tr%c,r%0\n",	/* reg: LOADS(reg) */
/* 173 */	"\tmr\tr%c,r%0\n",	/* reg: LOADI(reg) */
/* 174 */	"\tmr\tr%c,r%0\n",	/* reg: LOADP(reg) */
/* 175 */	"\tmr\tr%c,r%0\n",	/* reg: LOADU(reg) */
/* 176 */	"\tfmr\tf%c,f%0\n",	/* reg: LOADD(reg) */
/* 177 */	"\tfmr\tf%c,f%0\n",	/* reg: LOADF(reg) */
/* 178 */	"\tfadd  \tf%c,f%0,f%1\n",	/* reg: ADDD(reg,reg) */
/* 179 */	"\tfadds \tf%c,f%0,f%1\n",	/* reg: ADDF(reg,reg) */
/* 180 */	"\tfdiv  \tf%c,f%0,f%1\n",	/* reg: DIVD(reg,reg) */
/* 181 */	"\tfdivs \tf%c,f%0,f%1\n",	/* reg: DIVF(reg,reg) */
/* 182 */	"\tfmul  \tf%c,f%0,f%1\n",	/* reg: MULD(reg,reg) */
/* 183 */	"\tfmuls \tf%c,f%0,f%1\n",	/* reg: MULF(reg,reg) */
/* 184 */	"\tfsub  \tf%c,f%0,f%1\n",	/* reg: SUBD(reg,reg) */
/* 185 */	"\tfsubs \tf%c,f%0,f%1\n",	/* reg: SUBF(reg,reg) */
/* 186 */	"\tfneg  \tf%c,f%0\n",	/* reg: NEGD(reg) */
/* 187 */	"\tfneg  \tf%c,f%0\n",	/* reg: NEGF(reg) */
/* 188 */	"\textsb \tr%c,r%0\n",	/* reg: CVCI(reg) */
/* 189 */	"\textsb \tr%c,r%0\n",	/* reg: CVCI(reg) */
/* 190 */	"\textsh \tr%c,r%0\n",	/* reg: CVSI(reg) */
/* 191 */	"\tandi. \tr%c,r%0,0xff\n",	/* reg: CVCU(reg) */
/* 192 */	"\tandi. \tr%c,r%0,0xffff\n",	/* reg: CVSU(reg) */
/* 193 */	"\tfmr \tf%c,f%0\n",	/* reg: CVDF(reg) */
/* 194 */	"\tfmr \tf%c,f%0\n",	/* reg: CVFD(reg) */
/* 195 */	"# Int to double\n",	/* reg: CVID(reg) */
/* 196 */	"# Double to int\n",	/* reg: CVDI(reg) */
/* 197 */	"\tcmp   \tCR0,0,r%0,r%1\n\tbeq \t%a\n",	/* stmt: EQI(reg,reg) */
/* 198 */	"\tcmpi  \tCR0,0,r%0,%1\n \tbeq \t%a\n",	/* stmt: EQI(reg,con16) */
/* 199 */	"\tcmpli \tCR0,0,r%0,%1\n \tbeq \t%a\n",	/* stmt: EQI(reg,lcon16) */
/* 200 */	"\tcmp   \tCR0,0,r%0,r%1\n\tbge \t%a\n",	/* stmt: GEI(reg,reg) */
/* 201 */	"\tcmpi  \tCR0,0,r%0,%1\n \tbge \t%a\n",	/* stmt: GEI(reg,con16) */
/* 202 */	"\tcmpl  \tCR0,0,r%0,r%1\n\tbge \t%a\n",	/* stmt: GEU(reg,reg) */
/* 203 */	"\tcmpli \tCR0,0,r%0,%1\n \tbge \t%a\n",	/* stmt: GEU(reg,lcon16) */
/* 204 */	"\tcmp   \tCR0,0,r%0,r%1\n\tbgt \t%a\n",	/* stmt: GTI(reg,reg) */
/* 205 */	"\tcmpi  \tCR0,0,r%0,%1\n \tbgt \t%a\n",	/* stmt: GTI(reg,con16) */
/* 206 */	"\tcmpl  \tCR0,0,r%0,r%1\n\tbgt \t%a\n",	/* stmt: GTU(reg,reg) */
/* 207 */	"\tcmpli \tCR0,0,r%0,%1\n \tbgt \t%a\n",	/* stmt: GTU(reg,lcon16) */
/* 208 */	"\tcmp   \tCR0,0,r%0,r%1\n\tble \t%a\n",	/* stmt: LEI(reg,reg) */
/* 209 */	"\tcmpi  \tCR0,0,r%0,%1\n \tble \t%a\n",	/* stmt: LEI(reg,con16) */
/* 210 */	"\tcmpl  \tCR0,0,r%0,r%1\n\tble \t%a\n",	/* stmt: LEU(reg,reg) */
/* 211 */	"\tcmpli \tCR0,0,r%0,%1\n \tble \t%a\n",	/* stmt: LEU(reg,lcon16) */
/* 212 */	"\tcmp   \tCR0,0,r%0,r%1\n\tblt \t%a\n",	/* stmt: LTI(reg,reg) */
/* 213 */	"\tcmpi  \tCR0,0,r%0,%1\n \tblt \t%a\n",	/* stmt: LTI(reg,con16) */
/* 214 */	"\tcmpl  \tCR0,0,r%0,r%1\n\tblt \t%a\n",	/* stmt: LTU(reg,reg) */
/* 215 */	"\tcmpli \tCR0,0,r%0,%1\n \tblt \t%a\n",	/* stmt: LTU(reg,lcon16) */
/* 216 */	"\tcmp   \tCR0,0,r%0,r%1\n\tbne \t%a\n",	/* stmt: NEI(reg,reg) */
/* 217 */	"\tcmpi  \tCR0,0,r%0,%1\n \tbne \t%a\n",	/* stmt: NEI(reg,con16) */
/* 218 */	"\tcmpli \tCR0,0,r%0,%1\n \tbne \t%a\n",	/* stmt: NEI(reg,lcon16) */
/* 219 */	"%a",	/* zero: CNSTC */
/* 220 */	"%a",	/* zero: CNSTI */
/* 221 */	"%a",	/* zero: CNSTU */
/* 222 */	"%a",	/* zero: CNSTS */
/* 223 */	"%a",	/* zero: CNSTP */
/* 224 */	"\tandi. \tr0,r%0,%1\n\tbeq \t%a\n",	/* stmt: EQI(BANDU(reg,lcon16),zero) */
/* 225 */	"\tandi. \tr0,r%0,%1\n\tbne \t%a\n",	/* stmt: NEI(BANDU(reg,lcon16),zero) */
/* 226 */	"\tandi. \tr0,r%0,%1\n\tbeq \t%a\n",	/* stmt: EQI(CVUI(BANDU(reg,lcon16)),zero) */
/* 227 */	"\tandi. \tr0,r%0,%1\n\tbne \t%a\n",	/* stmt: NEI(CVUI(BANDU(reg,lcon16)),zero) */
/* 228 */	"\tandi. \tr0,r%0,0xff\n\tbeq \t%a\n",	/* stmt: EQI(CVCU(reg),zero) */
/* 229 */	"\tandi. \tr0,r%0,0xff\n\tbne \t%a\n",	/* stmt: NEI(CVCU(reg),zero) */
/* 230 */	"\tandi. \tr0,r%0,0xff\n\tbeq \t%a\n",	/* stmt: EQI(CVUI(CVCU(reg)),zero) */
/* 231 */	"\tandi. \tr0,r%0,0xff\n\tbne \t%a\n",	/* stmt: NEI(CVUI(CVCU(reg)),zero) */
/* 232 */	"\tadd. \tr0,r%0,r%1\n\tbeq \t%a\n",	/* stmt: EQI(ADDI(reg,reg),zero) */
/* 233 */	"\tadd. \tr0,r%0,r%1\n\tbge \t%a\n",	/* stmt: GEI(ADDI(reg,reg),zero) */
/* 234 */	"\tadd. \tr0,r%0,r%1\n\tbgt \t%a\n",	/* stmt: GTI(ADDI(reg,reg),zero) */
/* 235 */	"\tadd. \tr0,r%0,r%1\n\tble \t%a\n",	/* stmt: LEI(ADDI(reg,reg),zero) */
/* 236 */	"\tadd. \tr0,r%0,r%1\n\tblt \t%a\n",	/* stmt: LTI(ADDI(reg,reg),zero) */
/* 237 */	"\tadd. \tr0,r%0,r%1\n\tbne \t%a\n",	/* stmt: NEI(ADDI(reg,reg),zero) */
/* 238 */	"\tfcmpo \tCR0, f%0,f%1\n\tbeq \t%a\n",	/* stmt: EQD(reg,reg) */
/* 239 */	"\tfcmpo \tCR0, f%0,f%1\n\tbeq \t%a\n",	/* stmt: EQF(reg,reg) */
/* 240 */	"\tfcmpo \tCR0, f%0,f%1\n\tble \t%a\n",	/* stmt: LED(reg,reg) */
/* 241 */	"\tfcmpo \tCR0, f%0,f%1\n\tble \t%a\n",	/* stmt: LEF(reg,reg) */
/* 242 */	"\tfcmpo \tCR0, f%0,f%1\n\tblt \t%a\n",	/* stmt: LTD(reg,reg) */
/* 243 */	"\tfcmpo \tCR0, f%0,f%1\n\tblt \t%a\n",	/* stmt: LTF(reg,reg) */
/* 244 */	"\tfcmpo \tCR0, f%0,f%1\n\tbge \t%a\n",	/* stmt: GED(reg,reg) */
/* 245 */	"\tfcmpo \tCR0, f%0,f%1\n\tbge \t%a\n",	/* stmt: GEF(reg,reg) */
/* 246 */	"\tfcmpo \tCR0, f%0,f%1\n\tbgt \t%a\n",	/* stmt: GTD(reg,reg) */
/* 247 */	"\tfcmpo \tCR0, f%0,f%1\n\tbgt \t%a\n",	/* stmt: GTF(reg,reg) */
/* 248 */	"\tfcmpo \tCR0, f%0,f%1\n\tbne \t%a\n",	/* stmt: NED(reg,reg) */
/* 249 */	"\tfcmpo \tCR0, f%0,f%1\n\tbne \t%a\n",	/* stmt: NEF(reg,reg) */
/* 250 */	"\tmtspr \tLR,r%0\n\tbclr  \t0x14,0x0\n",	/* stmt: JUMPV(reg) */
/* 251 */	"# double call thru pointer\n",	/* reg: CALLD(reg) */
/* 252 */	"# float call thru pointer\n",	/* reg: CALLF(reg) */
/* 253 */	"# int call thru pointer\n",	/* reg: CALLI(reg) */
/* 254 */	"# void call thru pointer\n",	/* stmt: CALLV(reg) */
/* 255 */	"%a",	/* ar: ADDRGP */
/* 256 */	"%a",	/* ar: CNSTP */
/* 257 */	"\tb \t%0\n",	/* stmt: JUMPV(ar) */
/* 258 */	"\tbl \t.%0\n\tcror \t31,31,31\n",	/* reg: CALLD(ar) */
/* 259 */	"\tbl \t.%0\n\tcror \t31,31,31\n",	/* reg: CALLF(ar) */
/* 260 */	"\tbl \t.%0\n\tcror \t31,31,31\n",	/* reg: CALLI(ar) */
/* 261 */	"\tbl \t.%0\n\tcror \t31,31,31\n",	/* stmt: CALLV(ar) */
/* 262 */	"%a:\n",	/* stmt: LABELV */
/* 263 */	"# ret\n",	/* stmt: RETD(reg) */
/* 264 */	"# ret\n",	/* stmt: RETF(reg) */
/* 265 */	"# ret\n",	/* stmt: RETI(reg) */
/* 266 */	"# arg\n",	/* stmt: ARGD(reg) */
/* 267 */	"# arg\n",	/* stmt: ARGF(reg) */
/* 268 */	"# arg\n",	/* stmt: ARGI(reg) */
/* 269 */	"# arg\n",	/* stmt: ARGP(reg) */
/* 270 */	"# argb %0\n",	/* stmt: ARGB(INDIRB(reg)) */
/* 271 */	"# asgnb %0 %1\n",	/* stmt: ASGNB(reg,INDIRB(reg)) */
};

static char _isinstruction[] = {
/* 0 */	0,
/* 1 */	1,	/* # read register\n */
/* 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,	/* # write register\n */
/* 8 */	1,	/* # write register\n */
/* 9 */	1,	/* # write register\n */
/* 10 */	1,	/* # write register\n */
/* 11 */	1,	/* # write register\n */
/* 12 */	1,	/* # write register\n */
/* 13 */	0,	/* %a */
/* 14 */	0,	/* %a */
/* 15 */	0,	/* %a */
/* 16 */	0,	/* %a */
/* 17 */	0,	/* %a */
/* 18 */	0,	/*  */
/* 19 */	0,	/* %0 */
/* 20 */	0,	/* %0 */
/* 21 */	0,	/* %0 */
/* 22 */	0,	/* %0 */
/* 23 */	1,	/* # toc access\n */
/* 24 */	0,	/* %a */
/* 25 */	0,	/* %a */
/* 26 */	0,	/* %a */
/* 27 */	0,	/* %a */
/* 28 */	0,	/* %a */
/* 29 */	1,	/* \taddi \tr%c,r0,%0\n */
/* 30 */	1,	/* \taddis \tr%c,r0,(%a-((%a<16)>16))>16\n\taddi \tr%c,r%c,(%a<16)>16\t# Big constant %a\n */
/* 31 */	1,	/* \taddis \tr%c,r0,(%a-((%a<16)>16))>16\t# Big offset %a \n */
/* 32 */	0,	/* ((%a<16)>16)(r%0) */
/* 33 */	1,	/* \taddis \tr%c,FP,(%a-((%a<16)>16))>16\n\taddi \tr%c,r%c,(%a<16)>16\t# Big frame offset %a\n */
/* 34 */	0,	/* %a(FP) */
/* 35 */	1,	/* \taddi \tr%c,FP,%a\n */
/* 36 */	1,	/* \taddis \tr%c,FP,(%a-((%a<16)>16))>16\n\taddi \tr%c,r%c,(%a<16)>16\t# Big local offset %a\n */
/* 37 */	0,	/* %a(FP) */
/* 38 */	1,	/* \taddi \tr%c,FP,%a\n */
/* 39 */	0,	/* %0(r0) */
/* 40 */	0,	/* %1(r%0) */
/* 41 */	0,	/* %1(r%0) */
/* 42 */	0,	/* %1(r%0) */
/* 43 */	0,	/* 0(r%0) */
/* 44 */	0,	/* r%0,r%1 */
/* 45 */	0,	/* r%0,r%1 */
/* 46 */	0,	/* r%0,r%1 */
/* 47 */	1,	/* \tstb \tr%1,%0\n */
/* 48 */	1,	/* \tsth \tr%1,%0\n */
/* 49 */	1,	/* \tstw \tr%1,%0\n */
/* 50 */	1,	/* \tstw \tr%1,%0\n */
/* 51 */	1,	/* \tstfd \tf%1,%0\n */
/* 52 */	1,	/* \tstfs \tf%1,%0\n */
/* 53 */	1,	/* \tstbx \tr%1,%0\n */
/* 54 */	1,	/* \tsthx \tr%1,%0\n */
/* 55 */	1,	/* \tstwx \tr%1,%0\n */
/* 56 */	1,	/* \tstwx \tr%1,%0\n */
/* 57 */	1,	/* \tstfdx \tf%1,%0\n */
/* 58 */	1,	/* \tstfsx \tf%1,%0\n */
/* 59 */	1,	/* \tlbz \tr%c,%0\n */
/* 60 */	1,	/* \tlha \tr%c,%0\n */
/* 61 */	1,	/* \tlwz \tr%c,%0\n */
/* 62 */	1,	/* \tlwz \tr%c,%0\n */
/* 63 */	1,	/* \tlfd \tf%c,%0\n */
/* 64 */	1,	/* \tlfs \tf%c,%0\n */
/* 65 */	1,	/* \tlbzx \tr%c,%0\n */
/* 66 */	1,	/* \tlhax \tr%c,%0\n */
/* 67 */	1,	/* \tlwzx \tr%c,%0\n */
/* 68 */	1,	/* \tlwzx \tr%c,%0\n */
/* 69 */	1,	/* \tlfdx \tf%c,%0\n */
/* 70 */	1,	/* \tlfsx \tf%c,%0\n */
/* 71 */	1,	/* \tlha \tr%c,%0\n */
/* 72 */	1,	/* \tlbz \tr%c,%0\n */
/* 73 */	1,	/* \tlhz \tr%c,%0\n */
/* 74 */	1,	/* \tlhax \tr%c,%0\n */
/* 75 */	1,	/* \tlbzx \tr%c,%0\n */
/* 76 */	1,	/* \tlhzx \tr%c,%0\n */
/* 77 */	1,	/* \tmr \tr%c,r%0\n */
/* 78 */	1,	/* \tmr \tr%c,r%0\n */
/* 79 */	1,	/* \tmr \tr%c,r%0\n */
/* 80 */	1,	/* \tmr \tr%c,r%0\n */
/* 81 */	1,	/* \tmr \tr%c,r%0\n */
/* 82 */	1,	/* \tmr \tr%c,r%0\n */
/* 83 */	1,	/* \tmr \tr%c,r%0\n */
/* 84 */	1,	/* \tmr \tr%c,r%0\n */
/* 85 */	0,	/* %0 */
/* 86 */	0,	/* %0 */
/* 87 */	0,	/* %0 */
/* 88 */	0,	/* %0 */
/* 89 */	1,	/* \tmr \tr%c,r%0\n */
/* 90 */	1,	/* \tmr \tr%c,r%0\n */
/* 91 */	1,	/* \tmr \tr%c,r%0\n */
/* 92 */	1,	/* \tmr \tr%c,r%0\n */
/* 93 */	1,	/* \tmr \tr%c,r%0\n */
/* 94 */	1,	/* \tadd  \tr%c,r%0,r%1\n */
/* 95 */	1,	/* \taddi \tr%c,r%0,%1\n */
/* 96 */	1,	/* \taddis \tr%c,r%0,(%1-((%1<16)>16))>16\n\taddi \tr%c,r%c,(%1<16)>16\n */
/* 97 */	1,	/* \taddi \tr%c,r%0,%1\n */
/* 98 */	1,	/* \tadd  \tr%c,r%0,r%1\n */
/* 99 */	1,	/* \tadd  \tr%c,r%0,r%1\n */
/* 100 */	1,	/* \taddi \tr%c,r%0,%1\n */
/* 101 */	0,	/* %a */
/* 102 */	0,	/* %a */
/* 103 */	0,	/* %a */
/* 104 */	0,	/* %a */
/* 105 */	0,	/* %a */
/* 106 */	1,	/* \tsubf \tr%c,r%1,r%0\n */
/* 107 */	1,	/* \taddi \tr%c,r%0,-%1\n */
/* 108 */	1,	/* \tsubf \tr%c,r%1,r%0\n */
/* 109 */	1,	/* \taddi \tr%c,r%0,-%1\n */
/* 110 */	1,	/* \tsubf \tr%c,r%1,r%0\n */
/* 111 */	1,	/* \taddi \tr%c,r%0,-%1\n */
/* 112 */	0,	/* %a */
/* 113 */	0,	/* %a */
/* 114 */	0,	/* %a */
/* 115 */	0,	/* %a */
/* 116 */	0,	/* %a */
/* 117 */	0,	/* %a */
/* 118 */	0,	/* %a */
/* 119 */	0,	/* %a */
/* 120 */	0,	/* %a */
/* 121 */	0,	/* %a */
/* 122 */	1,	/* \tnand \tr%c,r%0,r%0\n */
/* 123 */	1,	/* \tand    \tr%c,r%0,r%1\n */
/* 124 */	1,	/* \tandi.  \tr%c,r%0,%1\n */
/* 125 */	1,	/* \tandis. \tr%c,r%0,(%1>16)&0xffff\n */
/* 126 */	1,	/* \tandc \tr%c,r%0,r%1\n */
/* 127 */	1,	/* \tandc \tr%c,r%1,r%0\n */
/* 128 */	1,	/* \tnand \tr%c,r%0,r%1\n */
/* 129 */	1,	/* \torc \tr%c,r%1,r%0\n */
/* 130 */	1,	/* \torc \tr%c,r%0,r%1\n */
/* 131 */	1,	/* \tor   \tr%c,r%0,r%1\n */
/* 132 */	1,	/* \tori  \tr%c,r%0,%1\n */
/* 133 */	1,	/* \toris \tr%c,r%0,(%1>16)&0xffff\n */
/* 134 */	1,	/* \torc \tr%c,r%0,r%1\n */
/* 135 */	1,	/* \torc \tr%c,r%1,r%0\n */
/* 136 */	1,	/* \tnor \tr%c,r%0,r%1\n */
/* 137 */	1,	/* \tandc \tr%c,r%1,r%0\n */
/* 138 */	1,	/* \tandc \tr%c,r%0,r%1\n */
/* 139 */	1,	/* \toris \tr%c,r%0,(%1>16)&0xffff\n\tori \tr%c,r%c,%1&0xffff\n */
/* 140 */	1,	/* \txor  \tr%c,r%0,r%1\n */
/* 141 */	1,	/* \txori \tr%c,r%0,%1\n */
/* 142 */	1,	/* \txori \tr%c,r%0,(%1>16)&0xffff\n */
/* 143 */	1,	/* \txoris \tr%c,r%0,(%1>16)&0xffff\n\txori \tr%c,r%c,%1&0xffff\n */
/* 144 */	0,	/* %a */
/* 145 */	0,	/* %a */
/* 146 */	0,	/* %a */
/* 147 */	0,	/* %a */
/* 148 */	0,	/* %a */
/* 149 */	0,	/* %0 */
/* 150 */	1,	/* \trlwinm \tr%c,r%0,0,%B\t\t# And r%0 with mask (%B) into r%c\n */
/* 151 */	1,	/* ?\tmr \tr%c,r%0\n \trlwimi \tr%c,r%1,0,%B\t\t# (r%1 & %B) | (r%0 & ~%B)\n */
/* 152 */	1,	/* \tdivw  \tr%c,r%0,r%1\n */
/* 153 */	1,	/* \tdivwu \tr%c,r%0,r%1\n */
/* 154 */	1,	/* \tdivw \tr0,r%0,r%1\t\t# Divide and truncate\n\tmullw \tr0,r0,r%1\t\t# Multiply back, rounded\n\tsubf \tr%c,r0,r%0\t\t# Compute signed remainder\n */
/* 155 */	1,	/* \tdivwu \tr0,r%0,r%1\t\t# Divide and truncate\n\tmullw \tr0,r0,r%1\t\t# Multiply back, rounded\n\tsubf \tr%c,r0,r%0\t\t# Compute unsigned remainder\n */
/* 156 */	1,	/* \tmullw \tr%c,r%0,r%1\n */
/* 157 */	1,	/* \tmullw \tr%c,r%0,r%1\n */
/* 158 */	0,	/* %a */
/* 159 */	0,	/* %a */
/* 160 */	0,	/* %a */
/* 161 */	0,	/* %a */
/* 162 */	1,	/* \trlwinm \tr%c,r%0,%1,0,31-%1\t# left shift r%0 by %1 into r%c\n */
/* 163 */	1,	/* \trlwinm \tr%c,r%0,%1,0,31-%1\t# left shift r%0 by %1 into r%c\n */
/* 164 */	1,	/* \tsrawi \tr%c,r%0,%1\t\t# Shift right arithmetic by %1\n */
/* 165 */	1,	/* \trlwinm \tr%c,r%0,32-%1,%1,31\t# Shift right logical r%0 by %1 into r%c\n */
/* 166 */	1,	/* \tslw \tr%c,r%0,r%1\t# Shift left logical by r%1\n */
/* 167 */	1,	/* \tslw \tr%c,r%0,r%1\t# Shift left logical by r%1\n */
/* 168 */	1,	/* \tsraw \tr%c,r%0,r%1\t# Shift right arithmetic by r%1\n */
/* 169 */	1,	/* \tsrw \tr%c,r%0,r%1\t# Shift right logical by r%1\n */
/* 170 */	1,	/* \tneg \tr%c,r%0\n */
/* 171 */	1,	/* \tmr\tr%c,r%0\n */
/* 172 */	1,	/* \tmr\tr%c,r%0\n */
/* 173 */	1,	/* \tmr\tr%c,r%0\n */
/* 174 */	1,	/* \tmr\tr%c,r%0\n */
/* 175 */	1,	/* \tmr\tr%c,r%0\n */
/* 176 */	1,	/* \tfmr\tf%c,f%0\n */
/* 177 */	1,	/* \tfmr\tf%c,f%0\n */
/* 178 */	1,	/* \tfadd  \tf%c,f%0,f%1\n */
/* 179 */	1,	/* \tfadds \tf%c,f%0,f%1\n */
/* 180 */	1,	/* \tfdiv  \tf%c,f%0,f%1\n */
/* 181 */	1,	/* \tfdivs \tf%c,f%0,f%1\n */
/* 182 */	1,	/* \tfmul  \tf%c,f%0,f%1\n */
/* 183 */	1,	/* \tfmuls \tf%c,f%0,f%1\n */
/* 184 */	1,	/* \tfsub  \tf%c,f%0,f%1\n */
/* 185 */	1,	/* \tfsubs \tf%c,f%0,f%1\n */
/* 186 */	1,	/* \tfneg  \tf%c,f%0\n */
/* 187 */	1,	/* \tfneg  \tf%c,f%0\n */
/* 188 */	1,	/* \textsb \tr%c,r%0\n */
/* 189 */	1,	/* \textsb \tr%c,r%0\n */
/* 190 */	1,	/* \textsh \tr%c,r%0\n */
/* 191 */	1,	/* \tandi. \tr%c,r%0,0xff\n */
/* 192 */	1,	/* \tandi. \tr%c,r%0,0xffff\n */
/* 193 */	1,	/* \tfmr \tf%c,f%0\n */
/* 194 */	1,	/* \tfmr \tf%c,f%0\n */
/* 195 */	1,	/* # Int to double\n */
/* 196 */	1,	/* # Double to int\n */
/* 197 */	1,	/* \tcmp   \tCR0,0,r%0,r%1\n\tbeq \t%a\n */
/* 198 */	1,	/* \tcmpi  \tCR0,0,r%0,%1\n \tbeq \t%a\n */
/* 199 */	1,	/* \tcmpli \tCR0,0,r%0,%1\n \tbeq \t%a\n */
/* 200 */	1,	/* \tcmp   \tCR0,0,r%0,r%1\n\tbge \t%a\n */
/* 201 */	1,	/* \tcmpi  \tCR0,0,r%0,%1\n \tbge \t%a\n */
/* 202 */	1,	/* \tcmpl  \tCR0,0,r%0,r%1\n\tbge \t%a\n */
/* 203 */	1,	/* \tcmpli \tCR0,0,r%0,%1\n \tbge \t%a\n */
/* 204 */	1,	/* \tcmp   \tCR0,0,r%0,r%1\n\tbgt \t%a\n */
/* 205 */	1,	/* \tcmpi  \tCR0,0,r%0,%1\n \tbgt \t%a\n */
/* 206 */	1,	/* \tcmpl  \tCR0,0,r%0,r%1\n\tbgt \t%a\n */
/* 207 */	1,	/* \tcmpli \tCR0,0,r%0,%1\n \tbgt \t%a\n */
/* 208 */	1,	/* \tcmp   \tCR0,0,r%0,r%1\n\tble \t%a\n */
/* 209 */	1,	/* \tcmpi  \tCR0,0,r%0,%1\n \tble \t%a\n */
/* 210 */	1,	/* \tcmpl  \tCR0,0,r%0,r%1\n\tble \t%a\n */
/* 211 */	1,	/* \tcmpli \tCR0,0,r%0,%1\n \tble \t%a\n */
/* 212 */	1,	/* \tcmp   \tCR0,0,r%0,r%1\n\tblt \t%a\n */
/* 213 */	1,	/* \tcmpi  \tCR0,0,r%0,%1\n \tblt \t%a\n */
/* 214 */	1,	/* \tcmpl  \tCR0,0,r%0,r%1\n\tblt \t%a\n */
/* 215 */	1,	/* \tcmpli \tCR0,0,r%0,%1\n \tblt \t%a\n */
/* 216 */	1,	/* \tcmp   \tCR0,0,r%0,r%1\n\tbne \t%a\n */
/* 217 */	1,	/* \tcmpi  \tCR0,0,r%0,%1\n \tbne \t%a\n */
/* 218 */	1,	/* \tcmpli \tCR0,0,r%0,%1\n \tbne \t%a\n */
/* 219 */	0,	/* %a */
/* 220 */	0,	/* %a */
/* 221 */	0,	/* %a */
/* 222 */	0,	/* %a */
/* 223 */	0,	/* %a */
/* 224 */	1,	/* \tandi. \tr0,r%0,%1\n\tbeq \t%a\n */
/* 225 */	1,	/* \tandi. \tr0,r%0,%1\n\tbne \t%a\n */
/* 226 */	1,	/* \tandi. \tr0,r%0,%1\n\tbeq \t%a\n */
/* 227 */	1,	/* \tandi. \tr0,r%0,%1\n\tbne \t%a\n */
/* 228 */	1,	/* \tandi. \tr0,r%0,0xff\n\tbeq \t%a\n */
/* 229 */	1,	/* \tandi. \tr0,r%0,0xff\n\tbne \t%a\n */
/* 230 */	1,	/* \tandi. \tr0,r%0,0xff\n\tbeq \t%a\n */
/* 231 */	1,	/* \tandi. \tr0,r%0,0xff\n\tbne \t%a\n */
/* 232 */	1,	/* \tadd. \tr0,r%0,r%1\n\tbeq \t%a\n */
/* 233 */	1,	/* \tadd. \tr0,r%0,r%1\n\tbge \t%a\n */
/* 234 */	1,	/* \tadd. \tr0,r%0,r%1\n\tbgt \t%a\n */
/* 235 */	1,	/* \tadd. \tr0,r%0,r%1\n\tble \t%a\n */
/* 236 */	1,	/* \tadd. \tr0,r%0,r%1\n\tblt \t%a\n */
/* 237 */	1,	/* \tadd. \tr0,r%0,r%1\n\tbne \t%a\n */
/* 238 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbeq \t%a\n */
/* 239 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbeq \t%a\n */
/* 240 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tble \t%a\n */
/* 241 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tble \t%a\n */
/* 242 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tblt \t%a\n */
/* 243 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tblt \t%a\n */
/* 244 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbge \t%a\n */
/* 245 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbge \t%a\n */
/* 246 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbgt \t%a\n */
/* 247 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbgt \t%a\n */
/* 248 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbne \t%a\n */
/* 249 */	1,	/* \tfcmpo \tCR0, f%0,f%1\n\tbne \t%a\n */
/* 250 */	1,	/* \tmtspr \tLR,r%0\n\tbclr  \t0x14,0x0\n */
/* 251 */	1,	/* # double call thru pointer\n */
/* 252 */	1,	/* # float call thru pointer\n */
/* 253 */	1,	/* # int call thru pointer\n */
/* 254 */	1,	/* # void call thru pointer\n */
/* 255 */	0,	/* %a */
/* 256 */	0,	/* %a */
/* 257 */	1,	/* \tb \t%0\n */
/* 258 */	1,	/* \tbl \t.%0\n\tcror \t31,31,31\n */
/* 259 */	1,	/* \tbl \t.%0\n\tcror \t31,31,31\n */
/* 260 */	1,	/* \tbl \t.%0\n\tcror \t31,31,31\n */
/* 261 */	1,	/* \tbl \t.%0\n\tcror \t31,31,31\n */
/* 262 */	1,	/* %a:\n */
/* 263 */	1,	/* # ret\n */
/* 264 */	1,	/* # ret\n */
/* 265 */	1,	/* # ret\n */
/* 266 */	1,	/* # arg\n */
/* 267 */	1,	/* # arg\n */
/* 268 */	1,	/* # arg\n */
/* 269 */	1,	/* # arg\n */
/* 270 */	1,	/* # argb %0\n */
/* 271 */	1,	/* # asgnb %0 %1\n */
};

static char *_string[] = {
/* 0 */	0,
/* 1 */	"reg: INDIRC(VREGP)",
/* 2 */	"reg: INDIRD(VREGP)",
/* 3 */	"reg: INDIRF(VREGP)",
/* 4 */	"reg: INDIRI(VREGP)",
/* 5 */	"reg: INDIRP(VREGP)",
/* 6 */	"reg: INDIRS(VREGP)",
/* 7 */	"stmt: ASGNC(VREGP,reg)",
/* 8 */	"stmt: ASGND(VREGP,reg)",
/* 9 */	"stmt: ASGNF(VREGP,reg)",
/* 10 */	"stmt: ASGNI(VREGP,reg)",
/* 11 */	"stmt: ASGNP(VREGP,reg)",
/* 12 */	"stmt: ASGNS(VREGP,reg)",
/* 13 */	"con: CNSTC",
/* 14 */	"con: CNSTI",
/* 15 */	"con: CNSTP",
/* 16 */	"con: CNSTS",
/* 17 */	"con: CNSTU",
/* 18 */	"stmt: reg",
/* 19 */	"reg: CVIU(reg)",
/* 20 */	"reg: CVPU(reg)",
/* 21 */	"reg: CVUI(reg)",
/* 22 */	"reg: CVUP(reg)",
/* 23 */	"reg: ADDRGP",
/* 24 */	"con16: CNSTC",
/* 25 */	"con16: CNSTS",
/* 26 */	"con16: CNSTI",
/* 27 */	"con16: CNSTU",
/* 28 */	"con16: CNSTP",
/* 29 */	"reg: con16",
/* 30 */	"reg: con",
/* 31 */	"conhi: con",
/* 32 */	"addr: conhi",
/* 33 */	"reg: ADDRFP",
/* 34 */	"addr: ADDRFP",
/* 35 */	"reg: ADDRFP",
/* 36 */	"reg: ADDRLP",
/* 37 */	"addr: ADDRLP",
/* 38 */	"reg: ADDRLP",
/* 39 */	"addr: con16",
/* 40 */	"addr: ADDI(reg,con16)",
/* 41 */	"addr: ADDP(reg,con16)",
/* 42 */	"addr: ADDU(reg,con16)",
/* 43 */	"addr: reg",
/* 44 */	"idx: ADDI(reg,reg)",
/* 45 */	"idx: ADDU(reg,reg)",
/* 46 */	"idx: ADDP(reg,reg)",
/* 47 */	"stmt: ASGNC(addr,reg)",
/* 48 */	"stmt: ASGNS(addr,reg)",
/* 49 */	"stmt: ASGNI(addr,reg)",
/* 50 */	"stmt: ASGNP(addr,reg)",
/* 51 */	"stmt: ASGND(addr,reg)",
/* 52 */	"stmt: ASGNF(addr,reg)",
/* 53 */	"stmt: ASGNC(idx,reg)",
/* 54 */	"stmt: ASGNS(idx,reg)",
/* 55 */	"stmt: ASGNI(idx,reg)",
/* 56 */	"stmt: ASGNP(idx,reg)",
/* 57 */	"stmt: ASGND(idx,reg)",
/* 58 */	"stmt: ASGNF(idx,reg)",
/* 59 */	"reg: INDIRC(addr)",
/* 60 */	"reg: INDIRS(addr)",
/* 61 */	"reg: INDIRI(addr)",
/* 62 */	"reg: INDIRP(addr)",
/* 63 */	"reg: INDIRD(addr)",
/* 64 */	"reg: INDIRF(addr)",
/* 65 */	"reg: INDIRC(idx)",
/* 66 */	"reg: INDIRS(idx)",
/* 67 */	"reg: INDIRI(idx)",
/* 68 */	"reg: INDIRP(idx)",
/* 69 */	"reg: INDIRD(idx)",
/* 70 */	"reg: INDIRF(idx)",
/* 71 */	"reg: CVSI(INDIRS(addr))",
/* 72 */	"reg: CVCU(INDIRC(addr))",
/* 73 */	"reg: CVSU(INDIRS(addr))",
/* 74 */	"reg: CVSI(INDIRS(idx))",
/* 75 */	"reg: CVCU(INDIRC(idx))",
/* 76 */	"reg: CVSU(INDIRS(idx))",
/* 77 */	"reg: CVIC(reg)",
/* 78 */	"reg: CVIS(reg)",
/* 79 */	"reg: CVIU(reg)",
/* 80 */	"reg: CVPU(reg)",
/* 81 */	"reg: CVUC(reg)",
/* 82 */	"reg: CVUI(reg)",
/* 83 */	"reg: CVUP(reg)",
/* 84 */	"reg: CVUS(reg)",
/* 85 */	"reg: CVIC(reg)",
/* 86 */	"reg: CVIS(reg)",
/* 87 */	"reg: CVUC(reg)",
/* 88 */	"reg: CVUS(reg)",
/* 89 */	"reg: LOADC(reg)",
/* 90 */	"reg: LOADI(reg)",
/* 91 */	"reg: LOADP(reg)",
/* 92 */	"reg: LOADS(reg)",
/* 93 */	"reg: LOADU(reg)",
/* 94 */	"reg: ADDI(reg,reg)",
/* 95 */	"reg: ADDI(reg,con16)",
/* 96 */	"reg: ADDI(reg,con)",
/* 97 */	"reg: ADDP(reg,con16)",
/* 98 */	"reg: ADDP(reg,reg)",
/* 99 */	"reg: ADDU(reg,reg)",
/* 100 */	"reg: ADDU(reg,con16)",
/* 101 */	"mcon16: CNSTC",
/* 102 */	"mcon16: CNSTS",
/* 103 */	"mcon16: CNSTI",
/* 104 */	"mcon16: CNSTU",
/* 105 */	"mcon16: CNSTP",
/* 106 */	"reg: SUBI(reg,reg)",
/* 107 */	"reg: SUBI(reg,mcon16)",
/* 108 */	"reg: SUBP(reg,reg)",
/* 109 */	"reg: SUBP(reg,mcon16)",
/* 110 */	"reg: SUBU(reg,reg)",
/* 111 */	"reg: SUBU(reg,mcon16)",
/* 112 */	"lcon16: CNSTC",
/* 113 */	"lcon16: CNSTS",
/* 114 */	"lcon16: CNSTI",
/* 115 */	"lcon16: CNSTU",
/* 116 */	"lcon16: CNSTP",
/* 117 */	"ucon16: CNSTC",
/* 118 */	"ucon16: CNSTS",
/* 119 */	"ucon16: CNSTI",
/* 120 */	"ucon16: CNSTU",
/* 121 */	"ucon16: CNSTP",
/* 122 */	"reg: BCOMU(reg)",
/* 123 */	"reg: BANDU(reg,reg)",
/* 124 */	"reg: BANDU(reg,lcon16)",
/* 125 */	"reg: BANDU(reg,ucon16)",
/* 126 */	"reg: BANDU(reg,BCOMU(reg))",
/* 127 */	"reg: BANDU(BCOMU(reg),reg)",
/* 128 */	"reg: BCOMU(BANDU(reg,reg))",
/* 129 */	"reg: BCOMU(BANDU(reg,BCOMU(reg)))",
/* 130 */	"reg: BCOMU(BANDU(BCOMU(reg),reg))",
/* 131 */	"reg: BORU(reg,reg)",
/* 132 */	"reg: BORU(reg,lcon16)",
/* 133 */	"reg: BORU(reg,ucon16)",
/* 134 */	"reg: BORU(reg,BCOMU(reg))",
/* 135 */	"reg: BORU(BCOMU(reg),reg)",
/* 136 */	"reg: BCOMU(BORU(reg,reg))",
/* 137 */	"reg: BCOMU(BORU(reg,BCOMU(reg)))",
/* 138 */	"reg: BCOMU(BORU(BCOMU(reg),reg))",
/* 139 */	"reg: BORU(reg,con)",
/* 140 */	"reg: BXORU(reg,reg)",
/* 141 */	"reg: BXORU(reg,lcon16)",
/* 142 */	"reg: BXORU(reg,ucon16)",
/* 143 */	"reg: BXORU(reg,con)",
/* 144 */	"bitrun: CNSTC",
/* 145 */	"bitrun: CNSTS",
/* 146 */	"bitrun: CNSTI",
/* 147 */	"bitrun: CNSTU",
/* 148 */	"bitrun: CNSTP",
/* 149 */	"and_mask: BANDU(reg,bitrun)",
/* 150 */	"reg: and_mask",
/* 151 */	"reg: BORU(and_mask,and_mask)",
/* 152 */	"reg: DIVI(reg,reg)",
/* 153 */	"reg: DIVU(reg,reg)",
/* 154 */	"reg: MODI(reg,reg)",
/* 155 */	"reg: MODU(reg,reg)",
/* 156 */	"reg: MULI(reg,reg)",
/* 157 */	"reg: MULU(reg,reg)",
/* 158 */	"con5: CNSTC",
/* 159 */	"con5: CNSTS",
/* 160 */	"con5: CNSTI",
/* 161 */	"con5: CNSTU",
/* 162 */	"reg: LSHI(reg,con5)",
/* 163 */	"reg: LSHU(reg,con5)",
/* 164 */	"reg: RSHI(reg,con5)",
/* 165 */	"reg: RSHU(reg,con5)",
/* 166 */	"reg: LSHI(reg,reg)",
/* 167 */	"reg: LSHU(reg,reg)",
/* 168 */	"reg: RSHI(reg,reg)",
/* 169 */	"reg: RSHU(reg,reg)",
/* 170 */	"reg: NEGI(reg)",
/* 171 */	"reg: LOADC(reg)",
/* 172 */	"reg: LOADS(reg)",
/* 173 */	"reg: LOADI(reg)",
/* 174 */	"reg: LOADP(reg)",
/* 175 */	"reg: LOADU(reg)",
/* 176 */	"reg: LOADD(reg)",
/* 177 */	"reg: LOADF(reg)",
/* 178 */	"reg: ADDD(reg,reg)",
/* 179 */	"reg: ADDF(reg,reg)",
/* 180 */	"reg: DIVD(reg,reg)",
/* 181 */	"reg: DIVF(reg,reg)",
/* 182 */	"reg: MULD(reg,reg)",
/* 183 */	"reg: MULF(reg,reg)",
/* 184 */	"reg: SUBD(reg,reg)",
/* 185 */	"reg: SUBF(reg,reg)",
/* 186 */	"reg: NEGD(reg)",
/* 187 */	"reg: NEGF(reg)",
/* 188 */	"reg: CVCI(reg)",
/* 189 */	"reg: CVCI(reg)",
/* 190 */	"reg: CVSI(reg)",
/* 191 */	"reg: CVCU(reg)",
/* 192 */	"reg: CVSU(reg)",
/* 193 */	"reg: CVDF(reg)",
/* 194 */	"reg: CVFD(reg)",
/* 195 */	"reg: CVID(reg)",
/* 196 */	"reg: CVDI(reg)",
/* 197 */	"stmt: EQI(reg,reg)",
/* 198 */	"stmt: EQI(reg,con16)",
/* 199 */	"stmt: EQI(reg,lcon16)",
/* 200 */	"stmt: GEI(reg,reg)",
/* 201 */	"stmt: GEI(reg,con16)",
/* 202 */	"stmt: GEU(reg,reg)",
/* 203 */	"stmt: GEU(reg,lcon16)",
/* 204 */	"stmt: GTI(reg,reg)",
/* 205 */	"stmt: GTI(reg,con16)",
/* 206 */	"stmt: GTU(reg,reg)",
/* 207 */	"stmt: GTU(reg,lcon16)",
/* 208 */	"stmt: LEI(reg,reg)",
/* 209 */	"stmt: LEI(reg,con16)",
/* 210 */	"stmt: LEU(reg,reg)",
/* 211 */	"stmt: LEU(reg,lcon16)",
/* 212 */	"stmt: LTI(reg,reg)",
/* 213 */	"stmt: LTI(reg,con16)",
/* 214 */	"stmt: LTU(reg,reg)",
/* 215 */	"stmt: LTU(reg,lcon16)",
/* 216 */	"stmt: NEI(reg,reg)",
/* 217 */	"stmt: NEI(reg,con16)",
/* 218 */	"stmt: NEI(reg,lcon16)",
/* 219 */	"zero: CNSTC",
/* 220 */	"zero: CNSTI",
/* 221 */	"zero: CNSTU",
/* 222 */	"zero: CNSTS",
/* 223 */	"zero: CNSTP",
/* 224 */	"stmt: EQI(BANDU(reg,lcon16),zero)",
/* 225 */	"stmt: NEI(BANDU(reg,lcon16),zero)",
/* 226 */	"stmt: EQI(CVUI(BANDU(reg,lcon16)),zero)",
/* 227 */	"stmt: NEI(CVUI(BANDU(reg,lcon16)),zero)",
/* 228 */	"stmt: EQI(CVCU(reg),zero)",
/* 229 */	"stmt: NEI(CVCU(reg),zero)",
/* 230 */	"stmt: EQI(CVUI(CVCU(reg)),zero)",
/* 231 */	"stmt: NEI(CVUI(CVCU(reg)),zero)",
/* 232 */	"stmt: EQI(ADDI(reg,reg),zero)",
/* 233 */	"stmt: GEI(ADDI(reg,reg),zero)",
/* 234 */	"stmt: GTI(ADDI(reg,reg),zero)",
/* 235 */	"stmt: LEI(ADDI(reg,reg),zero)",
/* 236 */	"stmt: LTI(ADDI(reg,reg),zero)",
/* 237 */	"stmt: NEI(ADDI(reg,reg),zero)",
/* 238 */	"stmt: EQD(reg,reg)",
/* 239 */	"stmt: EQF(reg,reg)",
/* 240 */	"stmt: LED(reg,reg)",
/* 241 */	"stmt: LEF(reg,reg)",
/* 242 */	"stmt: LTD(reg,reg)",
/* 243 */	"stmt: LTF(reg,reg)",
/* 244 */	"stmt: GED(reg,reg)",
/* 245 */	"stmt: GEF(reg,reg)",
/* 246 */	"stmt: GTD(reg,reg)",
/* 247 */	"stmt: GTF(reg,reg)",
/* 248 */	"stmt: NED(reg,reg)",
/* 249 */	"stmt: NEF(reg,reg)",
/* 250 */	"stmt: JUMPV(reg)",
/* 251 */	"reg: CALLD(reg)",
/* 252 */	"reg: CALLF(reg)",
/* 253 */	"reg: CALLI(reg)",
/* 254 */	"stmt: CALLV(reg)",
/* 255 */	"ar: ADDRGP",
/* 256 */	"ar: CNSTP",
/* 257 */	"stmt: JUMPV(ar)",
/* 258 */	"reg: CALLD(ar)",
/* 259 */	"reg: CALLF(ar)",
/* 260 */	"reg: CALLI(ar)",
/* 261 */	"stmt: CALLV(ar)",
/* 262 */	"stmt: LABELV",
/* 263 */	"stmt: RETD(reg)",
/* 264 */	"stmt: RETF(reg)",
/* 265 */	"stmt: RETI(reg)",
/* 266 */	"stmt: ARGD(reg)",
/* 267 */	"stmt: ARGF(reg)",
/* 268 */	"stmt: ARGI(reg)",
/* 269 */	"stmt: ARGP(reg)",
/* 270 */	"stmt: ARGB(INDIRB(reg))",
/* 271 */	"stmt: ASGNB(reg,INDIRB(reg))",
};

static short _decode_stmt[] = {
	0,
	7,
	8,
	9,
	10,
	11,
	12,
	18,
	47,
	48,
	49,
	50,
	51,
	52,
	53,
	54,
	55,
	56,
	57,
	58,
	197,
	198,
	199,
	200,
	201,
	202,
	203,
	204,
	205,
	206,
	207,
	208,
	209,
	210,
	211,
	212,
	213,
	214,
	215,
	216,
	217,
	218,
	224,
	225,
	226,
	227,
	228,
	229,
	230,
	231,
	232,
	233,
	234,
	235,
	236,
	237,
	238,
	239,
	240,
	241,
	242,
	243,
	244,
	245,
	246,
	247,
	248,
	249,
	250,
	254,
	257,
	261,
	262,
	263,
	264,
	265,
	266,
	267,
	268,
	269,
	270,
	271,
};

static short _decode_reg[] = {
	0,
	1,
	2,
	3,
	4,
	5,
	6,
	19,
	20,
	21,
	22,
	23,
	29,
	30,
	33,
	35,
	36,
	38,
	59,
	60,
	61,
	62,
	63,
	64,
	65,
	66,
	67,
	68,
	69,
	70,
	71,
	72,
	73,
	74,
	75,
	76,
	77,
	78,
	79,
	80,
	81,
	82,
	83,
	84,
	85,
	86,
	87,
	88,
	89,
	90,
	91,
	92,
	93,
	94,
	95,
	96,
	97,
	98,
	99,
	100,
	106,
	107,
	108,
	109,
	110,
	111,
	122,
	123,
	124,
	125,
	126,
	127,
	128,
	129,
	130,
	131,
	132,
	133,
	134,
	135,
	136,
	137,
	138,
	139,
	140,
	141,
	142,
	143,
	150,
	151,
	152,
	153,
	154,
	155,
	156,
	157,
	162,
	163,
	164,
	165,
	166,
	167,
	168,
	169,
	170,
	171,
	172,
	173,
	174,
	175,
	176,
	177,
	178,
	179,
	180,
	181,
	182,
	183,
	184,
	185,
	186,
	187,
	188,
	189,
	190,
	191,
	192,
	193,
	194,
	195,
	196,
	251,
	252,
	253,
	258,
	259,
	260,
};

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

static short _decode_con16[] = {
	0,
	24,
	25,
	26,
	27,
	28,
};

static short _decode_conhi[] = {
	0,
	31,
};

static short _decode_addr[] = {
	0,
	32,
	34,
	37,
	39,
	40,
	41,
	42,
	43,
};

static short _decode_idx[] = {
	0,
	44,
	45,
	46,
};

static short _decode_mcon16[] = {
	0,
	101,
	102,
	103,
	104,
	105,
};

static short _decode_lcon16[] = {
	0,
	112,
	113,
	114,
	115,
	116,
};

static short _decode_ucon16[] = {
	0,
	117,
	118,
	119,
	120,
	121,
};

static short _decode_bitrun[] = {
	0,
	144,
	145,
	146,
	147,
	148,
};

static short _decode_and_mask[] = {
	0,
	149,
};

static short _decode_con5[] = {
	0,
	158,
	159,
	160,
	161,
};

static short _decode_zero[] = {
	0,
	219,
	220,
	221,
	222,
	223,
};

static short _decode_ar[] = {
	0,
	255,
	256,
};

static int _rule(state, goalnt) void *state; int goalnt; {
	if (goalnt < 1 || goalnt > 15)
		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 _con16_NT:	return _decode_con16[((struct _state *)state)->rule._con16];
	case _conhi_NT:	return _decode_conhi[((struct _state *)state)->rule._conhi];
	case _addr_NT:	return _decode_addr[((struct _state *)state)->rule._addr];
	case _idx_NT:	return _decode_idx[((struct _state *)state)->rule._idx];
	case _mcon16_NT:	return _decode_mcon16[((struct _state *)state)->rule._mcon16];
	case _lcon16_NT:	return _decode_lcon16[((struct _state *)state)->rule._lcon16];
	case _ucon16_NT:	return _decode_ucon16[((struct _state *)state)->rule._ucon16];
	case _bitrun_NT:	return _decode_bitrun[((struct _state *)state)->rule._bitrun];
	case _and_mask_NT:	return _decode_and_mask[((struct _state *)state)->rule._and_mask];
	case _con5_NT:	return _decode_con5[((struct _state *)state)->rule._con5];
	case _zero_NT:	return _decode_zero[((struct _state *)state)->rule._zero];
	case _ar_NT:	return _decode_ar[((struct _state *)state)->rule._ar];
	default:
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
		return 0;
	}
}

static void _closure_reg ARGS((NODEPTR_TYPE, int));
static void _closure_con ARGS((NODEPTR_TYPE, int));
static void _closure_con16 ARGS((NODEPTR_TYPE, int));
static void _closure_conhi ARGS((NODEPTR_TYPE, int));
static void _closure_and_mask ARGS((NODEPTR_TYPE, int));

static void _closure_reg(a, c) NODEPTR_TYPE a; int c; {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_addr_NT]) {
		p->cost[_addr_NT] = c + 0;
		p->rule._addr = 8;
	}
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 7;
	}
}

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

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

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

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

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

	if (!a)
		fatal("_label", "Null tree\n", 0);
	STATE_LABEL(a) = p = allocate(sizeof *p, FUNC);
	p->rule._stmt = 0;
	p->cost[1] =
	p->cost[2] =
	p->cost[3] =
	p->cost[4] =
	p->cost[5] =
	p->cost[6] =
	p->cost[7] =
	p->cost[8] =
	p->cost[9] =
	p->cost[10] =
	p->cost[11] =
	p->cost[12] =
	p->cost[13] =
	p->cost[14] =
	p->cost[15] =
		0x7fff;
	switch (OP_LABEL(a)) {
	case 17: /* CNSTF */
		break;
	case 18: /* CNSTD */
		break;
	case 19: /* CNSTC */
		/* con: CNSTC */
		c = 0;
		if (c + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = c + 0;
			p->rule._con = 1;
			_closure_con(a, c + 0);
		}
		/* con16: CNSTC */
		c = range(a,-32768,32767)	/* Small integer constants */;
		if (c + 0 < p->cost[_con16_NT]) {
			p->cost[_con16_NT] = c + 0;
			p->rule._con16 = 1;
			_closure_con16(a, c + 0);
		}
		/* mcon16: CNSTC */
		c = range(a,-32767,32768)	/* Small integer constants */;
		if (c + 0 < p->cost[_mcon16_NT]) {
			p->cost[_mcon16_NT] = c + 0;
			p->rule._mcon16 = 1;
		}
		/* lcon16: CNSTC */
		c = range(a,0,65535);
		if (c + 0 < p->cost[_lcon16_NT]) {
			p->cost[_lcon16_NT] = c + 0;
			p->rule._lcon16 = 1;
		}
		/* ucon16: CNSTC */
		c = hibits(a);
		if (c + 0 < p->cost[_ucon16_NT]) {
			p->cost[_ucon16_NT] = c + 0;
			p->rule._ucon16 = 1;
		}
		/* bitrun: CNSTC */
		c = bitrun(a);
		if (c + 0 < p->cost[_bitrun_NT]) {
			p->cost[_bitrun_NT] = c + 0;
			p->rule._bitrun = 1;
		}
		/* con5: CNSTC */
		c = range(a,0,31);
		if (c + 0 < p->cost[_con5_NT]) {
			p->cost[_con5_NT] = c + 0;
			p->rule._con5 = 1;
		}
		/* zero: CNSTC */
		c = range(a,0,0);
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 1;
		}
		break;
	case 20: /* CNSTS */
		/* con: CNSTS */
		c = 0;
		if (c + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = c + 0;
			p->rule._con = 4;
			_closure_con(a, c + 0);
		}
		/* con16: CNSTS */
		c = range(a,-32768,32767);
		if (c + 0 < p->cost[_con16_NT]) {
			p->cost[_con16_NT] = c + 0;
			p->rule._con16 = 2;
			_closure_con16(a, c + 0);
		}
		/* mcon16: CNSTS */
		c = range(a,-32767,32768)	/* Small integer constants */;
		if (c + 0 < p->cost[_mcon16_NT]) {
			p->cost[_mcon16_NT] = c + 0;
			p->rule._mcon16 = 2;
		}
		/* lcon16: CNSTS */
		c = range(a,0,65535);
		if (c + 0 < p->cost[_lcon16_NT]) {
			p->cost[_lcon16_NT] = c + 0;
			p->rule._lcon16 = 2;
		}
		/* ucon16: CNSTS */
		c = hibits(a);
		if (c + 0 < p->cost[_ucon16_NT]) {
			p->cost[_ucon16_NT] = c + 0;
			p->rule._ucon16 = 2;
		}
		/* bitrun: CNSTS */
		c = bitrun(a);
		if (c + 0 < p->cost[_bitrun_NT]) {
			p->cost[_bitrun_NT] = c + 0;
			p->rule._bitrun = 2;
		}
		/* con5: CNSTS */
		c = range(a,0,31);
		if (c + 0 < p->cost[_con5_NT]) {
			p->cost[_con5_NT] = c + 0;
			p->rule._con5 = 2;
		}
		/* zero: CNSTS */
		c = range(a,0,0);
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 4;
		}
		break;
	case 21: /* CNSTI */
		/* con: CNSTI */
		c = 0;
		if (c + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = c + 0;
			p->rule._con = 2;
			_closure_con(a, c + 0);
		}
		/* con16: CNSTI */
		c = range(a,-32768,32767);
		if (c + 0 < p->cost[_con16_NT]) {
			p->cost[_con16_NT] = c + 0;
			p->rule._con16 = 3;
			_closure_con16(a, c + 0);
		}
		/* mcon16: CNSTI */
		c = range(a,-32767,32768)	/* Small integer constants */;
		if (c + 0 < p->cost[_mcon16_NT]) {
			p->cost[_mcon16_NT] = c + 0;
			p->rule._mcon16 = 3;
		}
		/* lcon16: CNSTI */
		c = range(a,0,65535);
		if (c + 0 < p->cost[_lcon16_NT]) {
			p->cost[_lcon16_NT] = c + 0;
			p->rule._lcon16 = 3;
		}
		/* ucon16: CNSTI */
		c = hibits(a);
		if (c + 0 < p->cost[_ucon16_NT]) {
			p->cost[_ucon16_NT] = c + 0;
			p->rule._ucon16 = 3;
		}
		/* bitrun: CNSTI */
		c = bitrun(a);
		if (c + 0 < p->cost[_bitrun_NT]) {
			p->cost[_bitrun_NT] = c + 0;
			p->rule._bitrun = 3;
		}
		/* con5: CNSTI */
		c = range(a,0,31);
		if (c + 0 < p->cost[_con5_NT]) {
			p->cost[_con5_NT] = c + 0;
			p->rule._con5 = 3;
		}
		/* zero: CNSTI */
		c = range(a,0,0);
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 2;
		}
		break;
	case 22: /* CNSTU */
		/* con: CNSTU */
		c = 0;
		if (c + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = c + 0;
			p->rule._con = 5;
			_closure_con(a, c + 0);
		}
		/* con16: CNSTU */
		c = range(a,0,32767);
		if (c + 0 < p->cost[_con16_NT]) {
			p->cost[_con16_NT] = c + 0;
			p->rule._con16 = 4;
			_closure_con16(a, c + 0);
		}
		/* mcon16: CNSTU */
		c = range(a,     0,32768)	/* Small integer constants */;
		if (c + 0 < p->cost[_mcon16_NT]) {
			p->cost[_mcon16_NT] = c + 0;
			p->rule._mcon16 = 4;
		}
		/* lcon16: CNSTU */
		c = range(a,0,65535);
		if (c + 0 < p->cost[_lcon16_NT]) {
			p->cost[_lcon16_NT] = c + 0;
			p->rule._lcon16 = 4;
		}
		/* ucon16: CNSTU */
		c = hibits(a);
		if (c + 0 < p->cost[_ucon16_NT]) {
			p->cost[_ucon16_NT] = c + 0;
			p->rule._ucon16 = 4;
		}
		/* bitrun: CNSTU */
		c = bitrun(a);
		if (c + 0 < p->cost[_bitrun_NT]) {
			p->cost[_bitrun_NT] = c + 0;
			p->rule._bitrun = 4;
		}
		/* con5: CNSTU */
		c = range(a,0,31);
		if (c + 0 < p->cost[_con5_NT]) {
			p->cost[_con5_NT] = c + 0;
			p->rule._con5 = 4;
		}
		/* zero: CNSTU */
		c = range(a,0,0);
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 3;
		}
		break;
	case 23: /* CNSTP */
		/* con: CNSTP */
		c = 0;
		if (c + 0 < p->cost[_con_NT]) {
			p->cost[_con_NT] = c + 0;
			p->rule._con = 3;
			_closure_con(a, c + 0);
		}
		/* con16: CNSTP */
		c = range(a,-32768,32767);
		if (c + 0 < p->cost[_con16_NT]) {
			p->cost[_con16_NT] = c + 0;
			p->rule._con16 = 5;
			_closure_con16(a, c + 0);
		}
		/* mcon16: CNSTP */
		c = range(a,-32767,32768)	/* Small integer constants */;
		if (c + 0 < p->cost[_mcon16_NT]) {
			p->cost[_mcon16_NT] = c + 0;
			p->rule._mcon16 = 5;
		}
		/* lcon16: CNSTP */
		c = range(a,0,65535);
		if (c + 0 < p->cost[_lcon16_NT]) {
			p->cost[_lcon16_NT] = c + 0;
			p->rule._lcon16 = 5;
		}
		/* ucon16: CNSTP */
		c = hibits(a);
		if (c + 0 < p->cost[_ucon16_NT]) {
			p->cost[_ucon16_NT] = c + 0;
			p->rule._ucon16 = 5;
		}
		/* bitrun: CNSTP */
		c = bitrun(a);
		if (c + 0 < p->cost[_bitrun_NT]) {
			p->cost[_bitrun_NT] = c + 0;
			p->rule._bitrun = 5;
		}
		/* zero: CNSTP */
		c = range(a,0,0);
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 5;
		}
		/* ar: CNSTP */
		c = range(a, 0, 0x0fffffff);
		if (c + 0 < p->cost[_ar_NT]) {
			p->cost[_ar_NT] = c + 0;
			p->rule._ar = 2;
		}
		break;
	case 33: /* ARGF */
		_label(LEFT_CHILD(a));
		/* stmt: ARGF(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 = 77;
		}
		break;
	case 34: /* ARGD */
		_label(LEFT_CHILD(a));
		/* stmt: ARGD(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 = 76;
		}
		break;
	case 37: /* ARGI */
		_label(LEFT_CHILD(a));
		/* stmt: ARGI(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 = 78;
		}
		break;
	case 39: /* ARGP */
		_label(LEFT_CHILD(a));
		/* stmt: ARGP(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 = 79;
		}
		break;
	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 = 80;
			}
		}
		break;
	case 49: /* ASGNF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNF(VREGP,reg) */
			LEFT_CHILD(a)->op == 615 /* 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: ASGNF(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 13;
		}
		/* stmt: ASGNF(idx,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 19;
		}
		break;
	case 50: /* ASGND */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGND(VREGP,reg) */
			LEFT_CHILD(a)->op == 615 /* 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: ASGND(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 12;
		}
		/* stmt: ASGND(idx,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 18;
		}
		break;
	case 51: /* ASGNC */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNC(VREGP,reg) */
			LEFT_CHILD(a)->op == 615 /* VREGP */
		) {
			c = ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 1;
			}
		}
		/* stmt: ASGNC(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 8;
		}
		/* stmt: ASGNC(idx,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 14;
		}
		break;
	case 52: /* ASGNS */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNS(VREGP,reg) */
			LEFT_CHILD(a)->op == 615 /* 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: ASGNS(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 9;
		}
		/* stmt: ASGNS(idx,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 15;
		}
		break;
	case 53: /* ASGNI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNI(VREGP,reg) */
			LEFT_CHILD(a)->op == 615 /* 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: ASGNI(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 10;
		}
		/* stmt: ASGNI(idx,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 16;
		}
		break;
	case 55: /* ASGNP */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNP(VREGP,reg) */
			LEFT_CHILD(a)->op == 615 /* 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: ASGNP(addr,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 11;
		}
		/* stmt: ASGNP(idx,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 17;
		}
		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] + 1;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 81;
			}
		}
		break;
	case 65: /* INDIRF */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRF(VREGP) */
			LEFT_CHILD(a)->op == 615 /* 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[_con16_NT] == 0) {
					p->cost[_con16_NT] = 0;
					p->rule._con16 = q->rule._con16;
				}
				if (q->cost[_conhi_NT] == 0) {
					p->cost[_conhi_NT] = 0;
					p->rule._conhi = q->rule._conhi;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_idx_NT] == 0) {
					p->cost[_idx_NT] = 0;
					p->rule._idx = q->rule._idx;
				}
				if (q->cost[_mcon16_NT] == 0) {
					p->cost[_mcon16_NT] = 0;
					p->rule._mcon16 = q->rule._mcon16;
				}
				if (q->cost[_lcon16_NT] == 0) {
					p->cost[_lcon16_NT] = 0;
					p->rule._lcon16 = q->rule._lcon16;
				}
				if (q->cost[_ucon16_NT] == 0) {
					p->cost[_ucon16_NT] = 0;
					p->rule._ucon16 = q->rule._ucon16;
				}
				if (q->cost[_bitrun_NT] == 0) {
					p->cost[_bitrun_NT] = 0;
					p->rule._bitrun = q->rule._bitrun;
				}
				if (q->cost[_and_mask_NT] == 0) {
					p->cost[_and_mask_NT] = 0;
					p->rule._and_mask = q->rule._and_mask;
				}
				if (q->cost[_con5_NT] == 0) {
					p->cost[_con5_NT] = 0;
					p->rule._con5 = q->rule._con5;
				}
				if (q->cost[_zero_NT] == 0) {
					p->cost[_zero_NT] = 0;
					p->rule._zero = q->rule._zero;
				}
				if (q->cost[_ar_NT] == 0) {
					p->cost[_ar_NT] = 0;
					p->rule._ar = q->rule._ar;
				}
			}
			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: INDIRF(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 23;
			_closure_reg(a, c + 0);
		}
		/* reg: INDIRF(idx) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_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 66: /* INDIRD */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRD(VREGP) */
			LEFT_CHILD(a)->op == 615 /* 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[_con16_NT] == 0) {
					p->cost[_con16_NT] = 0;
					p->rule._con16 = q->rule._con16;
				}
				if (q->cost[_conhi_NT] == 0) {
					p->cost[_conhi_NT] = 0;
					p->rule._conhi = q->rule._conhi;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_idx_NT] == 0) {
					p->cost[_idx_NT] = 0;
					p->rule._idx = q->rule._idx;
				}
				if (q->cost[_mcon16_NT] == 0) {
					p->cost[_mcon16_NT] = 0;
					p->rule._mcon16 = q->rule._mcon16;
				}
				if (q->cost[_lcon16_NT] == 0) {
					p->cost[_lcon16_NT] = 0;
					p->rule._lcon16 = q->rule._lcon16;
				}
				if (q->cost[_ucon16_NT] == 0) {
					p->cost[_ucon16_NT] = 0;
					p->rule._ucon16 = q->rule._ucon16;
				}
				if (q->cost[_bitrun_NT] == 0) {
					p->cost[_bitrun_NT] = 0;
					p->rule._bitrun = q->rule._bitrun;
				}
				if (q->cost[_and_mask_NT] == 0) {
					p->cost[_and_mask_NT] = 0;
					p->rule._and_mask = q->rule._and_mask;
				}
				if (q->cost[_con5_NT] == 0) {
					p->cost[_con5_NT] = 0;
					p->rule._con5 = q->rule._con5;
				}
				if (q->cost[_zero_NT] == 0) {
					p->cost[_zero_NT] = 0;
					p->rule._zero = q->rule._zero;
				}
				if (q->cost[_ar_NT] == 0) {
					p->cost[_ar_NT] = 0;
					p->rule._ar = q->rule._ar;
				}
			}
			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: INDIRD(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 22;
			_closure_reg(a, c + 0);
		}
		/* reg: INDIRD(idx) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 28;
			_closure_reg(a, c + 0);
		}
		break;
	case 67: /* INDIRC */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRC(VREGP) */
			LEFT_CHILD(a)->op == 615 /* 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[_con16_NT] == 0) {
					p->cost[_con16_NT] = 0;
					p->rule._con16 = q->rule._con16;
				}
				if (q->cost[_conhi_NT] == 0) {
					p->cost[_conhi_NT] = 0;
					p->rule._conhi = q->rule._conhi;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_idx_NT] == 0) {
					p->cost[_idx_NT] = 0;
					p->rule._idx = q->rule._idx;
				}
				if (q->cost[_mcon16_NT] == 0) {
					p->cost[_mcon16_NT] = 0;
					p->rule._mcon16 = q->rule._mcon16;
				}
				if (q->cost[_lcon16_NT] == 0) {
					p->cost[_lcon16_NT] = 0;
					p->rule._lcon16 = q->rule._lcon16;
				}
				if (q->cost[_ucon16_NT] == 0) {
					p->cost[_ucon16_NT] = 0;
					p->rule._ucon16 = q->rule._ucon16;
				}
				if (q->cost[_bitrun_NT] == 0) {
					p->cost[_bitrun_NT] = 0;
					p->rule._bitrun = q->rule._bitrun;
				}
				if (q->cost[_and_mask_NT] == 0) {
					p->cost[_and_mask_NT] = 0;
					p->rule._and_mask = q->rule._and_mask;
				}
				if (q->cost[_con5_NT] == 0) {
					p->cost[_con5_NT] = 0;
					p->rule._con5 = q->rule._con5;
				}
				if (q->cost[_zero_NT] == 0) {
					p->cost[_zero_NT] = 0;
					p->rule._zero = q->rule._zero;
				}
				if (q->cost[_ar_NT] == 0) {
					p->cost[_ar_NT] = 0;
					p->rule._ar = q->rule._ar;
				}
			}
			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: INDIRC(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 18;
			_closure_reg(a, c + 0);
		}
		/* reg: INDIRC(idx) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 24;
			_closure_reg(a, c + 0);
		}
		break;
	case 68: /* INDIRS */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRS(VREGP) */
			LEFT_CHILD(a)->op == 615 /* 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[_con16_NT] == 0) {
					p->cost[_con16_NT] = 0;
					p->rule._con16 = q->rule._con16;
				}
				if (q->cost[_conhi_NT] == 0) {
					p->cost[_conhi_NT] = 0;
					p->rule._conhi = q->rule._conhi;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_idx_NT] == 0) {
					p->cost[_idx_NT] = 0;
					p->rule._idx = q->rule._idx;
				}
				if (q->cost[_mcon16_NT] == 0) {
					p->cost[_mcon16_NT] = 0;
					p->rule._mcon16 = q->rule._mcon16;
				}
				if (q->cost[_lcon16_NT] == 0) {
					p->cost[_lcon16_NT] = 0;
					p->rule._lcon16 = q->rule._lcon16;
				}
				if (q->cost[_ucon16_NT] == 0) {
					p->cost[_ucon16_NT] = 0;
					p->rule._ucon16 = q->rule._ucon16;
				}
				if (q->cost[_bitrun_NT] == 0) {
					p->cost[_bitrun_NT] = 0;
					p->rule._bitrun = q->rule._bitrun;
				}
				if (q->cost[_and_mask_NT] == 0) {
					p->cost[_and_mask_NT] = 0;
					p->rule._and_mask = q->rule._and_mask;
				}
				if (q->cost[_con5_NT] == 0) {
					p->cost[_con5_NT] = 0;
					p->rule._con5 = q->rule._con5;
				}
				if (q->cost[_zero_NT] == 0) {
					p->cost[_zero_NT] = 0;
					p->rule._zero = q->rule._zero;
				}
				if (q->cost[_ar_NT] == 0) {
					p->cost[_ar_NT] = 0;
					p->rule._ar = q->rule._ar;
				}
			}
			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: INDIRS(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 19;
			_closure_reg(a, c + 0);
		}
		/* reg: INDIRS(idx) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 25;
			_closure_reg(a, c + 0);
		}
		break;
	case 69: /* INDIRI */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRI(VREGP) */
			LEFT_CHILD(a)->op == 615 /* 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[_con16_NT] == 0) {
					p->cost[_con16_NT] = 0;
					p->rule._con16 = q->rule._con16;
				}
				if (q->cost[_conhi_NT] == 0) {
					p->cost[_conhi_NT] = 0;
					p->rule._conhi = q->rule._conhi;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_idx_NT] == 0) {
					p->cost[_idx_NT] = 0;
					p->rule._idx = q->rule._idx;
				}
				if (q->cost[_mcon16_NT] == 0) {
					p->cost[_mcon16_NT] = 0;
					p->rule._mcon16 = q->rule._mcon16;
				}
				if (q->cost[_lcon16_NT] == 0) {
					p->cost[_lcon16_NT] = 0;
					p->rule._lcon16 = q->rule._lcon16;
				}
				if (q->cost[_ucon16_NT] == 0) {
					p->cost[_ucon16_NT] = 0;
					p->rule._ucon16 = q->rule._ucon16;
				}
				if (q->cost[_bitrun_NT] == 0) {
					p->cost[_bitrun_NT] = 0;
					p->rule._bitrun = q->rule._bitrun;
				}
				if (q->cost[_and_mask_NT] == 0) {
					p->cost[_and_mask_NT] = 0;
					p->rule._and_mask = q->rule._and_mask;
				}
				if (q->cost[_con5_NT] == 0) {
					p->cost[_con5_NT] = 0;
					p->rule._con5 = q->rule._con5;
				}
				if (q->cost[_zero_NT] == 0) {
					p->cost[_zero_NT] = 0;
					p->rule._zero = q->rule._zero;
				}
				if (q->cost[_ar_NT] == 0) {
					p->cost[_ar_NT] = 0;
					p->rule._ar = q->rule._ar;
				}
			}
			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: INDIRI(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 20;
			_closure_reg(a, c + 0);
		}
		/* reg: INDIRI(idx) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 26;
			_closure_reg(a, c + 0);
		}
		break;
	case 71: /* INDIRP */
		_label(LEFT_CHILD(a));
		if (	/* reg: INDIRP(VREGP) */
			LEFT_CHILD(a)->op == 615 /* 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[_con16_NT] == 0) {
					p->cost[_con16_NT] = 0;
					p->rule._con16 = q->rule._con16;
				}
				if (q->cost[_conhi_NT] == 0) {
					p->cost[_conhi_NT] = 0;
					p->rule._conhi = q->rule._conhi;
				}
				if (q->cost[_addr_NT] == 0) {
					p->cost[_addr_NT] = 0;
					p->rule._addr = q->rule._addr;
				}
				if (q->cost[_idx_NT] == 0) {
					p->cost[_idx_NT] = 0;
					p->rule._idx = q->rule._idx;
				}
				if (q->cost[_mcon16_NT] == 0) {
					p->cost[_mcon16_NT] = 0;
					p->rule._mcon16 = q->rule._mcon16;
				}
				if (q->cost[_lcon16_NT] == 0) {
					p->cost[_lcon16_NT] = 0;
					p->rule._lcon16 = q->rule._lcon16;
				}
				if (q->cost[_ucon16_NT] == 0) {
					p->cost[_ucon16_NT] = 0;
					p->rule._ucon16 = q->rule._ucon16;
				}
				if (q->cost[_bitrun_NT] == 0) {
					p->cost[_bitrun_NT] = 0;
					p->rule._bitrun = q->rule._bitrun;
				}
				if (q->cost[_and_mask_NT] == 0) {
					p->cost[_and_mask_NT] = 0;
					p->rule._and_mask = q->rule._and_mask;
				}
				if (q->cost[_con5_NT] == 0) {
					p->cost[_con5_NT] = 0;
					p->rule._con5 = q->rule._con5;
				}
				if (q->cost[_zero_NT] == 0) {
					p->cost[_zero_NT] = 0;
					p->rule._zero = q->rule._zero;
				}
				if (q->cost[_ar_NT] == 0) {
					p->cost[_ar_NT] = 0;
					p->rule._ar = q->rule._ar;
				}
			}
			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: INDIRP(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 21;
			_closure_reg(a, c + 0);
		}
		/* reg: INDIRP(idx) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_idx_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 27;
			_closure_reg(a, c + 0);
		}
		break;
	case 73: /* INDIRB */
		_label(LEFT_CHILD(a));
		break;
	case 85: /* CVCI */
		_label(LEFT_CHILD(a));
		/* reg: CVCI(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 = 122;
			_closure_reg(a, c + 0);
		}
		/* reg: CVCI(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 = 123;
			_closure_reg(a, c + 0);
		}
		break;
	case 86: /* CVCU */
		_label(LEFT_CHILD(a));
		if (	/* reg: CVCU(INDIRC(addr)) */
			LEFT_CHILD(a)->op == 67 /* INDIRC */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_addr_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 31;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: CVCU(INDIRC(idx)) */
			LEFT_CHILD(a)->op == 67 /* INDIRC */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_idx_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 34;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: CVCU(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 = 125;
			_closure_reg(a, c + 0);
		}
		break;
	case 97: /* CVDF */
		_label(LEFT_CHILD(a));
		/* reg: CVDF(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 = 127;
			_closure_reg(a, c + 0);
		}
		break;
	case 101: /* CVDI */
		_label(LEFT_CHILD(a));
		/* reg: CVDI(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 3;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 130;
			_closure_reg(a, c + 0);
		}
		break;
	case 114: /* CVFD */
		_label(LEFT_CHILD(a));
		/* reg: CVFD(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 = 128;
			_closure_reg(a, c + 0);
		}
		break;
	case 130: /* CVID */
		_label(LEFT_CHILD(a));
		/* reg: CVID(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 = 129;
			_closure_reg(a, c + 0);
		}
		break;
	case 131: /* CVIC */
		_label(LEFT_CHILD(a));
		/* reg: CVIC(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 = 36;
			_closure_reg(a, c + 0);
		}
		/* reg: CVIC(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 = 44;
			_closure_reg(a, c + 0);
		}
		break;
	case 132: /* CVIS */
		_label(LEFT_CHILD(a));
		/* reg: CVIS(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 = 37;
			_closure_reg(a, c + 0);
		}
		/* reg: CVIS(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 = 45;
			_closure_reg(a, c + 0);
		}
		break;
	case 134: /* CVIU */
		_label(LEFT_CHILD(a));
		/* reg: CVIU(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 = 7;
			_closure_reg(a, c + 0);
		}
		/* reg: CVIU(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 = 38;
			_closure_reg(a, c + 0);
		}
		break;
	case 150: /* CVPU */
		_label(LEFT_CHILD(a));
		/* reg: CVPU(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 = 8;
			_closure_reg(a, c + 0);
		}
		/* reg: CVPU(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 = 39;
			_closure_reg(a, c + 0);
		}
		break;
	case 165: /* CVSI */
		_label(LEFT_CHILD(a));
		if (	/* reg: CVSI(INDIRS(addr)) */
			LEFT_CHILD(a)->op == 68 /* INDIRS */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_addr_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 30;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: CVSI(INDIRS(idx)) */
			LEFT_CHILD(a)->op == 68 /* INDIRS */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_idx_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 33;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: CVSI(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 = 124;
			_closure_reg(a, c + 0);
		}
		break;
	case 166: /* CVSU */
		_label(LEFT_CHILD(a));
		if (	/* reg: CVSU(INDIRS(addr)) */
			LEFT_CHILD(a)->op == 68 /* INDIRS */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_addr_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 32;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: CVSU(INDIRS(idx)) */
			LEFT_CHILD(a)->op == 68 /* INDIRS */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_idx_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 35;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: CVSU(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 = 126;
			_closure_reg(a, c + 0);
		}
		break;
	case 179: /* CVUC */
		_label(LEFT_CHILD(a));
		/* reg: CVUC(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 = 40;
			_closure_reg(a, c + 0);
		}
		/* reg: CVUC(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 = 46;
			_closure_reg(a, c + 0);
		}
		break;
	case 180: /* CVUS */
		_label(LEFT_CHILD(a));
		/* reg: CVUS(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);
		}
		/* reg: CVUS(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 = 47;
			_closure_reg(a, c + 0);
		}
		break;
	case 181: /* CVUI */
		_label(LEFT_CHILD(a));
		/* reg: CVUI(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 = 9;
			_closure_reg(a, c + 0);
		}
		/* reg: CVUI(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 183: /* CVUP */
		_label(LEFT_CHILD(a));
		/* reg: CVUP(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 = 10;
			_closure_reg(a, c + 0);
		}
		/* reg: CVUP(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 193: /* NEGF */
		_label(LEFT_CHILD(a));
		/* reg: NEGF(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 = 121;
			_closure_reg(a, c + 0);
		}
		break;
	case 194: /* NEGD */
		_label(LEFT_CHILD(a));
		/* reg: NEGD(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 = 120;
			_closure_reg(a, c + 0);
		}
		break;
	case 197: /* NEGI */
		_label(LEFT_CHILD(a));
		/* reg: NEGI(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 = 104;
			_closure_reg(a, c + 0);
		}
		break;
	case 209: /* CALLF */
		_label(LEFT_CHILD(a));
		/* reg: CALLF(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 5;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 132;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLF(ar) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ar_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 135;
			_closure_reg(a, c + 0);
		}
		break;
	case 210: /* CALLD */
		_label(LEFT_CHILD(a));
		/* reg: CALLD(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 5;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 131;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLD(ar) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ar_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 134;
			_closure_reg(a, c + 0);
		}
		break;
	case 213: /* CALLI */
		_label(LEFT_CHILD(a));
		/* reg: CALLI(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 5;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 133;
			_closure_reg(a, c + 0);
		}
		/* reg: CALLI(ar) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ar_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 136;
			_closure_reg(a, c + 0);
		}
		break;
	case 216: /* CALLV */
		_label(LEFT_CHILD(a));
		/* stmt: CALLV(reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 5;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 69;
		}
		/* stmt: CALLV(ar) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ar_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 71;
		}
		break;
	case 217: /* CALLB */
		break;
	case 225: /* LOADF */
		_label(LEFT_CHILD(a));
		/* reg: LOADF(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 = 111;
			_closure_reg(a, c + 0);
		}
		break;
	case 226: /* LOADD */
		_label(LEFT_CHILD(a));
		/* reg: LOADD(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 = 110;
			_closure_reg(a, c + 0);
		}
		break;
	case 227: /* LOADC */
		_label(LEFT_CHILD(a));
		/* reg: LOADC(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);
		}
		/* reg: LOADC(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 = 105;
			_closure_reg(a, c + 0);
		}
		break;
	case 228: /* LOADS */
		_label(LEFT_CHILD(a));
		/* reg: LOADS(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 = 51;
			_closure_reg(a, c + 0);
		}
		/* reg: LOADS(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 = 106;
			_closure_reg(a, c + 0);
		}
		break;
	case 229: /* LOADI */
		_label(LEFT_CHILD(a));
		/* reg: LOADI(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);
		}
		/* reg: LOADI(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 = 107;
			_closure_reg(a, c + 0);
		}
		break;
	case 230: /* LOADU */
		_label(LEFT_CHILD(a));
		/* reg: LOADU(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 = 52;
			_closure_reg(a, c + 0);
		}
		/* reg: LOADU(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 = 109;
			_closure_reg(a, c + 0);
		}
		break;
	case 231: /* LOADP */
		_label(LEFT_CHILD(a));
		/* reg: LOADP(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 = 50;
			_closure_reg(a, c + 0);
		}
		/* reg: LOADP(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 = 108;
			_closure_reg(a, c + 0);
		}
		break;
	case 233: /* LOADB */
		break;
	case 241: /* RETF */
		_label(LEFT_CHILD(a));
		/* stmt: RETF(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 = 74;
		}
		break;
	case 242: /* RETD */
		_label(LEFT_CHILD(a));
		/* stmt: RETD(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 = 73;
		}
		break;
	case 245: /* RETI */
		_label(LEFT_CHILD(a));
		/* stmt: RETI(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 = 75;
		}
		break;
	case 263: /* ADDRGP */
		/* reg: ADDRGP */
		c = 2 /* Requires a full load, very expensive */;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 11;
			_closure_reg(a, c + 0);
		}
		/* ar: ADDRGP */
		c = 0;
		if (c + 0 < p->cost[_ar_NT]) {
			p->cost[_ar_NT] = c + 0;
			p->rule._ar = 1;
		}
		break;
	case 279: /* ADDRFP */
		/* reg: ADDRFP */
		c = 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 14;
			_closure_reg(a, c + 0);
		}
		/* addr: ADDRFP */
		c = range(a,-32768+220,32767+220);
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 2;
		}
		/* reg: ADDRFP */
		c = range(a,-32768+220,32767+220);
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 15;
			_closure_reg(a, c + 0);
		}
		break;
	case 295: /* ADDRLP */
		/* reg: ADDRLP */
		c = 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 16;
			_closure_reg(a, c + 0);
		}
		/* addr: ADDRLP */
		c = range(a,-32768,32767);
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 3;
		}
		/* reg: ADDRLP */
		c = range(a,-32768,32767);
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 17;
			_closure_reg(a, c + 0);
		}
		break;
	case 305: /* ADDF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDF(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 = 113;
			_closure_reg(a, c + 0);
		}
		break;
	case 306: /* ADDD */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: ADDD(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 = 112;
			_closure_reg(a, c + 0);
		}
		break;
	case 309: /* ADDI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* addr: ADDI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 5;
		}
		/* idx: ADDI(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_idx_NT]) {
			p->cost[_idx_NT] = c + 0;
			p->rule._idx = 1;
		}
		/* reg: ADDI(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 = 53;
			_closure_reg(a, c + 0);
		}
		/* reg: ADDI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 54;
			_closure_reg(a, c + 0);
		}
		/* reg: ADDI(reg,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 55;
			_closure_reg(a, c + 0);
		}
		break;
	case 310: /* ADDU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* addr: ADDU(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 7;
		}
		/* idx: ADDU(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_idx_NT]) {
			p->cost[_idx_NT] = c + 0;
			p->rule._idx = 2;
		}
		/* reg: ADDU(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 = 58;
			_closure_reg(a, c + 0);
		}
		/* reg: ADDU(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_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 311: /* ADDP */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* addr: ADDP(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 0;
		if (c + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = c + 0;
			p->rule._addr = 6;
		}
		/* idx: ADDP(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
		if (c + 0 < p->cost[_idx_NT]) {
			p->cost[_idx_NT] = c + 0;
			p->rule._idx = 3;
		}
		/* reg: ADDP(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 56;
			_closure_reg(a, c + 0);
		}
		/* reg: ADDP(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 = 57;
			_closure_reg(a, c + 0);
		}
		break;
	case 321: /* SUBF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBF(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 = 119;
			_closure_reg(a, c + 0);
		}
		break;
	case 322: /* SUBD */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBD(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 = 118;
			_closure_reg(a, c + 0);
		}
		break;
	case 325: /* SUBI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBI(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 = 60;
			_closure_reg(a, c + 0);
		}
		/* reg: SUBI(reg,mcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mcon16_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 326: /* SUBU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBU(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 = 64;
			_closure_reg(a, c + 0);
		}
		/* reg: SUBU(reg,mcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mcon16_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 327: /* SUBP */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: SUBP(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 = 62;
			_closure_reg(a, c + 0);
		}
		/* reg: SUBP(reg,mcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_mcon16_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 341: /* LSHI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHI(reg,con5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con5_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 96;
			_closure_reg(a, c + 0);
		}
		/* reg: LSHI(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 = 100;
			_closure_reg(a, c + 0);
		}
		break;
	case 342: /* LSHU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: LSHU(reg,con5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con5_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 97;
			_closure_reg(a, c + 0);
		}
		/* reg: LSHU(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 = 101;
			_closure_reg(a, c + 0);
		}
		break;
	case 357: /* MODI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODI(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 3;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 92;
			_closure_reg(a, c + 0);
		}
		break;
	case 358: /* MODU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MODU(reg,reg) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 3;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 93;
			_closure_reg(a, c + 0);
		}
		break;
	case 373: /* RSHI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHI(reg,con5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con5_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 98;
			_closure_reg(a, c + 0);
		}
		/* reg: RSHI(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 = 102;
			_closure_reg(a, c + 0);
		}
		break;
	case 374: /* RSHU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: RSHU(reg,con5) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con5_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 99;
			_closure_reg(a, c + 0);
		}
		/* reg: RSHU(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 = 103;
			_closure_reg(a, c + 0);
		}
		break;
	case 390: /* BANDU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BANDU(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 = 67;
			_closure_reg(a, c + 0);
		}
		/* reg: BANDU(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 68;
			_closure_reg(a, c + 0);
		}
		/* reg: BANDU(reg,ucon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ucon16_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 69;
			_closure_reg(a, c + 0);
		}
		if (	/* reg: BANDU(reg,BCOMU(reg)) */
			RIGHT_CHILD(a)->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(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 = 70;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: BANDU(BCOMU(reg),reg) */
			LEFT_CHILD(a)->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(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 = 71;
				_closure_reg(a, c + 0);
			}
		}
		/* and_mask: BANDU(reg,bitrun) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_bitrun_NT] + (a->x.argno=RIGHT_CHILD(a)->x.argno,0);
		if (c + 0 < p->cost[_and_mask_NT]) {
			p->cost[_and_mask_NT] = c + 0;
			p->rule._and_mask = 1;
			_closure_and_mask(a, c + 0);
		}
		break;
	case 406: /* BCOMU */
		_label(LEFT_CHILD(a));
		/* reg: BCOMU(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 = 66;
			_closure_reg(a, c + 0);
		}
		if (	/* reg: BCOMU(BANDU(reg,reg)) */
			LEFT_CHILD(a)->op == 390 /* BANDU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 72;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: BCOMU(BANDU(reg,BCOMU(reg))) */
			LEFT_CHILD(a)->op == 390 && /* BANDU */
			RIGHT_CHILD(LEFT_CHILD(a))->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_reg_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 73;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: BCOMU(BANDU(BCOMU(reg),reg)) */
			LEFT_CHILD(a)->op == 390 && /* BANDU */
			LEFT_CHILD(LEFT_CHILD(a))->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + 1;
			if (c + 0 < p->cost[_reg_NT]) {
				p->cost[_reg_NT] = c + 0;
				p->rule._reg = 74;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: BCOMU(BORU(reg,reg)) */
			LEFT_CHILD(a)->op == 422 /* BORU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(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 = 80;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: BCOMU(BORU(reg,BCOMU(reg))) */
			LEFT_CHILD(a)->op == 422 && /* BORU */
			RIGHT_CHILD(LEFT_CHILD(a))->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(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 = 81;
				_closure_reg(a, c + 0);
			}
		}
		if (	/* reg: BCOMU(BORU(BCOMU(reg),reg)) */
			LEFT_CHILD(a)->op == 422 && /* BORU */
			LEFT_CHILD(LEFT_CHILD(a))->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(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 = 82;
				_closure_reg(a, c + 0);
			}
		}
		break;
	case 422: /* BORU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BORU(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);
		}
		/* reg: BORU(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 76;
			_closure_reg(a, c + 0);
		}
		/* reg: BORU(reg,ucon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ucon16_NT] + 1;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 77;
			_closure_reg(a, c + 0);
		}
		if (	/* reg: BORU(reg,BCOMU(reg)) */
			RIGHT_CHILD(a)->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(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);
			}
		}
		if (	/* reg: BORU(BCOMU(reg),reg) */
			LEFT_CHILD(a)->op == 406 /* BCOMU */
		) {
			c = ((struct _state *)(LEFT_CHILD(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 = 79;
				_closure_reg(a, c + 0);
			}
		}
		/* reg: BORU(reg,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 83;
			_closure_reg(a, c + 0);
		}
		/* reg: BORU(and_mask,and_mask) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_and_mask_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_and_mask_NT] + bins(a);
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 89;
			_closure_reg(a, c + 0);
		}
		break;
	case 438: /* BXORU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: BXORU(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);
		}
		/* reg: BXORU(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_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: BXORU(reg,ucon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ucon16_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: BXORU(reg,con) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con_NT] + 2;
		if (c + 0 < p->cost[_reg_NT]) {
			p->cost[_reg_NT] = c + 0;
			p->rule._reg = 87;
			_closure_reg(a, c + 0);
		}
		break;
	case 449: /* DIVF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVF(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 = 115;
			_closure_reg(a, c + 0);
		}
		break;
	case 450: /* DIVD */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVD(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 = 114;
			_closure_reg(a, c + 0);
		}
		break;
	case 453: /* DIVI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVI(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 = 90;
			_closure_reg(a, c + 0);
		}
		break;
	case 454: /* DIVU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: DIVU(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 = 91;
			_closure_reg(a, c + 0);
		}
		break;
	case 465: /* MULF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULF(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 = 117;
			_closure_reg(a, c + 0);
		}
		break;
	case 466: /* MULD */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULD(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 = 116;
			_closure_reg(a, c + 0);
		}
		break;
	case 469: /* MULI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULI(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 = 94;
			_closure_reg(a, c + 0);
		}
		break;
	case 470: /* MULU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* reg: MULU(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 = 95;
			_closure_reg(a, c + 0);
		}
		break;
	case 481: /* EQF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQF(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 = 57;
		}
		break;
	case 482: /* EQD */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQD(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 = 56;
		}
		break;
	case 485: /* EQI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQI(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 = 20;
		}
		/* stmt: EQI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 21;
		}
		/* stmt: EQI(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 22;
		}
		if (	/* stmt: EQI(BANDU(reg,lcon16),zero) */
			LEFT_CHILD(a)->op == 390 /* BANDU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_lcon16_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 42;
			}
		}
		if (	/* stmt: EQI(CVUI(BANDU(reg,lcon16)),zero) */
			LEFT_CHILD(a)->op == 181 && /* CVUI */
			LEFT_CHILD(LEFT_CHILD(a))->op == 390 /* BANDU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_lcon16_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 44;
			}
		}
		if (	/* stmt: EQI(CVCU(reg),zero) */
			LEFT_CHILD(a)->op == 86 /* CVCU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 46;
			}
		}
		if (	/* stmt: EQI(CVUI(CVCU(reg)),zero) */
			LEFT_CHILD(a)->op == 181 && /* CVUI */
			LEFT_CHILD(LEFT_CHILD(a))->op == 86 /* CVCU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 48;
			}
		}
		if (	/* stmt: EQI(ADDI(reg,reg),zero) */
			LEFT_CHILD(a)->op == 309 /* ADDI */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 50;
			}
		}
		break;
	case 497: /* GEF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEF(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 = 63;
		}
		break;
	case 498: /* GED */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GED(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 = 62;
		}
		break;
	case 501: /* GEI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEI(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 = 23;
		}
		/* stmt: GEI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 24;
		}
		if (	/* stmt: GEI(ADDI(reg,reg),zero) */
			LEFT_CHILD(a)->op == 309 /* ADDI */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 51;
			}
		}
		break;
	case 502: /* GEU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEU(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 = 25;
		}
		/* stmt: GEU(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 26;
		}
		break;
	case 513: /* GTF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTF(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 = 65;
		}
		break;
	case 514: /* GTD */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTD(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 = 64;
		}
		break;
	case 517: /* GTI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTI(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 = 27;
		}
		/* stmt: GTI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 28;
		}
		if (	/* stmt: GTI(ADDI(reg,reg),zero) */
			LEFT_CHILD(a)->op == 309 /* ADDI */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 52;
			}
		}
		break;
	case 518: /* GTU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTU(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 = 29;
		}
		/* stmt: GTU(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 30;
		}
		break;
	case 529: /* LEF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEF(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 = 59;
		}
		break;
	case 530: /* LED */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LED(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 = 58;
		}
		break;
	case 533: /* LEI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEI(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 = 31;
		}
		/* stmt: LEI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 32;
		}
		if (	/* stmt: LEI(ADDI(reg,reg),zero) */
			LEFT_CHILD(a)->op == 309 /* ADDI */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 53;
			}
		}
		break;
	case 534: /* LEU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEU(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 = 33;
		}
		/* stmt: LEU(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 34;
		}
		break;
	case 545: /* LTF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTF(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 = 61;
		}
		break;
	case 546: /* LTD */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTD(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 = 60;
		}
		break;
	case 549: /* LTI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTI(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 = 35;
		}
		/* stmt: LTI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 36;
		}
		if (	/* stmt: LTI(ADDI(reg,reg),zero) */
			LEFT_CHILD(a)->op == 309 /* ADDI */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 54;
			}
		}
		break;
	case 550: /* LTU */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTU(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;
		}
		/* stmt: LTU(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 38;
		}
		break;
	case 561: /* NEF */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEF(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 = 67;
		}
		break;
	case 562: /* NED */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NED(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 = 66;
		}
		break;
	case 565: /* NEI */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEI(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;
		}
		/* stmt: NEI(reg,con16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 40;
		}
		/* stmt: NEI(reg,lcon16) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_lcon16_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 41;
		}
		if (	/* stmt: NEI(BANDU(reg,lcon16),zero) */
			LEFT_CHILD(a)->op == 390 /* BANDU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_lcon16_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 43;
			}
		}
		if (	/* stmt: NEI(CVUI(BANDU(reg,lcon16)),zero) */
			LEFT_CHILD(a)->op == 181 && /* CVUI */
			LEFT_CHILD(LEFT_CHILD(a))->op == 390 /* BANDU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_lcon16_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 45;
			}
		}
		if (	/* stmt: NEI(CVCU(reg),zero) */
			LEFT_CHILD(a)->op == 86 /* CVCU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 47;
			}
		}
		if (	/* stmt: NEI(CVUI(CVCU(reg)),zero) */
			LEFT_CHILD(a)->op == 181 && /* CVUI */
			LEFT_CHILD(LEFT_CHILD(a))->op == 86 /* CVCU */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(a)))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 49;
			}
		}
		if (	/* stmt: NEI(ADDI(reg,reg),zero) */
			LEFT_CHILD(a)->op == 309 /* ADDI */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 55;
			}
		}
		break;
	case 584: /* JUMPV */
		_label(LEFT_CHILD(a));
		/* stmt: JUMPV(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 = 68;
		}
		/* stmt: JUMPV(ar) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_ar_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 70;
		}
		break;
	case 600: /* LABELV */
		/* stmt: LABELV */
		c = 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 72;
		}
		break;
	case 615: /* VREGP */
		break;
	default:
		fatal("_label", "Bad terminal %d\n", OP_LABEL(a));
	}
}

static void _kids(p, eruleno, kids) NODEPTR_TYPE p, kids[]; int eruleno; {
	if (!p)
		fatal("_kids", "Null tree\n", 0);
	if (!kids)
		fatal("_kids", "Null kids\n", 0);
	switch (eruleno) {
	case 262: /* stmt: LABELV */
	case 256: /* ar: CNSTP */
	case 255: /* ar: ADDRGP */
	case 223: /* zero: CNSTP */
	case 222: /* zero: CNSTS */
	case 221: /* zero: CNSTU */
	case 220: /* zero: CNSTI */
	case 219: /* zero: CNSTC */
	case 161: /* con5: CNSTU */
	case 160: /* con5: CNSTI */
	case 159: /* con5: CNSTS */
	case 158: /* con5: CNSTC */
	case 148: /* bitrun: CNSTP */
	case 147: /* bitrun: CNSTU */
	case 146: /* bitrun: CNSTI */
	case 145: /* bitrun: CNSTS */
	case 144: /* bitrun: CNSTC */
	case 121: /* ucon16: CNSTP */
	case 120: /* ucon16: CNSTU */
	case 119: /* ucon16: CNSTI */
	case 118: /* ucon16: CNSTS */
	case 117: /* ucon16: CNSTC */
	case 116: /* lcon16: CNSTP */
	case 115: /* lcon16: CNSTU */
	case 114: /* lcon16: CNSTI */
	case 113: /* lcon16: CNSTS */
	case 112: /* lcon16: CNSTC */
	case 105: /* mcon16: CNSTP */
	case 104: /* mcon16: CNSTU */
	case 103: /* mcon16: CNSTI */
	case 102: /* mcon16: CNSTS */
	case 101: /* mcon16: CNSTC */
	case 38: /* reg: ADDRLP */
	case 37: /* addr: ADDRLP */
	case 36: /* reg: ADDRLP */
	case 35: /* reg: ADDRFP */
	case 34: /* addr: ADDRFP */
	case 33: /* reg: ADDRFP */
	case 28: /* con16: CNSTP */
	case 27: /* con16: CNSTU */
	case 26: /* con16: CNSTI */
	case 25: /* con16: CNSTS */
	case 24: /* con16: CNSTC */
	case 23: /* reg: ADDRGP */
	case 17: /* con: CNSTU */
	case 16: /* con: CNSTS */
	case 15: /* con: CNSTP */
	case 14: /* con: CNSTI */
	case 13: /* con: CNSTC */
	case 6: /* reg: INDIRS(VREGP) */
	case 5: /* reg: INDIRP(VREGP) */
	case 4: /* reg: INDIRI(VREGP) */
	case 3: /* reg: INDIRF(VREGP) */
	case 2: /* reg: INDIRD(VREGP) */
	case 1: /* reg: INDIRC(VREGP) */
		break;
	case 12: /* stmt: ASGNS(VREGP,reg) */
	case 11: /* stmt: ASGNP(VREGP,reg) */
	case 10: /* stmt: ASGNI(VREGP,reg) */
	case 9: /* stmt: ASGNF(VREGP,reg) */
	case 8: /* stmt: ASGND(VREGP,reg) */
	case 7: /* stmt: ASGNC(VREGP,reg) */
		kids[0] = RIGHT_CHILD(p);
		break;
	case 150: /* reg: and_mask */
	case 43: /* addr: reg */
	case 39: /* addr: con16 */
	case 32: /* addr: conhi */
	case 31: /* conhi: con */
	case 30: /* reg: con */
	case 29: /* reg: con16 */
	case 18: /* stmt: reg */
		kids[0] = p;
		break;
	case 269: /* stmt: ARGP(reg) */
	case 268: /* stmt: ARGI(reg) */
	case 267: /* stmt: ARGF(reg) */
	case 266: /* stmt: ARGD(reg) */
	case 265: /* stmt: RETI(reg) */
	case 264: /* stmt: RETF(reg) */
	case 263: /* stmt: RETD(reg) */
	case 261: /* stmt: CALLV(ar) */
	case 260: /* reg: CALLI(ar) */
	case 259: /* reg: CALLF(ar) */
	case 258: /* reg: CALLD(ar) */
	case 257: /* stmt: JUMPV(ar) */
	case 254: /* stmt: CALLV(reg) */
	case 253: /* reg: CALLI(reg) */
	case 252: /* reg: CALLF(reg) */
	case 251: /* reg: CALLD(reg) */
	case 250: /* stmt: JUMPV(reg) */
	case 196: /* reg: CVDI(reg) */
	case 195: /* reg: CVID(reg) */
	case 194: /* reg: CVFD(reg) */
	case 193: /* reg: CVDF(reg) */
	case 192: /* reg: CVSU(reg) */
	case 191: /* reg: CVCU(reg) */
	case 190: /* reg: CVSI(reg) */
	case 189: /* reg: CVCI(reg) */
	case 188: /* reg: CVCI(reg) */
	case 187: /* reg: NEGF(reg) */
	case 186: /* reg: NEGD(reg) */
	case 177: /* reg: LOADF(reg) */
	case 176: /* reg: LOADD(reg) */
	case 175: /* reg: LOADU(reg) */
	case 174: /* reg: LOADP(reg) */
	case 173: /* reg: LOADI(reg) */
	case 172: /* reg: LOADS(reg) */
	case 171: /* reg: LOADC(reg) */
	case 170: /* reg: NEGI(reg) */
	case 122: /* reg: BCOMU(reg) */
	case 93: /* reg: LOADU(reg) */
	case 92: /* reg: LOADS(reg) */
	case 91: /* reg: LOADP(reg) */
	case 90: /* reg: LOADI(reg) */
	case 89: /* reg: LOADC(reg) */
	case 88: /* reg: CVUS(reg) */
	case 87: /* reg: CVUC(reg) */
	case 86: /* reg: CVIS(reg) */
	case 85: /* reg: CVIC(reg) */
	case 84: /* reg: CVUS(reg) */
	case 83: /* reg: CVUP(reg) */
	case 82: /* reg: CVUI(reg) */
	case 81: /* reg: CVUC(reg) */
	case 80: /* reg: CVPU(reg) */
	case 79: /* reg: CVIU(reg) */
	case 78: /* reg: CVIS(reg) */
	case 77: /* reg: CVIC(reg) */
	case 70: /* reg: INDIRF(idx) */
	case 69: /* reg: INDIRD(idx) */
	case 68: /* reg: INDIRP(idx) */
	case 67: /* reg: INDIRI(idx) */
	case 66: /* reg: INDIRS(idx) */
	case 65: /* reg: INDIRC(idx) */
	case 64: /* reg: INDIRF(addr) */
	case 63: /* reg: INDIRD(addr) */
	case 62: /* reg: INDIRP(addr) */
	case 61: /* reg: INDIRI(addr) */
	case 60: /* reg: INDIRS(addr) */
	case 59: /* reg: INDIRC(addr) */
	case 22: /* reg: CVUP(reg) */
	case 21: /* reg: CVUI(reg) */
	case 20: /* reg: CVPU(reg) */
	case 19: /* reg: CVIU(reg) */
		kids[0] = LEFT_CHILD(p);
		break;
	case 249: /* stmt: NEF(reg,reg) */
	case 248: /* stmt: NED(reg,reg) */
	case 247: /* stmt: GTF(reg,reg) */
	case 246: /* stmt: GTD(reg,reg) */
	case 245: /* stmt: GEF(reg,reg) */
	case 244: /* stmt: GED(reg,reg) */
	case 243: /* stmt: LTF(reg,reg) */
	case 242: /* stmt: LTD(reg,reg) */
	case 241: /* stmt: LEF(reg,reg) */
	case 240: /* stmt: LED(reg,reg) */
	case 239: /* stmt: EQF(reg,reg) */
	case 238: /* stmt: EQD(reg,reg) */
	case 218: /* stmt: NEI(reg,lcon16) */
	case 217: /* stmt: NEI(reg,con16) */
	case 216: /* stmt: NEI(reg,reg) */
	case 215: /* stmt: LTU(reg,lcon16) */
	case 214: /* stmt: LTU(reg,reg) */
	case 213: /* stmt: LTI(reg,con16) */
	case 212: /* stmt: LTI(reg,reg) */
	case 211: /* stmt: LEU(reg,lcon16) */
	case 210: /* stmt: LEU(reg,reg) */
	case 209: /* stmt: LEI(reg,con16) */
	case 208: /* stmt: LEI(reg,reg) */
	case 207: /* stmt: GTU(reg,lcon16) */
	case 206: /* stmt: GTU(reg,reg) */
	case 205: /* stmt: GTI(reg,con16) */
	case 204: /* stmt: GTI(reg,reg) */
	case 203: /* stmt: GEU(reg,lcon16) */
	case 202: /* stmt: GEU(reg,reg) */
	case 201: /* stmt: GEI(reg,con16) */
	case 200: /* stmt: GEI(reg,reg) */
	case 199: /* stmt: EQI(reg,lcon16) */
	case 198: /* stmt: EQI(reg,con16) */
	case 197: /* stmt: EQI(reg,reg) */
	case 185: /* reg: SUBF(reg,reg) */
	case 184: /* reg: SUBD(reg,reg) */
	case 183: /* reg: MULF(reg,reg) */
	case 182: /* reg: MULD(reg,reg) */
	case 181: /* reg: DIVF(reg,reg) */
	case 180: /* reg: DIVD(reg,reg) */
	case 179: /* reg: ADDF(reg,reg) */
	case 178: /* reg: ADDD(reg,reg) */
	case 169: /* reg: RSHU(reg,reg) */
	case 168: /* reg: RSHI(reg,reg) */
	case 167: /* reg: LSHU(reg,reg) */
	case 166: /* reg: LSHI(reg,reg) */
	case 165: /* reg: RSHU(reg,con5) */
	case 164: /* reg: RSHI(reg,con5) */
	case 163: /* reg: LSHU(reg,con5) */
	case 162: /* reg: LSHI(reg,con5) */
	case 157: /* reg: MULU(reg,reg) */
	case 156: /* reg: MULI(reg,reg) */
	case 155: /* reg: MODU(reg,reg) */
	case 154: /* reg: MODI(reg,reg) */
	case 153: /* reg: DIVU(reg,reg) */
	case 152: /* reg: DIVI(reg,reg) */
	case 151: /* reg: BORU(and_mask,and_mask) */
	case 149: /* and_mask: BANDU(reg,bitrun) */
	case 143: /* reg: BXORU(reg,con) */
	case 142: /* reg: BXORU(reg,ucon16) */
	case 141: /* reg: BXORU(reg,lcon16) */
	case 140: /* reg: BXORU(reg,reg) */
	case 139: /* reg: BORU(reg,con) */
	case 133: /* reg: BORU(reg,ucon16) */
	case 132: /* reg: BORU(reg,lcon16) */
	case 131: /* reg: BORU(reg,reg) */
	case 125: /* reg: BANDU(reg,ucon16) */
	case 124: /* reg: BANDU(reg,lcon16) */
	case 123: /* reg: BANDU(reg,reg) */
	case 111: /* reg: SUBU(reg,mcon16) */
	case 110: /* reg: SUBU(reg,reg) */
	case 109: /* reg: SUBP(reg,mcon16) */
	case 108: /* reg: SUBP(reg,reg) */
	case 107: /* reg: SUBI(reg,mcon16) */
	case 106: /* reg: SUBI(reg,reg) */
	case 100: /* reg: ADDU(reg,con16) */
	case 99: /* reg: ADDU(reg,reg) */
	case 98: /* reg: ADDP(reg,reg) */
	case 97: /* reg: ADDP(reg,con16) */
	case 96: /* reg: ADDI(reg,con) */
	case 95: /* reg: ADDI(reg,con16) */
	case 94: /* reg: ADDI(reg,reg) */
	case 58: /* stmt: ASGNF(idx,reg) */
	case 57: /* stmt: ASGND(idx,reg) */
	case 56: /* stmt: ASGNP(idx,reg) */
	case 55: /* stmt: ASGNI(idx,reg) */
	case 54: /* stmt: ASGNS(idx,reg) */
	case 53: /* stmt: ASGNC(idx,reg) */
	case 52: /* stmt: ASGNF(addr,reg) */
	case 51: /* stmt: ASGND(addr,reg) */
	case 50: /* stmt: ASGNP(addr,reg) */
	case 49: /* stmt: ASGNI(addr,reg) */
	case 48: /* stmt: ASGNS(addr,reg) */
	case 47: /* stmt: ASGNC(addr,reg) */
	case 46: /* idx: ADDP(reg,reg) */
	case 45: /* idx: ADDU(reg,reg) */
	case 44: /* idx: ADDI(reg,reg) */
	case 42: /* addr: ADDU(reg,con16) */
	case 41: /* addr: ADDP(reg,con16) */
	case 40: /* addr: ADDI(reg,con16) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = RIGHT_CHILD(p);
		break;
	case 270: /* stmt: ARGB(INDIRB(reg)) */
	case 76: /* reg: CVSU(INDIRS(idx)) */
	case 75: /* reg: CVCU(INDIRC(idx)) */
	case 74: /* reg: CVSI(INDIRS(idx)) */
	case 73: /* reg: CVSU(INDIRS(addr)) */
	case 72: /* reg: CVCU(INDIRC(addr)) */
	case 71: /* reg: CVSI(INDIRS(addr)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		break;
	case 271: /* stmt: ASGNB(reg,INDIRB(reg)) */
	case 134: /* reg: BORU(reg,BCOMU(reg)) */
	case 126: /* reg: BANDU(reg,BCOMU(reg)) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = LEFT_CHILD(RIGHT_CHILD(p));
		break;
	case 229: /* stmt: NEI(CVCU(reg),zero) */
	case 228: /* stmt: EQI(CVCU(reg),zero) */
	case 135: /* reg: BORU(BCOMU(reg),reg) */
	case 127: /* reg: BANDU(BCOMU(reg),reg) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		kids[1] = RIGHT_CHILD(p);
		break;
	case 136: /* reg: BCOMU(BORU(reg,reg)) */
	case 128: /* reg: BCOMU(BANDU(reg,reg)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		kids[1] = RIGHT_CHILD(LEFT_CHILD(p));
		break;
	case 137: /* reg: BCOMU(BORU(reg,BCOMU(reg))) */
	case 129: /* reg: BCOMU(BANDU(reg,BCOMU(reg))) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		kids[1] = LEFT_CHILD(RIGHT_CHILD(LEFT_CHILD(p)));
		break;
	case 138: /* reg: BCOMU(BORU(BCOMU(reg),reg)) */
	case 130: /* reg: BCOMU(BANDU(BCOMU(reg),reg)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(p)));
		kids[1] = RIGHT_CHILD(LEFT_CHILD(p));
		break;
	case 237: /* stmt: NEI(ADDI(reg,reg),zero) */
	case 236: /* stmt: LTI(ADDI(reg,reg),zero) */
	case 235: /* stmt: LEI(ADDI(reg,reg),zero) */
	case 234: /* stmt: GTI(ADDI(reg,reg),zero) */
	case 233: /* stmt: GEI(ADDI(reg,reg),zero) */
	case 232: /* stmt: EQI(ADDI(reg,reg),zero) */
	case 225: /* stmt: NEI(BANDU(reg,lcon16),zero) */
	case 224: /* stmt: EQI(BANDU(reg,lcon16),zero) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		kids[1] = RIGHT_CHILD(LEFT_CHILD(p));
		kids[2] = RIGHT_CHILD(p);
		break;
	case 227: /* stmt: NEI(CVUI(BANDU(reg,lcon16)),zero) */
	case 226: /* stmt: EQI(CVUI(BANDU(reg,lcon16)),zero) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(p)));
		kids[1] = RIGHT_CHILD(LEFT_CHILD(LEFT_CHILD(p)));
		kids[2] = RIGHT_CHILD(p);
		break;
	case 231: /* stmt: NEI(CVUI(CVCU(reg)),zero) */
	case 230: /* stmt: EQI(CVUI(CVCU(reg)),zero) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(LEFT_CHILD(p)));
		kids[1] = RIGHT_CHILD(p);
		break;
	default:
		fatal("_kids", "Bad rule number %d\n", eruleno);
	}
}


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

  {
    union {
      char c;
      int i;
    } u;
    u.i = 0;
    u.c = 1;
    swap = (u.i == 1) != IR->little_endian;
  }
  parseflags(argc, argv);
  for (i = 0; i < argc; i++) {
    if (strncmp(argv[i], "-G", 2) == 0)
      gnum = atoi(argv[i] + 2);
    if( strcmp(argv[i], "-S") == 0 )
      pretty_print = 1;
  }
  for (i = 0; i < 32; i ++)
    freg2[i] = mkreg("%d", i, 1, FREG);
  for (i = 0; i < 32; i++)
    ireg[i] = mkreg("%d", i, 1, IREG);
  ireg[1]->x.name = "SP";
  rmap[C] = rmap[S] = rmap[P] = rmap[B] = rmap[U] = rmap[I] =
    mkwildcard(ireg);
  rmap[F] = rmap[D] = mkwildcard(freg2);
  tmask[IREG] = INTTMP; tmask[FREG] = FLTTMP;
  vmask[IREG] = INTVAR; vmask[FREG] = FLTVAR;

  /* Dump out some ".set"s so that the assembly looks more readable */
  print("\
.set r0,0;   .set SP,1;   .set r1,1;   .set RTOC,2; .set r2,2;   .set r3,3\n\
.set r4,4;   .set r5,5;   .set r6,6;   .set r7,7;   .set r8,8;   .set r9,9\n\
.set r10,10; .set r11,11; .set r12,12; .set r13,13; .set r14,14; .set r15,15\n\
.set r16,16; .set r17,17; .set r18,18; .set r19,19; .set r20,20; .set r21,21\n\
.set r22,22; .set r23,23; .set r24,24; .set r25,25; .set r26,26; .set r27,27\n\
.set r28,28; .set r29,29; .set r30,30; .set r31,31\n\
.set f0,0;   .set f1,1;   .set f2,2;   .set f3,3;   .set f4,4;   .set f5,5\n\
.set f6,6;   .set f7,7;   .set f8,8;   .set f9,9;   .set f10,10; .set f11,11\n\
.set f12,12; .set f13,13; .set f14,14; .set f15,15; .set f16,16; .set f17,17\n\
.set f18,18; .set f19,19; .set f20,20; .set f21,21; .set f22,22; .set f23,23\n\
.set f24,24; .set f25,25; .set f26,26; .set f27,27; .set f28,28; .set f29,29\n\
.set f30,30; .set f31,31; .set FP,31\n\
.set CR0,0; .set MQ,0; .set XER,1; .set LR,8; .set CTR,9\n\
");

}

static int cvid_hack = 0;
static void progend()
{
  /* Convert INT to DOUBLE needs a special constant */
  if( cvid_hack ) {
    swtoseg(TOC_SEG);
    print("_toc_.i2d:\t.tc\tFD.433000008000000[tc],0x43300000,0x80000000\n");
  }
}

/*---------------------------------------------------------------------------*/
static void comment VARARGS(( char *fmt, ... ),
			    (fmt, va_alist),char *fmt; va_dcl)
{
  if( !pretty_print ) *bp++ = '\n';
  else {
    va_list ap;
    va_init(ap, fmt);
    vprint(fmt, ap);
    va_end(ap);
  }
}

/*---------------------------------------------------------------------------*/
static void target(Node p)
{
  assert(p);
  switch (p->op) {
  case CALLD: 
  case CALLF:  
    setreg(p, freg2[1]);      
    break;
  case CALLI:
  case CALLV:
    setreg(p, ireg[3]);
    break;
  case RETD: 
  case RETF:    
    rtarget(p, 0, freg2[1]);  
    p->kids[0]->x.registered=1;
    break;
  case RETI: 
    rtarget(p, 0, ireg[3]);  
    p->kids[0]->x.registered=1;
    break;
  case ARGI: case ARGP: 
    /* If the argument lands in the first 24 bytes of the argument area, then
       it can go in a register and it's not actually stored in the arg area. */
    if( p->syms[2]->u.c.v.i < 32 ) /* If arg falls in first 8 words */
      rtarget(p, 0, ireg[3+(p->syms[2]->u.c.v.i>>2)]);
    break;
  case ARGD: case ARGF: 
    /* The first 13 float values are passed in registers f1-f13 in all cases.
       Anything past 8 words also goes in the arg area.  Sometimes things less
       than 8 words also go in the GPRs! */
    if( p->x.argno < 13 ) 
      rtarget(p, 0, freg2[1+p->x.argno]);
    break;
  }
}

/*---------------------------------------------------------------------------*/
static void clobber(Node p) 
{
  assert(p);
  switch (p->op) {
  case CALLD: case CALLF:
    spill(0x00001ff9, IREG, p);	/* Spill volatile+int return regs */
    spill(0x00003fe1, FREG, p); /* Spill volatile regs */
    break;
  case CALLI:
    spill(0x00001fe1, IREG, p);	/* Spill volatile regs */
    spill(0x00003fff, FREG, p); /* Spill volatile+float return regs */
    break;
  case CALLV:
    spill(0x00001ff9, IREG, p);	/* Spill volatile+int return regs */
    spill(0x00003fff, FREG, p); /* Spill volatile+float return regs */
    break;
  case CVID:
    spill(0x00000001, IREG, p); /* Ugly code needs gpr0 */
    spill(0x00000001, FREG, p); /* Ugly code needs fpr0 */
    break;
  case CVDI:
    spill(0x00000001, FREG, p); /* Ugly code needs fpr0 */
    break;
  }
}

/*---------------------------------------------------------------------------*/
/* Return true if ARGument node P is being passed to a function with no
   prototype, or a variadic function. */
static int is_varargs_called(Node p)
{
  Type ty;
  while( generic(p->op) != CALL ) p = p->x.next;
  ty = p->kids[0]->syms[0]->type;
  return ty->u.f.oldstyle || variadic(ty);
}

/*---------------------------------------------------------------------------*/
static void emit2(Node p)
{
  switch (p->op) {
    /* PPC passing conventions.  Yuch.
       If any value is beyond 8 words, it must be stored to the argument area.
       Any value before 8 words is _never_ stored to the arg area.  These early
       parameters are targeted into registers by target() above.  Early floats
       and doubles with no prototype or a varargs prototype are ALSO passed in
       the integer registers! */
  case ARGI: case ARGP: {
    int offset = p->syms[2]->u.c.v.i;
    if( offset >= 32 ) {	/* Must go to argument save area? */
      print("\tstw \tr%d,24+%d(SP)", getregnum(p->x.kids[0]), offset);
      comment("\t\t# Save arg\n");
    } else			/* Nope, its been register targeted */
      comment("\t# argument in r%d\n", 3+(offset>>2));
    break;
  }
  case ARGD: {
    int offset = p->syms[2]->u.c.v.i;
    if( offset >= 32 ) {	/* Must go to argument save area? */
      if( p->x.argno < 13 ) 	/* Register targeted? */
	print("\tstfd \tf%d,24+%d(SP)", 1+p->x.argno,offset);
      else			/* Not register targeted */
	print("\tstfd \tf%d,24+%d(SP)", getregnum(p->x.kids[0]),offset);
      comment("\t\t# Save arg\n");
    } else {
      comment("\t# argument in f%d\n",1+p->x.argno);
      if(is_varargs_called(p)) {
	print("\tstfd \tf%d,-8(SP)",1+p->x.argno);
	comment("\t\t# Also passed in GPRs\n");
	print("\tlwz \tr%d,-8(SP)\n", 3+(offset>>2)  );
	print("\tlwz \tr%d,-4(SP)\n", 3+(offset>>2)+1);
      }
    }
    break;
  }
  case ARGF: {
    int offset = p->syms[2]->u.c.v.i;
    if( offset >= 32 ) {	/* Must go to argument save area? */
      if( p->x.argno < 13 )	/* Register targeted? */
	print("\tstfs \tf%d,24+%d(SP)",1+p->x.argno,offset);
      else			/* Not register targeted */
	print("\tstfs \tf%d,24+%d(SP)",
	      getregnum(p->x.kids[0]),offset);
      comment("\t# Save arg\n");
    } else {
      comment("\t# argument in f%d\n",1+p->x.argno);
      if(is_varargs_called(p)) {
	print("\tstfs \tf%d,-4(SP)", 1+p->x.argno);
	comment("\t\t# Also passed in GPRs\n");
	print("\tlwz \tr%d,-4(SP)\n", 3+(offset>>2));
      }
    }
    break;
  }
  case ARGB: {
    int offset = p->syms[2]->u.c.v.i;
    int size = roundup(p->syms[0]->u.c.v.i,4);
    int start = 0;
    int src = getregnum(p->x.kids[0]);
    while( offset < 32 && size ) {
      print("\tlwz \tr%d,%d(r%d)\n", 3+(offset>>2), start, src);
      start += 4;
      offset += 4;
      size -= 4;
    }
    if( size ) {
      /* Block copy the rest to the stack frame */
      dalign = 4;
      salign = p->syms[1]->u.c.v.i;
      blkcopy(1/* Stack pointer*/, 24+offset, src, start, size, tmpregs);
    }
    break;
  }

  case ASGNB:
    dalign = salign = p->syms[1]->u.c.v.i;
    blkcopy(getregnum(p->x.kids[0]), 0,
	    getregnum(p->x.kids[1]), 0,
	    p->syms[0]->u.c.v.i, tmpregs);
    break;
  case ADDRGP: {
    /* TOC handling done here.  There's a load required, and an optional off */
    Symbol s = p->syms[0];
    int reg = getregnum(p);
    int off = s->x.offset;
    s->addressed = 1;		/* It's addressed */
    print("\tlwz \tr%d,_toc_%s(RTOC)", reg, s->x.name);
    comment("\t# Load address of %s\n", s->x.name);
    if( off ) {
      if( off < 32768 ) {		/* Small offset? */
	print("\taddi \tr%d,r%d,%d", reg, reg, off );
	comment("\t\t# Offset from global\n");
      } else {			/* Humungous offset */
	print("\taddis \tr%d,r%d,(%d-((%d<16)>16))>16\n", reg, reg, off, off);
	print("\taddi \tr%d,r%d,(%d<16)>16", reg, reg, off);
	comment("\t# Big offset %d\n", off);
      }
    }
    break;
  }
  case CVID: {
    int src = getregnum(p->x.kids[0]);
    int dst = getregnum(p);
    /* Clobber above saves us fpr0 for our use */
    assert( dst != 0 );
    cvid_hack = 1;		/* We had a CVID, we need the constant */
    print("\txoris \tr0,r%d,0x8000", src);
    comment("\t\t# Flip sign bit\n");
    print("\tstw   \tr0,-4(SP)");
    comment("\t\t# Store in stack scratch\n");
    print("\taddis \tr0,r0,0x4330");
    comment("\t\t# Exponent bits\n");
    print("\tstw   \tr0,-8(SP)");
    comment("\t\t# Store in stack scratch\n");
    print("\tlfd   \tf%d,_toc_.i2d(RTOC)",dst);
    comment("\t# Load majik constant\n");
    print("\tlfd   \tf0,-8(SP)");
    comment("\t\t# Load hacked int bits\n");
    print("\tfsub  \tf%d,f0,f%d", dst, dst);
    comment("\t\t# Complete int->double conversion\n");
    break;
  }
  case CVDI: {
    int src = getregnum(p->x.kids[0]);
    int dst = getregnum(p);
    /* Clobber above saves us fpr0 for our use */
    assert( dst != 0 );
    print("\tfctiwz \tf0,f%d",src);
    comment("\t\t# Double->int conversion into f0\n");
    print("\tstfd \tf0,-8(SP)");
    comment("\t\t# Save bits to memory\n");
    print("\tlwz \tr%d,-4(SP)",dst);
    comment("\t\t# Load bits\n");
    break;
  }

  case CALLD:  case CALLF:  case CALLI:  case CALLV: {
    int src = getregnum(p->x.kids[0]);
    print("\tlwz \tr11,0(r%d)", src);  comment("\t\t# Load fcn ptr to r11\n");
    print("\tstw \tRTOC,20(SP)");      comment("\t\t# Save TOC\n");
    print("\tlwz \tRTOC,4(r%d)", src); comment("\t\t# Load new TOC\n");
    print("\tmtspr \tCTR,r11");      comment("\t\t\t# Fcn ptr to CTR\n");
    print("\tbcctrl \t0x14,0x1e");     comment("\t\t# branch/link\n");
    print("\tlwz \tRTOC,20(SP)");      comment("\t\t# Restore TOC\n");
    break;
  }

  }
}


/*---------------------------------------------------------------------------*/
static void doarg(Node p)
{
  static int f_argno;		/* Float-only argument counts */
  int ty = optype(p->op);	/* Type of argument */

  if (argoffset == 0)		/* New call? */
    f_argno = 0;		/* Reset arg count */
  if( ty == F || ty == D )	/* Float argument? */
    p->x.argno = f_argno++;	/* Then bump count of 'em */
  else p->x.argno = -99;	/* Trash value to trip me up */
  /* Here we bump the argoffset: offset into argument area. 
     Things less than a whole word round up to a word.
     Structures, doubles & etc all take their entire size. 
     Align is always WORD, even for doubles. */
  p->syms[2] = intconst(mkactual(4, roundup(p->syms[0]->u.c.v.i,4)));
}

/*---------------------------------------------------------------------------*/
static void local(Symbol p)
{
  /* Because we got lotsa registers, through everything into registers */
  if( isscalar(p->type) && !p->addressed && p->ref >= 2.0 )
    p->sclass = REGISTER;
  /* if( glevel ) p->sclass = AUTO; No register variables whilst debugging */
  if (askregvar(p, rmap[ttob(p->type)]) == 0)
    mkauto(p);
}


/*---------------------------------------------------------------------------*/
static Symbol curr_func;
static void function(Symbol f, Symbol caller[], Symbol callee[], int ncalls)
{
  int i;			/* Tmp counter */
  int varargs;			/* Flag for varargs routine or not */
  int sizeisave, sizefsave;	/* Size of GPR and FPR save areas */
  int sizesave;			/* Offset from FP */
  int in_fparms = 0;		/* Count of incoming float args */
  int in_argoffset = 24;	/* Incoming argument offset, 24+framesize */
  int argreg[8];		/* Source register for incoming args */
  const char *FN = f->x.name;	/* Easy access */

  curr_func = f;
  usedmask[0] = usedmask[1] = 0;
  freemask[0] = freemask[1] = ~(unsigned)0;
  for (i = 0; callee[i]; i++)
    ;
  varargs = variadic(f->type)
    || i > 0 && strcmp(callee[i-1]->name, "va_alist") == 0;
  for( i=0; i<32; i++ )
    ireg[i]->x.regnode->vbl = freg2[i]->x.regnode->vbl = NULL;

  for (i = 0; callee[i]; i++) {	/* For all parameters */
    Symbol p = callee[i];
    Symbol q = caller[i];
    Symbol reg=NULL;		/* Assume not in a register */
    int size = roundup(q->type->size, 4);
    p->x.offset = q->x.offset = in_argoffset;
    p->x.name = q->x.name = stringd(in_argoffset);

    /* Figure out how the danged thing got passed */
    if( isfloat(q->type) )  	/* First 13 floats in float regs */
      reg = (in_fparms++ < 13) ? freg2[in_fparms] : NULL;
    else 			/* First 8 words in GPRs */
      reg = (in_argoffset-24 < 4*8) ? ireg[((in_argoffset-24)>>2)+3] : NULL;
    if( reg ) argreg[i] = reg->x.regnode->number;

    /* Can't handle address'd parameters in a register.
       Worse, STABs can't handle parameters in registers either.  Sigh. */
    if( !p->addressed && !glevel ) {
      /* Figure out if it's in a register and can stay there */
      if( reg && !ncalls && !isstruct(q->type) ) {
	p->sclass = q->sclass = REGISTER;	/* It can stay */
	askregvar(p, reg);	/* Get the register */
	assert( p->x.regnode && p->x.regnode->vbl == p );
	q->x = p->x;		/* Copy the register field */
	q->type = p->type;
	/* Try to register-allocate in a non-parameter register */
      } else if( askregvar(p, rmap[ttob(p->type)]) && reg && 
		 (isint(p->type) || p->type == q->type) ) {
	assert( q->sclass != REGISTER );
	p->sclass = q->sclass = REGISTER;
	q->type = p->type;
      }
    }
    in_argoffset += size;	/* Bump incoming arg stack offset */
  }
  assert(caller[i] == 0);

  offset = maxoffset = 0;	/* No locals reserved yet */
  maxargoffset = 32;		/* Reserve space for at least 8 outgoing args*/

  /* Boilerplate the function start */
  swtoseg(TOC_SEG);
  print("_toc_%s:\n",FN);
  print("\t.tc\t%s{TC},%s{DS}\n",FN,FN);
  print("\t.csect \t%s{DS}\n",FN);
  print("\t.long \t.%s, TOC{TC0}, 0\n", FN);
  swtoseg(CODE);
  print(".%s:\n", FN);
  if( glevel ) {
    print("\t.function\t.%s,.%s,16,36,FE..%s-.%s\n",FN,FN,FN,FN);
    /* Replace the location of where the function declaration starts with
       the location of where the declaration _ends_, i.e., the open curly
       brace location. */
    f->src = codehead.next->u.point.src;
    print("\t.bf\t%d\n",f->src.y);
  }

  framesize = 0;		/* Flag that we ain't got framesize yet */
  gencode(caller, callee);	/* Make code, count locals & outgoing args */

  /* Word-align local variables */
  maxoffset = roundup(maxoffset,4); 
  /* Word-align outgoing argument area size */
  maxargoffset = roundup(maxargoffset,4); 
  /* Routine must save non-volatile registers only */
  usedmask[IREG] &= 0xffffe000; /* Save GPRs 13-31 */
  usedmask[FREG] &= 0xffffc000;	/* Save FPRs 14-31 */
  usedmask[IREG] |= 0x80000000;	/* FP (GPR 31) is used all the time */
  /* Count size of non-volatile register save areas */
  sizeisave = 4*(32-ff1(usedmask[IREG]));
  sizefsave = 8*(32-ff1(usedmask[FREG]));
  /* Frame is FPR save + GPR save + locals + outgoing args + 24, quadword */
  framesize = roundup(sizefsave+sizeisave + maxoffset + maxargoffset + 24,16);
  /* Sizesave is distance from old SP to the new FP: at end of locals */
  sizesave = framesize - 24 - maxargoffset - maxoffset;
  /* Now emit stabs for parameters, AFTER we know the framesize */
  if (glevel && IR->stabsym) {
    int i;
    Symbol p, q;
    for(i = 0; (p = callee[i]) != NULL && (q = caller[i]) != NULL; i++) {
      (*IR->stabsym)(p);
      if (p->sclass != q->sclass || p->type != q->type)
	(*IR->stabsym)(q);
    }
    swtoseg(CODE);
  }

  print("\tmfspr \tr0,LR");
  comment("\t\t\t# Return address to r0\n");

  /* Save non-volatile FPRs */
  for (i = 31; i >= 14; i-- )
    if( (usedmask[FREG] >> i) & 1 ) {
      print("\tstfd \tf%d,%d(SP)", i, -(32-i)*8);
      comment("\t\t# Save non-volatile f%d\n", i);
    }

  /* Save non-volatile GPRs */
  for (i = 31; i >= 13; i-- )
    if( !((usedmask[IREG] >> i) & 1) ) 
      break;
  if( i == 30 ) {
    print("\tstw \tr%d,%d(SP)", i+1, -(32-i-1)*4-sizefsave);
    comment("\t\t# Save non-volatile r%d\n", i+1);
  } else {
    print("\tstmw \tr%d,%d(SP)", i+1, -(32-i-1)*4-sizefsave);
    comment("\t\t# Save non-volatile r%d - r%d\n", i+1, 31);    
  }
  for ( ; i >= 13; i-- )
    if( (usedmask[IREG] >> i) & 1 ) {
      print("\tstw \tr%d,%d(SP)", i, -(32-i)*4-sizefsave);
      comment("\t\t# Save non-volatile r%d\n", i);
    }

  /* Now save off any args passed in registers, but needed in memory */
  for (i = 0; callee[i]; i++) {	/* For all parameters */
    Symbol p = callee[i];
    Symbol q = caller[i];	/* Get where we came from */
    int reg = argreg[i];
    assert( p->sclass != REGISTER || p->x.regnode );
    if( p->x.offset-24 >= 32 )	/* Passed the not-already-in-memory area? */
      break;			/* Then quit saving stuff */
    if( p->sclass == AUTO ) {	/* Needed on the stack? */
      if( isfloat(q->type) ) {
	print("\tstfd \tf%d,%d(SP)", reg, p->x.offset);
	comment("\t\t# Parm %d addressed or used, save f%d\n", i, reg);
      } else if( isscalar(q->type) ) {
	print("\tstw \tr%d,%d(SP)", reg, p->x.offset);
	comment("\t\t# Parm %d addressed or used, save r%d\n", i, reg);
      } else {
	int off = p->x.offset;
	int size = roundup(p->type->size, 4);
	assert( isstruct(q->type) );
	for( ; off-24 < 32 && size; size -= 4, off += 4 ) {
	  print("\tstw \tr%d,%d(SP)", reg++, off, i);
	  comment("\t\t# Structure moved to stack\n");
	}
      }
      /* Here I have passed an arg in a register, but must use it in another */
    } else if( p->x.regnode != q->x.regnode ) {
      if( isfloat(q->type) ) {
	print("\tfmr \tf%d,f%d", p->x.regnode->number, reg );
	comment("\t\t\t# Parm %d used in register f%d\n",
		i, p->x.regnode->number);
      } else {
	print("\tmr  \tr%d,r%d", p->x.regnode->number, reg );
	comment("\t\t\t# Parm %d used in register r%d\n", 
		i, p->x.regnode->number);
      }
    }
  }

  /* For varargs, we gotta save the remaining GPR area. 
     Leading named (not-varargs) arguments don't need to be saved. */
  if( varargs && !callee[i] ) {	/* Varargs and all named arguments handled? */
    i = callee[i-1]->x.offset + 
      roundup(callee[i-1]->type->size,4); /* End of last named arg*/
    for( ; i-24 < 32; i += 4 ) {
      int reg = ((i-24)>>2)+3;
      print("\tstw \tr%d,%d(SP)", reg, i);
      comment("\t\t# Save varargs r%d\n", reg);
    }
  }

  print("\tstw \tr0,8(SP)");  comment("\t\t# Save return address\n");
  print("\taddi \tFP,SP,%d",-sizesave); comment("\t\t# Set FramePointer\n");
  {
    /* Adjust all formal offsets by the sizesave area. */
    /* Formals are now directly referenced from the FP. */
    Code cp = codehead.next;
    for (i = 0; callee[i]; i++) {	/* For all parameters */
      Symbol p = callee[i];
      p->x.offset += sizesave;
      if( p->sclass == AUTO )
	p->x.name = stringd(p->x.offset);
      p = caller[i];
      p->x.offset += sizesave;
      if( p->sclass == AUTO )
	p->x.name = stringd(p->x.offset);
    }
    for ( ; cp; cp = cp->next)
      if( cp->kind == Address) {
	Symbol p = cp->u.addr.sym;
	if( p->scope == PARAM ) {
	  assert( p->sclass == AUTO );
	  p->x.offset += sizesave;
	  p->x.name = stringd(p->x.offset);
	}
      }
  }


  if( framesize ) {		/* Stack frame creation */
    if( framesize < 32768 ) {	/* Small frame? */
      print("\tstwu \tSP,-%d(SP)", framesize);
      comment("\t\t# Stack frame = %d(FPRs)+%d(GPRs)+%d(pad)+%d(locals)+%d(args)+24\n", sizefsave, sizeisave, sizesave-(sizefsave+sizeisave), maxoffset, maxargoffset);
    } else {			/* Humungous frame */
      print("\taddis \tr12,r0,((-%d)>16)&0xffff", framesize);
      comment("\t# Large frame size\n");
      print("\tori \tr12,r12,(-%d)&0xffff", framesize);
      comment("\t# Frame = %d(FPRs)+%d(GPRs)+%d(pad)+%d(locals)+%d(args)+24\n", sizefsave, sizeisave, sizesave-(sizefsave+sizeisave), maxoffset, maxargoffset);
      print("\tstwux \tSP,SP,r12");
      comment("\t\t# Atomically create stack frame\n");
    }
  }

  emitcode();

  print("\tlwz \tr0,%d(FP)",sizesave+8);
  comment("\t\t# Load return address\n");
  if( framesize ) {		/* Stack frame release */
    print("\taddi \tSP,FP,%d",sizesave); 
    comment("\t\t# Restore SP from FP\n");
  }

  /* Reload non-volatile GPRs */
  for (i = 31; i >= 13; i-- )
    if( !((usedmask[IREG] >> i) & 1) ) 
      break;
  if( i == 30 ) {
    print("\tlwz \tr%d,%d(SP)", i+1, -(32-i-1)*4-sizefsave);
    comment("\t\t# Load non-volatile r%d\n", i+1);
  } else {
    print("\tlmw \tr%d,%d(SP)", i+1, -(32-i-1)*4-sizefsave);
    comment("\t\t# Load non-volatile r%d - r%d\n", i+1, 31);    
  }
  for ( ; i >= 13; i-- )
    if( (usedmask[IREG] >> i) & 1 ) {
      print("\tlwz \tr%d,%d(SP)", i, -(32-i)*4-sizefsave);
      comment("\t\t# Load non-volatile r%d\n", i);
    }

  print("\tmtspr \tLR, r0");
  comment("\t\t\t# Return address to link register\n");

  /* Reload non-volatile FPRs */
  for (i = 31; i >= 14; i-- )
    if( (usedmask[FREG] >> i) & 1 ) {
      print("\tlfd \tf%d,%d(SP)", i, -(32-i)*8);
      comment("\t\t# Load non-volatile f%d\n", i);
    }

  if( glevel ) {
    print("\t.ef\t%d",src.y);
    comment("\t\t\t# End function %s\n", FN);
  }
  print("\tbclr \t0x14, 0x0\n");
  print("FE..%s:", FN);
  comment("\t\t\t\t# end %s\n\n\n", FN);
}

/*---------------------------------------------------------------------------*/
static void defconst(int ty, Value v) 
{
  switch (ty) {
  case C: print("\t.byte\t%d\n"  , v.uc); return;
  case S: print("\t.short\t%d\n" , v.ss); return;
  case I: print("\t.long\t0x%x\n", v.i ); return;
  case U: print("\t.long\t0x%x\n", v.u ); return;
  case P: print("\t.long\t0x%x\n", v.p ); return;
  case F: print("\t.long\t0x%x\n", *(unsigned *)&v.f);  return;
  case D: {
    unsigned *p = (unsigned *)&v.d;
    print("\t.long\t0x%x\n\t.long\t0x%x\n", p[swap], p[!swap]);
    return;
  }
  }
  assert(0);
}

/*---------------------------------------------------------------------------*/
static void defaddress(Symbol p)
{
  p->addressed = 1;
  print("\t.long\t%s%s+%d\n", p->x.name, 
	isfunc(p->type) ? "{ds}" : (p->sclass==EXTERN ? "{UA}" : ""),
	p->x.offset);
}

/*---------------------------------------------------------------------------*/
static void defstring(int n, char *str)
{
  int i;
  for( i=0; i<n-1; i++ )	/* Check all characters */
    if( str[i] < ' ' || str[i] == '"') /* Find an unpleasant character? */
      break;
  if( (i == n) && !str[n-1] )	/* All checked OK and nul-terminated? */
    print("\t.string\t\"%s\"\n", str); /* Nice method to print strings */
  else for( i=0; i<n; i++ )	/* Emit the hard way */
    print("\t.byte\t%d\n", str[i]);
}

/*---------------------------------------------------------------------------*/
static void export(Symbol p)
{
  if( isfunc(p->type) ) 
    print("\t.globl\t.%s\n\t.globl\t%s{ds}\n", p->x.name, p->x.name);
  else print("\t.globl\t%s\n", p->x.name);
}

/*---------------------------------------------------------------------------*/
static void import(Symbol p)
{
  if( p->ref == 0.0 ) return;
  if( isfunc( p->type ) ) {
    print("\t.extern\t.%s\n", p->name);
    if( !p->addressed ) return;
    swtoseg(TOC_SEG);
    print("_toc_%s:\n", p->x.name);
    print("\t.tc\t%s{TC},%s{ds}\n", p->x.name, p->x.name);
    print("\t.extern\t%s{ds}\n", p->name);
  } else {
    print("\t.extern\t%s{UA}\n", p->name);
    swtoseg(TOC_SEG);
    print("_toc_%s:\n", p->x.name);
    print("\t.tc\t%s{TC},%s{UA}\n", p->x.name, p->x.name);
  }
}

/*---------------------------------------------------------------------------*/
static void defsymbol(Symbol p)
{
  if (p->scope >= LOCAL && p->sclass == STATIC)
    p->x.name = stringf("L.%d", genlabel(1));
  else if (p->generated)
    p->x.name = stringf("L.%s", p->name);
  else {
    assert(p->scope != CONSTANTS || isint(p->type) || isptr(p->type));
    p->x.name = p->name;
  }
}

/*---------------------------------------------------------------------------*/
static void address(Symbol q, Symbol p, int n)
{
  q->x.offset = p->x.offset + n;
  if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN)
    q->x.name = p->x.name;	/* Same name, different offset */
  else
    q->x.name = stringd(q->x.offset);
}

/*---------------------------------------------------------------------------*/
static void global(Symbol p)
{
  int oldseg = cseg;
  /* Slam in a TOC entry */
  swtoseg(TOC_SEG);
  print("_toc_%s:\n\t.tc\t%s{TC},%s\n",p->x.name,p->x.name,p->x.name);
  swtoseg(oldseg);
  if (p->u.seg == BSS) {
    if (p->sclass == STATIC || Aflag >= 2)
      print("\t.lcomm \t%s,%d,_.bss_c\n", p->x.name, p->type->size);
    else
      print( "\t.comm \t%s,%d\n", p->x.name, p->type->size);
  } else {
    if( p->type->align > 1 )	/* If greater-than-byte alignment needed */
      print("\t.align \t%c\n", ".01.2...3"[p->type->align]);
    print("%s:\n", p->x.name);
  }
}

/*---------------------------------------------------------------------------*/
static void space(int n) 
{
  if (cseg != BSS)
    print("\t.space \t%d\n", n);
}

/*---------------------------------------------------------------------------*/
static void segment(int n) 
{
  cseg = n;
  switch (n) {
  case CODE: print("\t.csect \t[pr]\n");  break;
  case DATA: print("\t.csect \t[rw]\n"); break;
  case LIT:  print("\t.csect \t[rw]\n"); break;
  case TOC_SEG: print("\t.toc\n"); break;
  }
}

/*---------------------------------------------------------------------------*/
static void blkloop(int dreg, int doff, int sreg, int soff, int size, int tmps[])
{
  int lab = genlabel(1);
  int rsz = size&~7;

  comment("\t# Block copy %d bytes from %d(r%d) to %d(r%d)\n",
	  size, soff, sreg, doff, dreg);
  if( (rsz) < 32768 ) {	/* Align to 8 byte size */
    print("\taddi \tr%d,r%d,%d", sreg, sreg, rsz);
    comment("\t\t# Add align(size,8) to src\n");
    print("\taddi \tr%d,r%d,%d", tmps[2], dreg, rsz);
    comment("\t\t# Set align(size,8)+dst in tmp r%d\n", tmps[2]);
  } else {
    print("\taddis \tr%d,r0,(%d-((%d<16)>16))>16\n", tmps[2], rsz, rsz);
    print("\taddi  \tr%d,r%d,(%d<16)>16\n", tmps[2], tmps[2], rsz);
    print("\tadd   \tr%d,r%d,r%d\n", sreg, tmps[2], sreg);
    print("\tadd   \tr%d,r%d,r%d\n", tmps[2], tmps[2], dreg);
  }
  blkcopy(tmps[2], doff, sreg, soff, size&7, tmps);
  print("L.%d:\n", lab);
  print("\taddi \tr%d,r%d,-8\n", sreg, sreg);
  print("\taddi \tr%d,r%d,-8\n", tmps[2], tmps[2]);
  blkcopy(tmps[2], doff, sreg, soff, 8, tmps);
  print("\tcmpl \tCR0,0,r%d,r%d\n", dreg, tmps[2]);
  print("\tblt \tL.%d\n", lab);
}

/*---------------------------------------------------------------------------*/
static void blkfetch(int size, int off, int reg, int tmp) 
{
  assert(size == 1 || size == 2 || size == 4);
  assert( salign >= size );
  if( size == 1 )
    print("\tlbz \tr%d,%d(r%d)\n", tmp, off, reg);
  else if( size == 2 )
    print("\tlhz \tr%d,%d(r%d)\n", tmp, off, reg);
  else
    print("\tlwz \tr%d,%d(r%d)\n", tmp, off, reg);
}

/*---------------------------------------------------------------------------*/
static void blkstore(int size, int off, int reg, int tmp) 
{
  assert(size == 1 || size == 2 || size == 4);
  assert( dalign >= size );
  if( size == 1 )
    print("\tstb \tr%d,%d(r%d)\n", tmp, off, reg);
  else if( size == 2 )
    print("\tsth \tr%d,%d(r%d)\n", tmp, off, reg);
  else
    print("\tstw \tr%d,%d(r%d)\n", tmp, off, reg);
}

/*---------------------------------------------------------------------------*/
/* Get the constant, return 0 or LBURG_MAX */
static int getcon( Node p, unsigned int *con ) 
{
  Symbol s = p->syms[0];
  unsigned int i;
  switch( p->op ) {
  case ADDRFP: 
  case ADDRLP: i = s->x.offset; break;
  case CNSTC:  i = s->u.c.v.sc; break;
  case CNSTI:  i = s->u.c.v.i;  break;
  case CNSTS:  i = s->u.c.v.ss; break;
  case CNSTU:  i = s->u.c.v.u;  break;
  case CNSTP:  i = (int)s->u.c.v.p;  break;
  default: return LBURG_MAX;
  }
  *con = i;
  return 0;
}

/*---------------------------------------------------------------------------*/
/* Return 0 if 16 low bits are zero, and LBURG_MAX otherwise. */
static int hibits( Node p ) 
{
  unsigned int i;
  if( getcon(p,&i) ) return LBURG_MAX;
  return (i & 0xffff) ? LBURG_MAX : 0;
}

/*---------------------------------------------------------------------------*/
/* Return 0 if the constant can be represented by a run of bits.  A bit run 
 * is a sequence of all 1'bits, with the remaining bits 0.  The sequence can 
 * wrap at the end of the word. */
static int bitrun( Node p )
{ 
  unsigned int i;
  int r, lsb, idx0, idx1;
  if( getcon(p,&i) ) return LBURG_MAX;
  
  /* A finite sequence of 1 bits has a start and a finish, i.e., one 0->1
   * changeup and one 1->0 changeup.  If we rotate the word right 1 and XOR
   * it, we'll get 1 bits at the changeups and 0s elsewhere.  We need to have
   * exactly 2 changeups.  */
  r = (i>>1) |			/* i logical shift right 1, not rotated */
    ((i<<31)&(1L<<31));		/* Or in the high order bit */
  r ^= i;			/* XOR 'em together */
  r -= lsb = (r & -r);		/* Compute LSB, or first change-up */
  if( r - (r & -r) ) return LBURG_MAX; /* More than 1 more bit */
  idx0 = ff1(lsb);		/* Index of LSB */
  idx1 = ff1(r);		/* Index of MSB */
  /* Record the start & end runs in x.argno */
  p->x.argno = ( lsb & i ) ? (idx0<<5) + idx1 : (idx1<<5) + idx0;
  return 0;			/* Only 2 changeups */
}

/*---------------------------------------------------------------------------*/
/* Check for bit field insert.  This is expressed as the OR of two AND'd
 * fields, where the AND's have complemented bit masks. 
 */
static int bins( Node p )
{ 
  Node and0 = p->kids[0];
  int s0 = and0->x.argno>>5;	/* Begin/end bitrun mask */
  int e0 = and0->x.argno&31;
  Node and1 = p->kids[1];
  int s1 = and1->x.argno>>5;	/* Begin/end bitrun mask */
  int e1 = and1->x.argno&31;
  p->x.argno = and1->x.argno;
  return ((s0-e1) | (s1-e0)) ? LBURG_MAX : 2;
}

/*---------------------------------------------------------------------------*/
/* Find first 1, or return 32 if empty */
static int ff1(unsigned mask)
{
  unsigned i, n = 0;

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

/*---------------------------------------------------------------------------*/
#if defined(HAVE_DBXSTCLASS_H)
#include <dbxstclass.h>
#endif

static char *currentfile;       /* current file name */
static int ntypes;

static void stabblock ARGS((int, int, Symbol*));
static void stabfend ARGS((Symbol, int));
static void stabinit ARGS((char *, int, char *[]));
static void stabline ARGS((Coordinate *));
static void stabsym ARGS((Symbol));
static void stabtype ARGS((Symbol));

static void asgncode ARGS((Type, int));
static void dbxout ARGS((Type));
static int dbxtype ARGS((Type));
static int emittype ARGS((Type, int, int));

/*---------------------------------------------------------------------------*/
/* asgncode - assign type code to ty */
static void asgncode(Type ty, int lev)
{
  if (ty->x.marked || ty->x.typeno)
    return;
  ty->x.marked = 1;
  switch( ty->op ) {
  case VOLATILE: case CONST: case VOLATILE+CONST:
    asgncode(ty->type, lev);
    ty->x.typeno = ty->type->x.typeno;
    break;
  case POINTER: case FUNCTION: case ARRAY:
    asgncode(ty->type, lev + 1);
    /* fall thru */
  case VOID: case CHAR: case SHORT: case INT: case UNSIGNED:
  case FLOAT: case DOUBLE:
    break;
  case STRUCT: case UNION: {
    Field p;
    for( p = fieldlist(ty); p; p = p->link )
      asgncode(p->type, lev + 1);
  }
  /* fall thru */
  case ENUM:
    if( ty->x.typeno == 0 )
      ty->x.typeno = ++ntypes;
    if( lev > 0 && (*ty->u.sym->name < '0' || *ty->u.sym->name > '9') )
      dbxout(ty);
    break;
  default:
    assert(0);
  }
}

/*---------------------------------------------------------------------------*/
/* dbxout - output .stabx entry for type ty */
static void dbxout(Type ty)
{
  ty = unqual(ty);
  if( !ty->x.printed ) {	/* Not already emitted? */
    int col = 0;		/* Start column counting */
    /* Print stabx and some tabs */
    print("\t.stabx \t\""), col += 17;
    /* If I have a symbol, and it's not a function, array or pointer */
    if( ty->u.sym && !(isfunc(ty) || isarray(ty) || isptr(ty)) )
      /* Then emit the user's type name */
      print("%s", ty->u.sym->name), col += strlen(ty->u.sym->name);
    /* Emit the "NamedType" type tag */
    print(":%c", isstruct(ty) || isenum(ty) ? 'T' : 't'), col += 2;
    /* Recursively dump the type */
    emittype(ty, 0, col);
    /* Emit symbol's value, storage class and type */
    print("\",0,%d,0\t# ", C_DECL);
    if( pretty_print ) outtype(ty);
    print("\n");
  }
}

/*---------------------------------------------------------------------------*/
/* dbxtype - emit a stabs entry for type ty, return type code */
static int dbxtype(Type ty)
{
  asgncode(ty, 0);
  dbxout(ty);
  return ty->x.typeno;
}

/*---------------------------------------------------------------------------*/
/* emittype - emit ty's type number, emitting its definition if necessary.
 * Returns the output column number after emission; col is the approximate
 * output column before emission and is used to emit continuation lines for 
 * long struct, union, and enum types.  Continuations are not emitted for other
 * types, even if the definition is long.  lev is the depth of calls to 
 * emittype.
 */
static int emittype(Type ty, int lev, int col)
{
  int tc = ty->x.typeno;

  /* Qualified types just copy the typeno and are done. */
  if( isconst(ty) || isvolatile(ty) ) {
    col = emittype(ty->type, lev, col);
    ty->x.typeno = ty->type->x.typeno;
    ty->x.printed = 1;
    return col;
  }
  if (tc == 0)			/* Not already got a typeno? */
    ty->x.typeno = tc = ++ntypes; /* Then get a new unique number */
  print("%d", tc), col += 3;
  if( ty->x.printed )		/* Printed already? */
    return col;			/* Then we are done! */
  ty->x.printed = 1;		/* It's printed now! */

  switch( ty->op ) {		/* Break out and print each type */
  case VOID:			/* Previous void def */
    print("=%d", TP_VOID), col += 1+3;
    break;
  case CHAR:			/* Previous char def */
    print("=%d", (ty == unsignedchar) ? TP_UCHAR : TP_CHAR), col += 1+3;
    break;
  case SHORT:			/* Previous short def */
    print("=%d", (ty == unsignedshort) ? TP_USHORT : TP_SHORT), col += 1+3;
    break;
  case INT:			/* Previous int def */
    print("=%d", TP_INT), col += 1+3;
    break;
  case UNSIGNED:		/* Previous unsigned def */
    print("=%d", TP_UNSIGNED), col += 1+3;
    break;
  case FLOAT: 
    print("=%d", TP_FLOAT), col += 1+3;
    break;
  case DOUBLE:	
    print("=%d", TP_DOUBLE), col += 1+3;
    break;
  case POINTER:
    print("=*"), col += 2;
    col = emittype(ty->type, lev + 1, col);
    break;
  case FUNCTION:
    print("=f"), col += 2;	/* Static function? */
    col = emittype(ty->type, lev + 1, col);
    break;
  case ARRAY:			/* array includes subscript as an int range */
    if( ty->size && ty->type->size )
      print("=ar%d;0;%d;", TP_INT, ty->size/ty->type->size - 1), col += 7+2+1;
    else
      print("=ar%d;0;-1;", TP_INT), col += 11;
    col = emittype(ty->type, lev + 1, col);
    break;
  case STRUCT: case UNION: {
    Field p;
    /* if( !ty->u.sym->defined ) {
      print("=x%c%s:", ty->op == STRUCT ? 's' : 'u', ty->u.sym->name);
      col += 2+1+strlen(ty->u.sym->name)+1;
      break;
    } */
    if (lev > 0 && (*ty->u.sym->name < '0' || *ty->u.sym->name > '9')) {
      ty->x.printed = 0;
      break;
    }
    print("=%c%d", ty->op == STRUCT ? 's' : 'u', ty->size), col += 1+1+3;
    for( p = fieldlist(ty); p; p = p->link ) {
      if (p->name)
	print("%s:", p->name), col += strlen(p->name)+1;
      else
	print(":"), col += 1;
      col = emittype(p->type, lev + 1, col);
      if( p->lsb )
	print(",%d,%d;", 8*p->offset +
	      (IR->little_endian ? fieldright(p) : fieldleft(p)),
	      fieldsize(p));
      else
	print(",%d,%d;", 8*p->offset, 8*p->type->size);
      col += 1+3+1+3+1;		/* accounts for ,%d,%d; */
      if( col >= 80 && p->link ) {
	print("?\",0,%d,0\n\t.stabx \t\"", C_DECL);
	col = 17;
      }
    }
    print(";"), col += 1;
    break;
  }
  case ENUM: {
    Symbol *p;
    if (lev > 0 && (*ty->u.sym->name < '0' || *ty->u.sym->name > '9')) {
      ty->x.printed = 0;
      break;
    }
    print("=e"), col += 2;
    for( p = ty->u.sym->u.idlist; *p; p++ ) {
      print("%s:%d,", (*p)->name, (*p)->u.value), col += strlen((*p)->name)+3;
      if (col >= 80 && p[1]) {
	print("?\",0,%d,0\n\t.stabx \t\"", C_DECL);
	col = 17;
      }
    }
    print(";"), col += 1;
    break;
  }
  default:
    assert(0);
  }
  return col;
}

/*---------------------------------------------------------------------------*/
/* stabblock - output a stab entry for '{' or '}' at level lev */
static void stabblock(int brace, int lev, Symbol *p)
{
  if( lev ) {
    print("\t.%cb \t%d", brace == '{' ? 'b' : 'e', src.y);
    comment("\t\t\t# Block depth %d\n", lev);
  }  
  if( brace == '{' )		/* Start of a block? */
    while (*p)			/* Then emit variable declarations */
      stabsym(*p++);
}

/*---------------------------------------------------------------------------*/
/* stabfend - end of function p */
static void stabfend(Symbol p, int line) 
{
}

/*---------------------------------------------------------------------------*/
/* stabinit - initialize stab output */
static void stabinit(char *file, int argc, char *argv[]) 
{
  typedef void (*Closure) ARGS((Symbol, void *));

  if( file && *file ) {
    (*IR->segment)(CODE);
    print("\t.file\t\"%s\"\n", file);
    currentfile = file;
  } else {
    currentfile = NULL;
  }
  dbxtype(inttype);
  dbxtype(chartype);
  dbxtype(doubletype);
  dbxtype(floattype);
  dbxtype(longdouble);
  dbxtype(longtype);
  dbxtype(shorttype);
  dbxtype(signedchar);
  dbxtype(unsignedchar);
  dbxtype(unsignedlong);
  dbxtype(unsignedshort);
  dbxtype(unsignedtype);
  dbxtype(voidtype);
  foreach(types, GLOBAL, (Closure)stabtype, NULL);
}

/*---------------------------------------------------------------------------*/
/* stabline - emit stab entry for source coordinate *cp */
static void stabline(Coordinate *cp)
{
  if( cp->file && cp->file != currentfile ) {
    print("\t.file\t\"%s\"\n", cp->file);
    currentfile = cp->file;
  }
  if( curr_func->src.file == currentfile ) {
    print("\t.line\t%d", cp->y - curr_func->src.y+1);
    comment("\t\t\t# Source line %d\n", cp->y+1);
  }
}

/*---------------------------------------------------------------------------*/
/* stabsym - output a stab entry for symbol p */
static void stabsym(Symbol p)
{
  int tc;
  Type ty = p->type;

  if( p->generated || p->computed )
    return;			/* Skip if internal variable */
  if( p->scope == PARAM && !framesize ) return;
  if( isfunc(ty) ) {		/* Print function declaration */
    print("\t.stabx \t\"%s:%c%d\",.%s,%d,0", p->name, 
	  p->sclass == STATIC ? 'f' : 'F', dbxtype(freturn(ty)), 
	  p->x.name, C_FUN);
    if( pretty_print ) {
      print("\t# %k ", p->sclass);
      outtype(ty);
    }
    print("\n");
    return;
  }

  if (!IR->wants_argb && p->scope == PARAM && p->structarg) {
    assert(isptr(ty) && isstruct(ty->type));
    ty = ty->type;		/* Structures passed by reference */
  }
  tc = dbxtype(ty);		/* Compute STABS TypeID for the type */

  if( p->sclass == AUTO && p->scope == GLOBAL || p->sclass == EXTERN ) {
    print(".stabx \"%s:G%d\",0,%d,0\t#", p->name, tc, C_GSYM);
  } else if( p->sclass == STATIC ) {
    if( p->u.seg == BSS ) print("\t.bs \t_.bss_c\n",p->src.file);
    else print("\t.bs \t[rw]\n");
    print("\t.stabx\t \"%s:%c%d\",0,%d,0\n", p->name, 
	  p->scope == GLOBAL ? 'S' : 'V', tc, 
	  p->u.seg == BSS ? C_LSYM : C_STSYM);
    print("\t.es\t# ");
  } else if( p->sclass == REGISTER ) {
    int r = p->x.regnode->number;
    if (p->x.regnode->set == FREG)
      r += 32;			/* floating point */
    print("\t.stabx\t \"%s:r%d\",%d,%d,0", p->name, tc, r, C_RSYM);
    if( pretty_print ) print("\t# r%d", r);
  } else if( p->scope == PARAM ) {
    assert( p->sclass != EXTERN );
    print("\t.stabx\t \"%s:p%d\",%s+%d,%d,0", 
	  p->name, tc, p->x.name, framesize, C_PSYM);
    if( pretty_print ) print("\t# param");
  } else if (p->scope >= LOCAL) {
    assert( p->sclass != EXTERN );
    print("\t.stabx\t \"%s:%d\",%d+24%s,%d,0", 
	  p->name, tc, maxargoffset+maxoffset, p->x.name, C_LSYM);
    if( pretty_print ) print("\t# local");
  } else
    assert(0);
  if( pretty_print ) {
    print(" %k ", p->sclass);
    outtype(ty);
    print(" %s", p->name);
  }
  print("\n");
}

/*---------------------------------------------------------------------------*/
/* stabtype - output a stab entry for type *p */
static void stabtype(Symbol p)
{
  if (p->type) {
    if (p->sclass == 0)
      dbxtype(p->type);
    else if (p->sclass == TYPEDEF) {
      print("\t.stabx \t\"%s:t%d\",0,%d,0\n", p->name,dbxtype(p->type),C_LSYM);
    }
  }
}

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

  }
};

