text: #include "c.h"
  #define NODEPTR_TYPE Node
  #define OP_LABEL(p) ((p)->op)
  #define LEFT_CHILD(p) ((p)->kids[0])
  #define RIGHT_CHILD(p) ((p)->kids[1])
  #define STATE_LABEL(p) ((p)->x.state)
  static void address     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 imm ARGS((Node));
  static void rename ARGS((void));
  static void defsymbol2 ARGS((Symbol));
  static void global2 ARGS((Symbol));
  static void segment2 ARGS((int));
  
  static Symbol greg[32];
  static Symbol *oreg = &greg[8], *ireg = &greg[24];
  static Symbol freg[32], freg2[32];
  
  static int retstruct;
  
  static int pflag = 0;
  
  static int cseg;
  
  /*
  generated at Fri Dec 16 10:42:15 1994
  by $Id: lburg.c,v 2.2 1994/12/08 16:10:01 cwf 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 _stk13_NT 4
  #define _stk_NT 5
  #define _con13_NT 6
  #define _base_NT 7
  #define _addr_NT 8
  #define _addrl_NT 9
  #define _spill_NT 10
  #define _rc_NT 11
  #define _rc5_NT 12
  #define _addrg_NT 13
  #define _call_NT 14
  #define _rel_NT 15
  
  static char *_ntname[] = {
  	0,
  	"stmt",
  	"reg",
  	"con",
  	"stk13",
  	"stk",
  	"con13",
  	"base",
  	"addr",
  	"addrl",
  	"spill",
  	"rc",
  	"rc5",
  	"addrg",
  	"call",
  	"rel",
  	0
  };
  
  struct _state {
  	short cost[16];
  	struct {
  		unsigned int _stmt:6;
  		unsigned int _reg:7;
  		unsigned int _con:3;
  		unsigned int _stk13:2;
  		unsigned int _stk:2;
  		unsigned int _con13:3;
  		unsigned int _base:3;
  		unsigned int _addr:3;
  		unsigned int _addrl:1;
  		unsigned int _spill:1;
  		unsigned int _rc:2;
  		unsigned int _rc5:2;
  		unsigned int _addrg:1;
  		unsigned int _call:2;
  		unsigned int _rel:4;
  	} rule;
  };
  
  static short _nts_0[] = { 0 };
  static short _nts_1[] = { _reg_NT, 0 };
  static short _nts_2[] = { _stk13_NT, 0 };
  static short _nts_3[] = { _reg_NT, _con13_NT, 0 };
  static short _nts_4[] = { _con13_NT, 0 };
  static short _nts_5[] = { _base_NT, 0 };
  static short _nts_6[] = { _reg_NT, _reg_NT, 0 };
  static short _nts_7[] = { _stk_NT, 0 };
  static short _nts_8[] = { _addr_NT, 0 };
  static short _nts_9[] = { _addr_NT, _reg_NT, 0 };
  static short _nts_10[] = { _addrl_NT, 0 };
  static short _nts_11[] = { _addrl_NT, _reg_NT, 0 };
  static short _nts_12[] = { _base_NT, _reg_NT, 0 };
  static short _nts_13[] = { _spill_NT, _reg_NT, 0 };
  static short _nts_14[] = { _con_NT, 0 };
  static short _nts_15[] = { _reg_NT, _rc_NT, 0 };
  static short _nts_16[] = { _reg_NT, _rc5_NT, 0 };
  static short _nts_17[] = { _addrg_NT, 0 };
  static short _nts_18[] = { _call_NT, 0 };
  static short _nts_19[] = { _call_NT, _reg_NT, 0 };
  static short _nts_20[] = { _rel_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_2,	/* 26 */
  	_nts_0,	/* 27 */
  	_nts_0,	/* 28 */
  	_nts_0,	/* 29 */
  	_nts_0,	/* 30 */
  	_nts_0,	/* 31 */
  	_nts_0,	/* 32 */
  	_nts_0,	/* 33 */
  	_nts_0,	/* 34 */
  	_nts_0,	/* 35 */
  	_nts_3,	/* 36 */
  	_nts_3,	/* 37 */
  	_nts_3,	/* 38 */
  	_nts_1,	/* 39 */
  	_nts_4,	/* 40 */
  	_nts_2,	/* 41 */
  	_nts_5,	/* 42 */
  	_nts_6,	/* 43 */
  	_nts_6,	/* 44 */
  	_nts_6,	/* 45 */
  	_nts_7,	/* 46 */
  	_nts_8,	/* 47 */
  	_nts_8,	/* 48 */
  	_nts_8,	/* 49 */
  	_nts_8,	/* 50 */
  	_nts_8,	/* 51 */
  	_nts_9,	/* 52 */
  	_nts_9,	/* 53 */
  	_nts_9,	/* 54 */
  	_nts_9,	/* 55 */
  	_nts_9,	/* 56 */
  	_nts_0,	/* 57 */
  	_nts_10,	/* 58 */
  	_nts_11,	/* 59 */
  	_nts_5,	/* 60 */
  	_nts_12,	/* 61 */
  	_nts_0,	/* 62 */
  	_nts_13,	/* 63 */
  	_nts_13,	/* 64 */
  	_nts_13,	/* 65 */
  	_nts_13,	/* 66 */
  	_nts_13,	/* 67 */
  	_nts_13,	/* 68 */
  	_nts_8,	/* 69 */
  	_nts_8,	/* 70 */
  	_nts_8,	/* 71 */
  	_nts_8,	/* 72 */
  	_nts_1,	/* 73 */
  	_nts_1,	/* 74 */
  	_nts_1,	/* 75 */
  	_nts_1,	/* 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_0,	/* 90 */
  	_nts_0,	/* 91 */
  	_nts_0,	/* 92 */
  	_nts_0,	/* 93 */
  	_nts_0,	/* 94 */
  	_nts_14,	/* 95 */
  	_nts_4,	/* 96 */
  	_nts_1,	/* 97 */
  	_nts_15,	/* 98 */
  	_nts_15,	/* 99 */
  	_nts_15,	/* 100 */
  	_nts_15,	/* 101 */
  	_nts_15,	/* 102 */
  	_nts_15,	/* 103 */
  	_nts_15,	/* 104 */
  	_nts_15,	/* 105 */
  	_nts_15,	/* 106 */
  	_nts_0,	/* 107 */
  	_nts_1,	/* 108 */
  	_nts_16,	/* 109 */
  	_nts_16,	/* 110 */
  	_nts_16,	/* 111 */
  	_nts_16,	/* 112 */
  	_nts_15,	/* 113 */
  	_nts_15,	/* 114 */
  	_nts_15,	/* 115 */
  	_nts_1,	/* 116 */
  	_nts_1,	/* 117 */
  	_nts_1,	/* 118 */
  	_nts_1,	/* 119 */
  	_nts_1,	/* 120 */
  	_nts_1,	/* 121 */
  	_nts_0,	/* 122 */
  	_nts_17,	/* 123 */
  	_nts_8,	/* 124 */
  	_nts_0,	/* 125 */
  	_nts_15,	/* 126 */
  	_nts_15,	/* 127 */
  	_nts_15,	/* 128 */
  	_nts_15,	/* 129 */
  	_nts_15,	/* 130 */
  	_nts_15,	/* 131 */
  	_nts_15,	/* 132 */
  	_nts_15,	/* 133 */
  	_nts_15,	/* 134 */
  	_nts_15,	/* 135 */
  	_nts_0,	/* 136 */
  	_nts_8,	/* 137 */
  	_nts_18,	/* 138 */
  	_nts_18,	/* 139 */
  	_nts_18,	/* 140 */
  	_nts_18,	/* 141 */
  	_nts_19,	/* 142 */
  	_nts_1,	/* 143 */
  	_nts_1,	/* 144 */
  	_nts_1,	/* 145 */
  	_nts_1,	/* 146 */
  	_nts_1,	/* 147 */
  	_nts_1,	/* 148 */
  	_nts_1,	/* 149 */
  	_nts_6,	/* 150 */
  	_nts_6,	/* 151 */
  	_nts_6,	/* 152 */
  	_nts_6,	/* 153 */
  	_nts_6,	/* 154 */
  	_nts_6,	/* 155 */
  	_nts_6,	/* 156 */
  	_nts_6,	/* 157 */
  	_nts_6,	/* 158 */
  	_nts_6,	/* 159 */
  	_nts_6,	/* 160 */
  	_nts_6,	/* 161 */
  	_nts_6,	/* 162 */
  	_nts_6,	/* 163 */
  	_nts_1,	/* 164 */
  	_nts_1,	/* 165 */
  	_nts_1,	/* 166 */
  	_nts_1,	/* 167 */
  	_nts_1,	/* 168 */
  	_nts_1,	/* 169 */
  	_nts_6,	/* 170 */
  	_nts_6,	/* 171 */
  	_nts_6,	/* 172 */
  	_nts_6,	/* 173 */
  	_nts_6,	/* 174 */
  	_nts_6,	/* 175 */
  	_nts_6,	/* 176 */
  	_nts_6,	/* 177 */
  	_nts_6,	/* 178 */
  	_nts_6,	/* 179 */
  	_nts_6,	/* 180 */
  	_nts_6,	/* 181 */
  	_nts_20,	/* 182 */
  	_nts_1,	/* 183 */
  	_nts_1,	/* 184 */
  	_nts_6,	/* 185 */
  };
  
  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 */
  	0,	/* 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 */
  	2,	/* 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 */	"set %a,%%%c\n",	/* reg: ADDRGP */
  /* 24 */	"%a",	/* stk13: ADDRFP */
  /* 25 */	"%a",	/* stk13: ADDRLP */
  /* 26 */	"add %0,%%fp,%%%c\n",	/* reg: stk13 */
  /* 27 */	"set %a,%%%c\n",	/* stk: ADDRFP */
  /* 28 */	"set %a,%%%c\n",	/* stk: ADDRLP */
  /* 29 */	"set %a,%%%c\nadd %%%c,%%fp,%%%c\n",	/* reg: ADDRFP */
  /* 30 */	"set %a,%%%c\nadd %%%c,%%fp,%%%c\n",	/* reg: ADDRLP */
  /* 31 */	"%a",	/* con13: CNSTC */
  /* 32 */	"%a",	/* con13: CNSTI */
  /* 33 */	"%a",	/* con13: CNSTP */
  /* 34 */	"%a",	/* con13: CNSTS */
  /* 35 */	"%a",	/* con13: CNSTU */
  /* 36 */	"%%%0+%1",	/* base: ADDI(reg,con13) */
  /* 37 */	"%%%0+%1",	/* base: ADDP(reg,con13) */
  /* 38 */	"%%%0+%1",	/* base: ADDU(reg,con13) */
  /* 39 */	"%%%0",	/* base: reg */
  /* 40 */	"%0",	/* base: con13 */
  /* 41 */	"%%fp+%0",	/* base: stk13 */
  /* 42 */	"%0",	/* addr: base */
  /* 43 */	"%%%0+%%%1",	/* addr: ADDI(reg,reg) */
  /* 44 */	"%%%0+%%%1",	/* addr: ADDP(reg,reg) */
  /* 45 */	"%%%0+%%%1",	/* addr: ADDU(reg,reg) */
  /* 46 */	"%%fp+%%%0",	/* addr: stk */
  /* 47 */	"ldsb [%0],%%%c\n",	/* reg: INDIRC(addr) */
  /* 48 */	"ldsh [%0],%%%c\n",	/* reg: INDIRS(addr) */
  /* 49 */	"ld [%0],%%%c\n",	/* reg: INDIRI(addr) */
  /* 50 */	"ld [%0],%%%c\n",	/* reg: INDIRP(addr) */
  /* 51 */	"ld [%0],%%f%c\n",	/* reg: INDIRF(addr) */
  /* 52 */	"stb %%%1,[%0]\n",	/* stmt: ASGNC(addr,reg) */
  /* 53 */	"sth %%%1,[%0]\n",	/* stmt: ASGNS(addr,reg) */
  /* 54 */	"st %%%1,[%0]\n",	/* stmt: ASGNI(addr,reg) */
  /* 55 */	"st %%%1,[%0]\n",	/* stmt: ASGNP(addr,reg) */
  /* 56 */	"st %%f%1,[%0]\n",	/* stmt: ASGNF(addr,reg) */
  /* 57 */	"%%%fp+%a",	/* addrl: ADDRLP */
  /* 58 */	"ldd [%0],%%f%c\n",	/* reg: INDIRD(addrl) */
  /* 59 */	"std %%f%1,[%0]\n",	/* stmt: ASGND(addrl,reg) */
  /* 60 */	"ld2 [%0],%%f%c\n",	/* reg: INDIRD(base) */
  /* 61 */	"st2 %%f%1,[%0]\n",	/* stmt: ASGND(base,reg) */
  /* 62 */	"%a",	/* spill: ADDRLP */
  /* 63 */	"set %0,%%g1\nstb %%%1,[%%fp+%%g1]\n",	/* stmt: ASGNC(spill,reg) */
  /* 64 */	"set %0,%%g1\nsth %%%1,[%%fp+%%g1]\n",	/* stmt: ASGNS(spill,reg) */
  /* 65 */	"set %0,%%g1\nst %%%1,[%%fp+%%g1]\n",	/* stmt: ASGNI(spill,reg) */
  /* 66 */	"set %0,%%g1\nst %%%1,[%%fp+%%g1]\n",	/* stmt: ASGNP(spill,reg) */
  /* 67 */	"set %0,%%g1\nst %%f%1,[%%fp+%%g1]\n",	/* stmt: ASGNF(spill,reg) */
  /* 68 */	"set %0,%%g1\nstd %%f%1,[%%fp+%%g1]\n",	/* stmt: ASGND(spill,reg) */
  /* 69 */	"ldsb [%0],%%%c\n",	/* reg: CVCI(INDIRC(addr)) */
  /* 70 */	"ldsh [%0],%%%c\n",	/* reg: CVSI(INDIRS(addr)) */
  /* 71 */	"ldub [%0],%%%c\n",	/* reg: CVCU(INDIRC(addr)) */
  /* 72 */	"lduh [%0],%%%c\n",	/* reg: CVSU(INDIRS(addr)) */
  /* 73 */	"mov %%%0,%%%c\n",	/* reg: CVIC(reg) */
  /* 74 */	"mov %%%0,%%%c\n",	/* reg: CVIS(reg) */
  /* 75 */	"mov %%%0,%%%c\n",	/* reg: CVIU(reg) */
  /* 76 */	"mov %%%0,%%%c\n",	/* reg: CVPU(reg) */
  /* 77 */	"mov %%%0,%%%c\n",	/* reg: CVUC(reg) */
  /* 78 */	"mov %%%0,%%%c\n",	/* reg: CVUI(reg) */
  /* 79 */	"mov %%%0,%%%c\n",	/* reg: CVUP(reg) */
  /* 80 */	"mov %%%0,%%%c\n",	/* reg: CVUS(reg) */
  /* 81 */	"%0",	/* reg: CVIC(reg) */
  /* 82 */	"%0",	/* reg: CVIS(reg) */
  /* 83 */	"%0",	/* reg: CVUC(reg) */
  /* 84 */	"%0",	/* reg: CVUS(reg) */
  /* 85 */	"mov %%%0,%%%c\n",	/* reg: LOADC(reg) */
  /* 86 */	"mov %%%0,%%%c\n",	/* reg: LOADI(reg) */
  /* 87 */	"mov %%%0,%%%c\n",	/* reg: LOADP(reg) */
  /* 88 */	"mov %%%0,%%%c\n",	/* reg: LOADS(reg) */
  /* 89 */	"mov %%%0,%%%c\n",	/* reg: LOADU(reg) */
  /* 90 */	"# reg\n",	/* reg: CNSTC */
  /* 91 */	"# reg\n",	/* reg: CNSTI */
  /* 92 */	"# reg\n",	/* reg: CNSTP */
  /* 93 */	"# reg\n",	/* reg: CNSTS */
  /* 94 */	"# reg\n",	/* reg: CNSTU */
  /* 95 */	"set %0,%%%c\n",	/* reg: con */
  /* 96 */	"%0",	/* rc: con13 */
  /* 97 */	"%%%0",	/* rc: reg */
  /* 98 */	"add %%%0,%1,%%%c\n",	/* reg: ADDI(reg,rc) */
  /* 99 */	"add %%%0,%1,%%%c\n",	/* reg: ADDP(reg,rc) */
  /* 100 */	"add %%%0,%1,%%%c\n",	/* reg: ADDU(reg,rc) */
  /* 101 */	"and %%%0,%1,%%%c\n",	/* reg: BANDU(reg,rc) */
  /* 102 */	"or %%%0,%1,%%%c\n",	/* reg: BORU(reg,rc) */
  /* 103 */	"xor %%%0,%1,%%%c\n",	/* reg: BXORU(reg,rc) */
  /* 104 */	"sub %%%0,%1,%%%c\n",	/* reg: SUBI(reg,rc) */
  /* 105 */	"sub %%%0,%1,%%%c\n",	/* reg: SUBP(reg,rc) */
  /* 106 */	"sub %%%0,%1,%%%c\n",	/* reg: SUBU(reg,rc) */
  /* 107 */	"%a",	/* rc5: CNSTI */
  /* 108 */	"%%%0",	/* rc5: reg */
  /* 109 */	"sll %%%0,%1,%%%c\n",	/* reg: LSHI(reg,rc5) */
  /* 110 */	"sll %%%0,%1,%%%c\n",	/* reg: LSHU(reg,rc5) */
  /* 111 */	"sra %%%0,%1,%%%c\n",	/* reg: RSHI(reg,rc5) */
  /* 112 */	"srl %%%0,%1,%%%c\n",	/* reg: RSHU(reg,rc5) */
  /* 113 */	"andn %%%0,%1,%%%c\n",	/* reg: BANDU(reg,BCOMU(rc)) */
  /* 114 */	"orn %%%0,%1,%%%c\n",	/* reg: BORU(reg,BCOMU(rc)) */
  /* 115 */	"xnor %%%0,%1,%%%c\n",	/* reg: BXORU(reg,BCOMU(rc)) */
  /* 116 */	"neg %%%0,%%%c\n",	/* reg: NEGI(reg) */
  /* 117 */	"not %%%0,%%%c\n",	/* reg: BCOMU(reg) */
  /* 118 */	"sll %%%0,24,%%%c; sra %%%c,24,%%%c\n",	/* reg: CVCI(reg) */
  /* 119 */	"sll %%%0,16,%%%c; sra %%%c,16,%%%c\n",	/* reg: CVSI(reg) */
  /* 120 */	"and %%%0,0xff,%%%c\n",	/* reg: CVCU(reg) */
  /* 121 */	"set 0xffff,%%g1; and %%%0,%%g1,%%%c\n",	/* reg: CVSU(reg) */
  /* 122 */	"%a",	/* addrg: ADDRGP */
  /* 123 */	"ba %0; nop\n",	/* stmt: JUMPV(addrg) */
  /* 124 */	"jmp %0; nop\n",	/* stmt: JUMPV(addr) */
  /* 125 */	"%a:\n",	/* stmt: LABELV */
  /* 126 */	"cmp %%%0,%1; be %a; nop\n",	/* stmt: EQI(reg,rc) */
  /* 127 */	"cmp %%%0,%1; bge %a; nop\n",	/* stmt: GEI(reg,rc) */
  /* 128 */	"cmp %%%0,%1; bgeu %a; nop\n",	/* stmt: GEU(reg,rc) */
  /* 129 */	"cmp %%%0,%1; bg %a; nop\n",	/* stmt: GTI(reg,rc) */
  /* 130 */	"cmp %%%0,%1; bgu %a; nop\n",	/* stmt: GTU(reg,rc) */
  /* 131 */	"cmp %%%0,%1; ble %a; nop\n",	/* stmt: LEI(reg,rc) */
  /* 132 */	"cmp %%%0,%1; bleu %a; nop\n",	/* stmt: LEU(reg,rc) */
  /* 133 */	"cmp %%%0,%1; bl %a; nop\n",	/* stmt: LTI(reg,rc) */
  /* 134 */	"cmp %%%0,%1; blu %a; nop\n",	/* stmt: LTU(reg,rc) */
  /* 135 */	"cmp %%%0,%1; bne %a; nop\n",	/* stmt: NEI(reg,rc) */
  /* 136 */	"%a",	/* call: ADDRGP */
  /* 137 */	"%0",	/* call: addr */
  /* 138 */	"call %0; nop\n",	/* reg: CALLD(call) */
  /* 139 */	"call %0; nop\n",	/* reg: CALLF(call) */
  /* 140 */	"call %0; nop\n",	/* reg: CALLI(call) */
  /* 141 */	"call %0; nop\n",	/* stmt: CALLV(call) */
  /* 142 */	"call %0; st %%%1,[%%sp+64]\n",	/* stmt: CALLB(call,reg) */
  /* 143 */	"# ret\n",	/* stmt: RETD(reg) */
  /* 144 */	"# ret\n",	/* stmt: RETF(reg) */
  /* 145 */	"# ret\n",	/* stmt: RETI(reg) */
  /* 146 */	"st %%%0,[%%sp+4*%c+68]\n",	/* stmt: ARGI(reg) */
  /* 147 */	"st %%%0,[%%sp+4*%c+68]\n",	/* stmt: ARGP(reg) */
  /* 148 */	"# ARGD\n",	/* stmt: ARGD(reg) */
  /* 149 */	"# ARGF\n",	/* stmt: ARGF(reg) */
  /* 150 */	"call .div,2; nop\n",	/* reg: DIVI(reg,reg) */
  /* 151 */	"call .udiv,2; nop\n",	/* reg: DIVU(reg,reg) */
  /* 152 */	"call .rem,2; nop\n",	/* reg: MODI(reg,reg) */
  /* 153 */	"call .urem,2; nop\n",	/* reg: MODU(reg,reg) */
  /* 154 */	"call .mul,2; nop\n",	/* reg: MULI(reg,reg) */
  /* 155 */	"call .umul,2; nop\n",	/* reg: MULU(reg,reg) */
  /* 156 */	"faddd %%f%0,%%f%1,%%f%c\n",	/* reg: ADDD(reg,reg) */
  /* 157 */	"fadds %%f%0,%%f%1,%%f%c\n",	/* reg: ADDF(reg,reg) */
  /* 158 */	"fdivd %%f%0,%%f%1,%%f%c\n",	/* reg: DIVD(reg,reg) */
  /* 159 */	"fdivs %%f%0,%%f%1,%%f%c\n",	/* reg: DIVF(reg,reg) */
  /* 160 */	"fmuld %%f%0,%%f%1,%%f%c\n",	/* reg: MULD(reg,reg) */
  /* 161 */	"fmuls %%f%0,%%f%1,%%f%c\n",	/* reg: MULF(reg,reg) */
  /* 162 */	"fsubd %%f%0,%%f%1,%%f%c\n",	/* reg: SUBD(reg,reg) */
  /* 163 */	"fsubs %%f%0,%%f%1,%%f%c\n",	/* reg: SUBF(reg,reg) */
  /* 164 */	"fnegs %%f%0,%%f%c\n",	/* reg: NEGF(reg) */
  /* 165 */	"fmovs %%f%0,%%f%c\n",	/* reg: LOADF(reg) */
  /* 166 */	"fdtos %%f%0,%%f%c\n",	/* reg: CVDF(reg) */
  /* 167 */	"fstod %%f%0,%%f%c\n",	/* reg: CVFD(reg) */
  /* 168 */	"fdtoi %%f%0,%%f0; st %%f0,[%%sp+64]; ld [%%sp+64],%%%c\n",	/* reg: CVDI(reg) */
  /* 169 */	"st %%%0,[%%sp+64]; ld [%%sp+64],%%f%c; fitod %%f%c,%%f%c\n",	/* reg: CVID(reg) */
  /* 170 */	"fcmped %%f%0,%%f%1; nop; fbue",	/* rel: EQD(reg,reg) */
  /* 171 */	"fcmpes %%f%0,%%f%1; nop; fbue",	/* rel: EQF(reg,reg) */
  /* 172 */	"fcmped %%f%0,%%f%1; nop; fbuge",	/* rel: GED(reg,reg) */
  /* 173 */	"fcmpes %%f%0,%%f%1; nop; fbuge",	/* rel: GEF(reg,reg) */
  /* 174 */	"fcmped %%f%0,%%f%1; nop; fbug",	/* rel: GTD(reg,reg) */
  /* 175 */	"fcmpes %%f%0,%%f%1; nop; fbug",	/* rel: GTF(reg,reg) */
  /* 176 */	"fcmped %%f%0,%%f%1; nop; fbule",	/* rel: LED(reg,reg) */
  /* 177 */	"fcmpes %%f%0,%%f%1; nop; fbule",	/* rel: LEF(reg,reg) */
  /* 178 */	"fcmped %%f%0,%%f%1; nop; fbul",	/* rel: LTD(reg,reg) */
  /* 179 */	"fcmpes %%f%0,%%f%1; nop; fbul",	/* rel: LTF(reg,reg) */
  /* 180 */	"fcmped %%f%0,%%f%1; nop; fbne",	/* rel: NED(reg,reg) */
  /* 181 */	"fcmpes %%f%0,%%f%1; nop; fbne",	/* rel: NEF(reg,reg) */
  /* 182 */	"%0 %a; nop\n",	/* stmt: rel */
  /* 183 */	"# LOADD\n",	/* reg: LOADD(reg) */
  /* 184 */	"# NEGD\n",	/* reg: NEGD(reg) */
  /* 185 */	"# ASGNB\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,	/* set %a,%%%c\n */
  /* 24 */	0,	/* %a */
  /* 25 */	0,	/* %a */
  /* 26 */	1,	/* add %0,%%fp,%%%c\n */
  /* 27 */	1,	/* set %a,%%%c\n */
  /* 28 */	1,	/* set %a,%%%c\n */
  /* 29 */	1,	/* set %a,%%%c\nadd %%%c,%%fp,%%%c\n */
  /* 30 */	1,	/* set %a,%%%c\nadd %%%c,%%fp,%%%c\n */
  /* 31 */	0,	/* %a */
  /* 32 */	0,	/* %a */
  /* 33 */	0,	/* %a */
  /* 34 */	0,	/* %a */
  /* 35 */	0,	/* %a */
  /* 36 */	0,	/* %%%0+%1 */
  /* 37 */	0,	/* %%%0+%1 */
  /* 38 */	0,	/* %%%0+%1 */
  /* 39 */	0,	/* %%%0 */
  /* 40 */	0,	/* %0 */
  /* 41 */	0,	/* %%fp+%0 */
  /* 42 */	0,	/* %0 */
  /* 43 */	0,	/* %%%0+%%%1 */
  /* 44 */	0,	/* %%%0+%%%1 */
  /* 45 */	0,	/* %%%0+%%%1 */
  /* 46 */	0,	/* %%fp+%%%0 */
  /* 47 */	1,	/* ldsb [%0],%%%c\n */
  /* 48 */	1,	/* ldsh [%0],%%%c\n */
  /* 49 */	1,	/* ld [%0],%%%c\n */
  /* 50 */	1,	/* ld [%0],%%%c\n */
  /* 51 */	1,	/* ld [%0],%%f%c\n */
  /* 52 */	1,	/* stb %%%1,[%0]\n */
  /* 53 */	1,	/* sth %%%1,[%0]\n */
  /* 54 */	1,	/* st %%%1,[%0]\n */
  /* 55 */	1,	/* st %%%1,[%0]\n */
  /* 56 */	1,	/* st %%f%1,[%0]\n */
  /* 57 */	0,	/* %%%fp+%a */
  /* 58 */	1,	/* ldd [%0],%%f%c\n */
  /* 59 */	1,	/* std %%f%1,[%0]\n */
  /* 60 */	1,	/* ld2 [%0],%%f%c\n */
  /* 61 */	1,	/* st2 %%f%1,[%0]\n */
  /* 62 */	0,	/* %a */
  /* 63 */	1,	/* set %0,%%g1\nstb %%%1,[%%fp+%%g1]\n */
  /* 64 */	1,	/* set %0,%%g1\nsth %%%1,[%%fp+%%g1]\n */
  /* 65 */	1,	/* set %0,%%g1\nst %%%1,[%%fp+%%g1]\n */
  /* 66 */	1,	/* set %0,%%g1\nst %%%1,[%%fp+%%g1]\n */
  /* 67 */	1,	/* set %0,%%g1\nst %%f%1,[%%fp+%%g1]\n */
  /* 68 */	1,	/* set %0,%%g1\nstd %%f%1,[%%fp+%%g1]\n */
  /* 69 */	1,	/* ldsb [%0],%%%c\n */
  /* 70 */	1,	/* ldsh [%0],%%%c\n */
  /* 71 */	1,	/* ldub [%0],%%%c\n */
  /* 72 */	1,	/* lduh [%0],%%%c\n */
  /* 73 */	1,	/* mov %%%0,%%%c\n */
  /* 74 */	1,	/* mov %%%0,%%%c\n */
  /* 75 */	1,	/* mov %%%0,%%%c\n */
  /* 76 */	1,	/* mov %%%0,%%%c\n */
  /* 77 */	1,	/* mov %%%0,%%%c\n */
  /* 78 */	1,	/* mov %%%0,%%%c\n */
  /* 79 */	1,	/* mov %%%0,%%%c\n */
  /* 80 */	1,	/* mov %%%0,%%%c\n */
  /* 81 */	0,	/* %0 */
  /* 82 */	0,	/* %0 */
  /* 83 */	0,	/* %0 */
  /* 84 */	0,	/* %0 */
  /* 85 */	1,	/* mov %%%0,%%%c\n */
  /* 86 */	1,	/* mov %%%0,%%%c\n */
  /* 87 */	1,	/* mov %%%0,%%%c\n */
  /* 88 */	1,	/* mov %%%0,%%%c\n */
  /* 89 */	1,	/* mov %%%0,%%%c\n */
  /* 90 */	1,	/* # reg\n */
  /* 91 */	1,	/* # reg\n */
  /* 92 */	1,	/* # reg\n */
  /* 93 */	1,	/* # reg\n */
  /* 94 */	1,	/* # reg\n */
  /* 95 */	1,	/* set %0,%%%c\n */
  /* 96 */	0,	/* %0 */
  /* 97 */	0,	/* %%%0 */
  /* 98 */	1,	/* add %%%0,%1,%%%c\n */
  /* 99 */	1,	/* add %%%0,%1,%%%c\n */
  /* 100 */	1,	/* add %%%0,%1,%%%c\n */
  /* 101 */	1,	/* and %%%0,%1,%%%c\n */
  /* 102 */	1,	/* or %%%0,%1,%%%c\n */
  /* 103 */	1,	/* xor %%%0,%1,%%%c\n */
  /* 104 */	1,	/* sub %%%0,%1,%%%c\n */
  /* 105 */	1,	/* sub %%%0,%1,%%%c\n */
  /* 106 */	1,	/* sub %%%0,%1,%%%c\n */
  /* 107 */	0,	/* %a */
  /* 108 */	0,	/* %%%0 */
  /* 109 */	1,	/* sll %%%0,%1,%%%c\n */
  /* 110 */	1,	/* sll %%%0,%1,%%%c\n */
  /* 111 */	1,	/* sra %%%0,%1,%%%c\n */
  /* 112 */	1,	/* srl %%%0,%1,%%%c\n */
  /* 113 */	1,	/* andn %%%0,%1,%%%c\n */
  /* 114 */	1,	/* orn %%%0,%1,%%%c\n */
  /* 115 */	1,	/* xnor %%%0,%1,%%%c\n */
  /* 116 */	1,	/* neg %%%0,%%%c\n */
  /* 117 */	1,	/* not %%%0,%%%c\n */
  /* 118 */	1,	/* sll %%%0,24,%%%c; sra %%%c,24,%%%c\n */
  /* 119 */	1,	/* sll %%%0,16,%%%c; sra %%%c,16,%%%c\n */
  /* 120 */	1,	/* and %%%0,0xff,%%%c\n */
  /* 121 */	1,	/* set 0xffff,%%g1; and %%%0,%%g1,%%%c\n */
  /* 122 */	0,	/* %a */
  /* 123 */	1,	/* ba %0; nop\n */
  /* 124 */	1,	/* jmp %0; nop\n */
  /* 125 */	1,	/* %a:\n */
  /* 126 */	1,	/* cmp %%%0,%1; be %a; nop\n */
  /* 127 */	1,	/* cmp %%%0,%1; bge %a; nop\n */
  /* 128 */	1,	/* cmp %%%0,%1; bgeu %a; nop\n */
  /* 129 */	1,	/* cmp %%%0,%1; bg %a; nop\n */
  /* 130 */	1,	/* cmp %%%0,%1; bgu %a; nop\n */
  /* 131 */	1,	/* cmp %%%0,%1; ble %a; nop\n */
  /* 132 */	1,	/* cmp %%%0,%1; bleu %a; nop\n */
  /* 133 */	1,	/* cmp %%%0,%1; bl %a; nop\n */
  /* 134 */	1,	/* cmp %%%0,%1; blu %a; nop\n */
  /* 135 */	1,	/* cmp %%%0,%1; bne %a; nop\n */
  /* 136 */	0,	/* %a */
  /* 137 */	0,	/* %0 */
  /* 138 */	1,	/* call %0; nop\n */
  /* 139 */	1,	/* call %0; nop\n */
  /* 140 */	1,	/* call %0; nop\n */
  /* 141 */	1,	/* call %0; nop\n */
  /* 142 */	1,	/* call %0; st %%%1,[%%sp+64]\n */
  /* 143 */	1,	/* # ret\n */
  /* 144 */	1,	/* # ret\n */
  /* 145 */	1,	/* # ret\n */
  /* 146 */	1,	/* st %%%0,[%%sp+4*%c+68]\n */
  /* 147 */	1,	/* st %%%0,[%%sp+4*%c+68]\n */
  /* 148 */	1,	/* # ARGD\n */
  /* 149 */	1,	/* # ARGF\n */
  /* 150 */	1,	/* call .div,2; nop\n */
  /* 151 */	1,	/* call .udiv,2; nop\n */
  /* 152 */	1,	/* call .rem,2; nop\n */
  /* 153 */	1,	/* call .urem,2; nop\n */
  /* 154 */	1,	/* call .mul,2; nop\n */
  /* 155 */	1,	/* call .umul,2; nop\n */
  /* 156 */	1,	/* faddd %%f%0,%%f%1,%%f%c\n */
  /* 157 */	1,	/* fadds %%f%0,%%f%1,%%f%c\n */
  /* 158 */	1,	/* fdivd %%f%0,%%f%1,%%f%c\n */
  /* 159 */	1,	/* fdivs %%f%0,%%f%1,%%f%c\n */
  /* 160 */	1,	/* fmuld %%f%0,%%f%1,%%f%c\n */
  /* 161 */	1,	/* fmuls %%f%0,%%f%1,%%f%c\n */
  /* 162 */	1,	/* fsubd %%f%0,%%f%1,%%f%c\n */
  /* 163 */	1,	/* fsubs %%f%0,%%f%1,%%f%c\n */
  /* 164 */	1,	/* fnegs %%f%0,%%f%c\n */
  /* 165 */	1,	/* fmovs %%f%0,%%f%c\n */
  /* 166 */	1,	/* fdtos %%f%0,%%f%c\n */
  /* 167 */	1,	/* fstod %%f%0,%%f%c\n */
  /* 168 */	1,	/* fdtoi %%f%0,%%f0; st %%f0,[%%sp+64]; ld [%%sp+64],%%%c\n */
  /* 169 */	1,	/* st %%%0,[%%sp+64]; ld [%%sp+64],%%f%c; fitod %%f%c,%%f%c\n */
  /* 170 */	0,	/* fcmped %%f%0,%%f%1; nop; fbue */
  /* 171 */	0,	/* fcmpes %%f%0,%%f%1; nop; fbue */
  /* 172 */	0,	/* fcmped %%f%0,%%f%1; nop; fbuge */
  /* 173 */	0,	/* fcmpes %%f%0,%%f%1; nop; fbuge */
  /* 174 */	0,	/* fcmped %%f%0,%%f%1; nop; fbug */
  /* 175 */	0,	/* fcmpes %%f%0,%%f%1; nop; fbug */
  /* 176 */	0,	/* fcmped %%f%0,%%f%1; nop; fbule */
  /* 177 */	0,	/* fcmpes %%f%0,%%f%1; nop; fbule */
  /* 178 */	0,	/* fcmped %%f%0,%%f%1; nop; fbul */
  /* 179 */	0,	/* fcmpes %%f%0,%%f%1; nop; fbul */
  /* 180 */	0,	/* fcmped %%f%0,%%f%1; nop; fbne */
  /* 181 */	0,	/* fcmpes %%f%0,%%f%1; nop; fbne */
  /* 182 */	1,	/* %0 %a; nop\n */
  /* 183 */	1,	/* # LOADD\n */
  /* 184 */	1,	/* # NEGD\n */
  /* 185 */	1,	/* # ASGNB\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 */	"stk13: ADDRFP",
  /* 25 */	"stk13: ADDRLP",
  /* 26 */	"reg: stk13",
  /* 27 */	"stk: ADDRFP",
  /* 28 */	"stk: ADDRLP",
  /* 29 */	"reg: ADDRFP",
  /* 30 */	"reg: ADDRLP",
  /* 31 */	"con13: CNSTC",
  /* 32 */	"con13: CNSTI",
  /* 33 */	"con13: CNSTP",
  /* 34 */	"con13: CNSTS",
  /* 35 */	"con13: CNSTU",
  /* 36 */	"base: ADDI(reg,con13)",
  /* 37 */	"base: ADDP(reg,con13)",
  /* 38 */	"base: ADDU(reg,con13)",
  /* 39 */	"base: reg",
  /* 40 */	"base: con13",
  /* 41 */	"base: stk13",
  /* 42 */	"addr: base",
  /* 43 */	"addr: ADDI(reg,reg)",
  /* 44 */	"addr: ADDP(reg,reg)",
  /* 45 */	"addr: ADDU(reg,reg)",
  /* 46 */	"addr: stk",
  /* 47 */	"reg: INDIRC(addr)",
  /* 48 */	"reg: INDIRS(addr)",
  /* 49 */	"reg: INDIRI(addr)",
  /* 50 */	"reg: INDIRP(addr)",
  /* 51 */	"reg: INDIRF(addr)",
  /* 52 */	"stmt: ASGNC(addr,reg)",
  /* 53 */	"stmt: ASGNS(addr,reg)",
  /* 54 */	"stmt: ASGNI(addr,reg)",
  /* 55 */	"stmt: ASGNP(addr,reg)",
  /* 56 */	"stmt: ASGNF(addr,reg)",
  /* 57 */	"addrl: ADDRLP",
  /* 58 */	"reg: INDIRD(addrl)",
  /* 59 */	"stmt: ASGND(addrl,reg)",
  /* 60 */	"reg: INDIRD(base)",
  /* 61 */	"stmt: ASGND(base,reg)",
  /* 62 */	"spill: ADDRLP",
  /* 63 */	"stmt: ASGNC(spill,reg)",
  /* 64 */	"stmt: ASGNS(spill,reg)",
  /* 65 */	"stmt: ASGNI(spill,reg)",
  /* 66 */	"stmt: ASGNP(spill,reg)",
  /* 67 */	"stmt: ASGNF(spill,reg)",
  /* 68 */	"stmt: ASGND(spill,reg)",
  /* 69 */	"reg: CVCI(INDIRC(addr))",
  /* 70 */	"reg: CVSI(INDIRS(addr))",
  /* 71 */	"reg: CVCU(INDIRC(addr))",
  /* 72 */	"reg: CVSU(INDIRS(addr))",
  /* 73 */	"reg: CVIC(reg)",
  /* 74 */	"reg: CVIS(reg)",
  /* 75 */	"reg: CVIU(reg)",
  /* 76 */	"reg: CVPU(reg)",
  /* 77 */	"reg: CVUC(reg)",
  /* 78 */	"reg: CVUI(reg)",
  /* 79 */	"reg: CVUP(reg)",
  /* 80 */	"reg: CVUS(reg)",
  /* 81 */	"reg: CVIC(reg)",
  /* 82 */	"reg: CVIS(reg)",
  /* 83 */	"reg: CVUC(reg)",
  /* 84 */	"reg: CVUS(reg)",
  /* 85 */	"reg: LOADC(reg)",
  /* 86 */	"reg: LOADI(reg)",
  /* 87 */	"reg: LOADP(reg)",
  /* 88 */	"reg: LOADS(reg)",
  /* 89 */	"reg: LOADU(reg)",
  /* 90 */	"reg: CNSTC",
  /* 91 */	"reg: CNSTI",
  /* 92 */	"reg: CNSTP",
  /* 93 */	"reg: CNSTS",
  /* 94 */	"reg: CNSTU",
  /* 95 */	"reg: con",
  /* 96 */	"rc: con13",
  /* 97 */	"rc: reg",
  /* 98 */	"reg: ADDI(reg,rc)",
  /* 99 */	"reg: ADDP(reg,rc)",
  /* 100 */	"reg: ADDU(reg,rc)",
  /* 101 */	"reg: BANDU(reg,rc)",
  /* 102 */	"reg: BORU(reg,rc)",
  /* 103 */	"reg: BXORU(reg,rc)",
  /* 104 */	"reg: SUBI(reg,rc)",
  /* 105 */	"reg: SUBP(reg,rc)",
  /* 106 */	"reg: SUBU(reg,rc)",
  /* 107 */	"rc5: CNSTI",
  /* 108 */	"rc5: reg",
  /* 109 */	"reg: LSHI(reg,rc5)",
  /* 110 */	"reg: LSHU(reg,rc5)",
  /* 111 */	"reg: RSHI(reg,rc5)",
  /* 112 */	"reg: RSHU(reg,rc5)",
  /* 113 */	"reg: BANDU(reg,BCOMU(rc))",
  /* 114 */	"reg: BORU(reg,BCOMU(rc))",
  /* 115 */	"reg: BXORU(reg,BCOMU(rc))",
  /* 116 */	"reg: NEGI(reg)",
  /* 117 */	"reg: BCOMU(reg)",
  /* 118 */	"reg: CVCI(reg)",
  /* 119 */	"reg: CVSI(reg)",
  /* 120 */	"reg: CVCU(reg)",
  /* 121 */	"reg: CVSU(reg)",
  /* 122 */	"addrg: ADDRGP",
  /* 123 */	"stmt: JUMPV(addrg)",
  /* 124 */	"stmt: JUMPV(addr)",
  /* 125 */	"stmt: LABELV",
  /* 126 */	"stmt: EQI(reg,rc)",
  /* 127 */	"stmt: GEI(reg,rc)",
  /* 128 */	"stmt: GEU(reg,rc)",
  /* 129 */	"stmt: GTI(reg,rc)",
  /* 130 */	"stmt: GTU(reg,rc)",
  /* 131 */	"stmt: LEI(reg,rc)",
  /* 132 */	"stmt: LEU(reg,rc)",
  /* 133 */	"stmt: LTI(reg,rc)",
  /* 134 */	"stmt: LTU(reg,rc)",
  /* 135 */	"stmt: NEI(reg,rc)",
  /* 136 */	"call: ADDRGP",
  /* 137 */	"call: addr",
  /* 138 */	"reg: CALLD(call)",
  /* 139 */	"reg: CALLF(call)",
  /* 140 */	"reg: CALLI(call)",
  /* 141 */	"stmt: CALLV(call)",
  /* 142 */	"stmt: CALLB(call,reg)",
  /* 143 */	"stmt: RETD(reg)",
  /* 144 */	"stmt: RETF(reg)",
  /* 145 */	"stmt: RETI(reg)",
  /* 146 */	"stmt: ARGI(reg)",
  /* 147 */	"stmt: ARGP(reg)",
  /* 148 */	"stmt: ARGD(reg)",
  /* 149 */	"stmt: ARGF(reg)",
  /* 150 */	"reg: DIVI(reg,reg)",
  /* 151 */	"reg: DIVU(reg,reg)",
  /* 152 */	"reg: MODI(reg,reg)",
  /* 153 */	"reg: MODU(reg,reg)",
  /* 154 */	"reg: MULI(reg,reg)",
  /* 155 */	"reg: MULU(reg,reg)",
  /* 156 */	"reg: ADDD(reg,reg)",
  /* 157 */	"reg: ADDF(reg,reg)",
  /* 158 */	"reg: DIVD(reg,reg)",
  /* 159 */	"reg: DIVF(reg,reg)",
  /* 160 */	"reg: MULD(reg,reg)",
  /* 161 */	"reg: MULF(reg,reg)",
  /* 162 */	"reg: SUBD(reg,reg)",
  /* 163 */	"reg: SUBF(reg,reg)",
  /* 164 */	"reg: NEGF(reg)",
  /* 165 */	"reg: LOADF(reg)",
  /* 166 */	"reg: CVDF(reg)",
  /* 167 */	"reg: CVFD(reg)",
  /* 168 */	"reg: CVDI(reg)",
  /* 169 */	"reg: CVID(reg)",
  /* 170 */	"rel: EQD(reg,reg)",
  /* 171 */	"rel: EQF(reg,reg)",
  /* 172 */	"rel: GED(reg,reg)",
  /* 173 */	"rel: GEF(reg,reg)",
  /* 174 */	"rel: GTD(reg,reg)",
  /* 175 */	"rel: GTF(reg,reg)",
  /* 176 */	"rel: LED(reg,reg)",
  /* 177 */	"rel: LEF(reg,reg)",
  /* 178 */	"rel: LTD(reg,reg)",
  /* 179 */	"rel: LTF(reg,reg)",
  /* 180 */	"rel: NED(reg,reg)",
  /* 181 */	"rel: NEF(reg,reg)",
  /* 182 */	"stmt: rel",
  /* 183 */	"reg: LOADD(reg)",
  /* 184 */	"reg: NEGD(reg)",
  /* 185 */	"stmt: ASGNB(reg,INDIRB(reg))",
  };
  
  static short _decode_stmt[] = {
  	0,
  	7,
  	8,
  	9,
  	10,
  	11,
  	12,
  	18,
  	52,
  	53,
  	54,
  	55,
  	56,
  	59,
  	61,
  	63,
  	64,
  	65,
  	66,
  	67,
  	68,
  	123,
  	124,
  	125,
  	126,
  	127,
  	128,
  	129,
  	130,
  	131,
  	132,
  	133,
  	134,
  	135,
  	141,
  	142,
  	143,
  	144,
  	145,
  	146,
  	147,
  	148,
  	149,
  	182,
  	185,
  };
  
  static short _decode_reg[] = {
  	0,
  	1,
  	2,
  	3,
  	4,
  	5,
  	6,
  	19,
  	20,
  	21,
  	22,
  	23,
  	26,
  	29,
  	30,
  	47,
  	48,
  	49,
  	50,
  	51,
  	58,
  	60,
  	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,
  	98,
  	99,
  	100,
  	101,
  	102,
  	103,
  	104,
  	105,
  	106,
  	109,
  	110,
  	111,
  	112,
  	113,
  	114,
  	115,
  	116,
  	117,
  	118,
  	119,
  	120,
  	121,
  	138,
  	139,
  	140,
  	150,
  	151,
  	152,
  	153,
  	154,
  	155,
  	156,
  	157,
  	158,
  	159,
  	160,
  	161,
  	162,
  	163,
  	164,
  	165,
  	166,
  	167,
  	168,
  	169,
  	183,
  	184,
  };
  
  static short _decode_con[] = {
  	0,
  	13,
  	14,
  	15,
  	16,
  	17,
  };
  
  static short _decode_stk13[] = {
  	0,
  	24,
  	25,
  };
  
  static short _decode_stk[] = {
  	0,
  	27,
  	28,
  };
  
  static short _decode_con13[] = {
  	0,
  	31,
  	32,
  	33,
  	34,
  	35,
  };
  
  static short _decode_base[] = {
  	0,
  	36,
  	37,
  	38,
  	39,
  	40,
  	41,
  };
  
  static short _decode_addr[] = {
  	0,
  	42,
  	43,
  	44,
  	45,
  	46,
  };
  
  static short _decode_addrl[] = {
  	0,
  	57,
  };
  
  static short _decode_spill[] = {
  	0,
  	62,
  };
  
  static short _decode_rc[] = {
  	0,
  	96,
  	97,
  };
  
  static short _decode_rc5[] = {
  	0,
  	107,
  	108,
  };
  
  static short _decode_addrg[] = {
  	0,
  	122,
  };
  
  static short _decode_call[] = {
  	0,
  	136,
  	137,
  };
  
  static short _decode_rel[] = {
  	0,
  	170,
  	171,
  	172,
  	173,
  	174,
  	175,
  	176,
  	177,
  	178,
  	179,
  	180,
  	181,
  };
  
  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 _stk13_NT:	return _decode_stk13[((struct _state *)state)->rule._stk13];
  	case _stk_NT:	return _decode_stk[((struct _state *)state)->rule._stk];
  	case _con13_NT:	return _decode_con13[((struct _state *)state)->rule._con13];
  	case _base_NT:	return _decode_base[((struct _state *)state)->rule._base];
  	case _addr_NT:	return _decode_addr[((struct _state *)state)->rule._addr];
  	case _addrl_NT:	return _decode_addrl[((struct _state *)state)->rule._addrl];
  	case _spill_NT:	return _decode_spill[((struct _state *)state)->rule._spill];
  	case _rc_NT:	return _decode_rc[((struct _state *)state)->rule._rc];
  	case _rc5_NT:	return _decode_rc5[((struct _state *)state)->rule._rc5];
  	case _addrg_NT:	return _decode_addrg[((struct _state *)state)->rule._addrg];
  	case _call_NT:	return _decode_call[((struct _state *)state)->rule._call];
  	case _rel_NT:	return _decode_rel[((struct _state *)state)->rule._rel];
  	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_stk13 ARGS((NODEPTR_TYPE, int));
  static void _closure_stk ARGS((NODEPTR_TYPE, int));
  static void _closure_con13 ARGS((NODEPTR_TYPE, int));
  static void _closure_base ARGS((NODEPTR_TYPE, int));
  static void _closure_addr ARGS((NODEPTR_TYPE, int));
  static void _closure_rel 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[_rc5_NT]) {
  		p->cost[_rc5_NT] = c + 0;
  		p->rule._rc5 = 2;
  	}
  	if (c + 0 < p->cost[_rc_NT]) {
  		p->cost[_rc_NT] = c + 0;
  		p->rule._rc = 2;
  	}
  	if (c + 0 < p->cost[_base_NT]) {
  		p->cost[_base_NT] = c + 0;
  		p->rule._base = 4;
  		_closure_base(a, c + 0);
  	}
  	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[_reg_NT]) {
  		p->cost[_reg_NT] = c + 1;
  		p->rule._reg = 48;
  		_closure_reg(a, c + 1);
  	}
  }
  
  static void _closure_stk13(a, c) NODEPTR_TYPE a; int c; {
  	struct _state *p = STATE_LABEL(a);
  	if (c + 0 < p->cost[_base_NT]) {
  		p->cost[_base_NT] = c + 0;
  		p->rule._base = 6;
  		_closure_base(a, c + 0);
  	}
  	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_stk(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 = 5;
  		_closure_addr(a, c + 0);
  	}
  }
  
  static void _closure_con13(a, c) NODEPTR_TYPE a; int c; {
  	struct _state *p = STATE_LABEL(a);
  	if (c + 0 < p->cost[_rc_NT]) {
  		p->cost[_rc_NT] = c + 0;
  		p->rule._rc = 1;
  	}
  	if (c + 0 < p->cost[_base_NT]) {
  		p->cost[_base_NT] = c + 0;
  		p->rule._base = 5;
  		_closure_base(a, c + 0);
  	}
  }
  
  static void _closure_base(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;
  		_closure_addr(a, c + 0);
  	}
  }
  
  static void _closure_addr(a, c) NODEPTR_TYPE a; int c; {
  	struct _state *p = STATE_LABEL(a);
  	if (c + 0 < p->cost[_call_NT]) {
  		p->cost[_call_NT] = c + 0;
  		p->rule._call = 2;
  	}
  }
  
  static void _closure_rel(a, c) NODEPTR_TYPE a; int c; {
  	struct _state *p = STATE_LABEL(a);
  	if (c + 4 < p->cost[_stmt_NT]) {
  		p->cost[_stmt_NT] = c + 4;
  		p->rule._stmt = 43;
  	}
  }
  
  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);
  		}
  		/* con13: CNSTC */
  		c = imm(a);
  		if (c + 0 < p->cost[_con13_NT]) {
  			p->cost[_con13_NT] = c + 0;
  			p->rule._con13 = 1;
  			_closure_con13(a, c + 0);
  		}
  		/* reg: CNSTC */
  		c = range(a, 0, 0);
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 43;
  			_closure_reg(a, c + 0);
  		}
  		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);
  		}
  		/* con13: CNSTS */
  		c = imm(a);
  		if (c + 0 < p->cost[_con13_NT]) {
  			p->cost[_con13_NT] = c + 0;
  			p->rule._con13 = 4;
  			_closure_con13(a, c + 0);
  		}
  		/* reg: CNSTS */
  		c = range(a, 0, 0);
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 46;
  			_closure_reg(a, c + 0);
  		}
  		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);
  		}
  		/* con13: CNSTI */
  		c = imm(a);
  		if (c + 0 < p->cost[_con13_NT]) {
  			p->cost[_con13_NT] = c + 0;
  			p->rule._con13 = 2;
  			_closure_con13(a, c + 0);
  		}
  		/* reg: CNSTI */
  		c = range(a, 0, 0);
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 44;
  			_closure_reg(a, c + 0);
  		}
  		/* rc5: CNSTI */
  		c = range(a, 0, 31);
  		if (c + 0 < p->cost[_rc5_NT]) {
  			p->cost[_rc5_NT] = c + 0;
  			p->rule._rc5 = 1;
  		}
  		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);
  		}
  		/* con13: CNSTU */
  		c = imm(a);
  		if (c + 0 < p->cost[_con13_NT]) {
  			p->cost[_con13_NT] = c + 0;
  			p->rule._con13 = 5;
  			_closure_con13(a, c + 0);
  		}
  		/* reg: CNSTU */
  		c = range(a, 0, 0);
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 47;
  			_closure_reg(a, c + 0);
  		}
  		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);
  		}
  		/* con13: CNSTP */
  		c = imm(a);
  		if (c + 0 < p->cost[_con13_NT]) {
  			p->cost[_con13_NT] = c + 0;
  			p->rule._con13 = 3;
  			_closure_con13(a, c + 0);
  		}
  		/* reg: CNSTP */
  		c = range(a, 0, 0);
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 45;
  			_closure_reg(a, c + 0);
  		}
  		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 = 42;
  		}
  		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 = 41;
  		}
  		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 = 39;
  		}
  		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 = 40;
  		}
  		break;
  	case 41: /* ARGB */
  		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 = 12;
  		}
  		/* stmt: ASGNF(spill,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 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(addrl,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrl_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: ASGND(base,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_base_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 = 14;
  		}
  		/* stmt: ASGND(spill,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 20;
  		}
  		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(spill,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 15;
  		}
  		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(spill,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 16;
  		}
  		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(spill,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 17;
  		}
  		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(spill,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_spill_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_reg_NT] + 0;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 18;
  		}
  		break;
  	case 57: /* ASGNB */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		if (	/* stmt: ASGNB(reg,INDIRB(reg)) */
  			RIGHT_CHILD(a)->op == 73 /* INDIRB */
  		) {
  			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_reg_NT] + 0;
  			if (c + 0 < p->cost[_stmt_NT]) {
  				p->cost[_stmt_NT] = c + 0;
  				p->rule._stmt = 44;
  			}
  		}
  		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[_stk13_NT] == 0) {
  					p->cost[_stk13_NT] = 0;
  					p->rule._stk13 = q->rule._stk13;
  				}
  				if (q->cost[_stk_NT] == 0) {
  					p->cost[_stk_NT] = 0;
  					p->rule._stk = q->rule._stk;
  				}
  				if (q->cost[_con13_NT] == 0) {
  					p->cost[_con13_NT] = 0;
  					p->rule._con13 = q->rule._con13;
  				}
  				if (q->cost[_base_NT] == 0) {
  					p->cost[_base_NT] = 0;
  					p->rule._base = q->rule._base;
  				}
  				if (q->cost[_addr_NT] == 0) {
  					p->cost[_addr_NT] = 0;
  					p->rule._addr = q->rule._addr;
  				}
  				if (q->cost[_addrl_NT] == 0) {
  					p->cost[_addrl_NT] = 0;
  					p->rule._addrl = q->rule._addrl;
  				}
  				if (q->cost[_spill_NT] == 0) {
  					p->cost[_spill_NT] = 0;
  					p->rule._spill = q->rule._spill;
  				}
  				if (q->cost[_rc_NT] == 0) {
  					p->cost[_rc_NT] = 0;
  					p->rule._rc = q->rule._rc;
  				}
  				if (q->cost[_rc5_NT] == 0) {
  					p->cost[_rc5_NT] = 0;
  					p->rule._rc5 = q->rule._rc5;
  				}
  				if (q->cost[_addrg_NT] == 0) {
  					p->cost[_addrg_NT] = 0;
  					p->rule._addrg = q->rule._addrg;
  				}
  				if (q->cost[_call_NT] == 0) {
  					p->cost[_call_NT] = 0;
  					p->rule._call = q->rule._call;
  				}
  				if (q->cost[_rel_NT] == 0) {
  					p->cost[_rel_NT] = 0;
  					p->rule._rel = q->rule._rel;
  				}
  			}
  			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 = 19;
  			_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[_stk13_NT] == 0) {
  					p->cost[_stk13_NT] = 0;
  					p->rule._stk13 = q->rule._stk13;
  				}
  				if (q->cost[_stk_NT] == 0) {
  					p->cost[_stk_NT] = 0;
  					p->rule._stk = q->rule._stk;
  				}
  				if (q->cost[_con13_NT] == 0) {
  					p->cost[_con13_NT] = 0;
  					p->rule._con13 = q->rule._con13;
  				}
  				if (q->cost[_base_NT] == 0) {
  					p->cost[_base_NT] = 0;
  					p->rule._base = q->rule._base;
  				}
  				if (q->cost[_addr_NT] == 0) {
  					p->cost[_addr_NT] = 0;
  					p->rule._addr = q->rule._addr;
  				}
  				if (q->cost[_addrl_NT] == 0) {
  					p->cost[_addrl_NT] = 0;
  					p->rule._addrl = q->rule._addrl;
  				}
  				if (q->cost[_spill_NT] == 0) {
  					p->cost[_spill_NT] = 0;
  					p->rule._spill = q->rule._spill;
  				}
  				if (q->cost[_rc_NT] == 0) {
  					p->cost[_rc_NT] = 0;
  					p->rule._rc = q->rule._rc;
  				}
  				if (q->cost[_rc5_NT] == 0) {
  					p->cost[_rc5_NT] = 0;
  					p->rule._rc5 = q->rule._rc5;
  				}
  				if (q->cost[_addrg_NT] == 0) {
  					p->cost[_addrg_NT] = 0;
  					p->rule._addrg = q->rule._addrg;
  				}
  				if (q->cost[_call_NT] == 0) {
  					p->cost[_call_NT] = 0;
  					p->rule._call = q->rule._call;
  				}
  				if (q->cost[_rel_NT] == 0) {
  					p->cost[_rel_NT] = 0;
  					p->rule._rel = q->rule._rel;
  				}
  			}
  			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(addrl) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrl_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: INDIRD(base) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_base_NT] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 21;
  			_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[_stk13_NT] == 0) {
  					p->cost[_stk13_NT] = 0;
  					p->rule._stk13 = q->rule._stk13;
  				}
  				if (q->cost[_stk_NT] == 0) {
  					p->cost[_stk_NT] = 0;
  					p->rule._stk = q->rule._stk;
  				}
  				if (q->cost[_con13_NT] == 0) {
  					p->cost[_con13_NT] = 0;
  					p->rule._con13 = q->rule._con13;
  				}
  				if (q->cost[_base_NT] == 0) {
  					p->cost[_base_NT] = 0;
  					p->rule._base = q->rule._base;
  				}
  				if (q->cost[_addr_NT] == 0) {
  					p->cost[_addr_NT] = 0;
  					p->rule._addr = q->rule._addr;
  				}
  				if (q->cost[_addrl_NT] == 0) {
  					p->cost[_addrl_NT] = 0;
  					p->rule._addrl = q->rule._addrl;
  				}
  				if (q->cost[_spill_NT] == 0) {
  					p->cost[_spill_NT] = 0;
  					p->rule._spill = q->rule._spill;
  				}
  				if (q->cost[_rc_NT] == 0) {
  					p->cost[_rc_NT] = 0;
  					p->rule._rc = q->rule._rc;
  				}
  				if (q->cost[_rc5_NT] == 0) {
  					p->cost[_rc5_NT] = 0;
  					p->rule._rc5 = q->rule._rc5;
  				}
  				if (q->cost[_addrg_NT] == 0) {
  					p->cost[_addrg_NT] = 0;
  					p->rule._addrg = q->rule._addrg;
  				}
  				if (q->cost[_call_NT] == 0) {
  					p->cost[_call_NT] = 0;
  					p->rule._call = q->rule._call;
  				}
  				if (q->cost[_rel_NT] == 0) {
  					p->cost[_rel_NT] = 0;
  					p->rule._rel = q->rule._rel;
  				}
  			}
  			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 = 15;
  			_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[_stk13_NT] == 0) {
  					p->cost[_stk13_NT] = 0;
  					p->rule._stk13 = q->rule._stk13;
  				}
  				if (q->cost[_stk_NT] == 0) {
  					p->cost[_stk_NT] = 0;
  					p->rule._stk = q->rule._stk;
  				}
  				if (q->cost[_con13_NT] == 0) {
  					p->cost[_con13_NT] = 0;
  					p->rule._con13 = q->rule._con13;
  				}
  				if (q->cost[_base_NT] == 0) {
  					p->cost[_base_NT] = 0;
  					p->rule._base = q->rule._base;
  				}
  				if (q->cost[_addr_NT] == 0) {
  					p->cost[_addr_NT] = 0;
  					p->rule._addr = q->rule._addr;
  				}
  				if (q->cost[_addrl_NT] == 0) {
  					p->cost[_addrl_NT] = 0;
  					p->rule._addrl = q->rule._addrl;
  				}
  				if (q->cost[_spill_NT] == 0) {
  					p->cost[_spill_NT] = 0;
  					p->rule._spill = q->rule._spill;
  				}
  				if (q->cost[_rc_NT] == 0) {
  					p->cost[_rc_NT] = 0;
  					p->rule._rc = q->rule._rc;
  				}
  				if (q->cost[_rc5_NT] == 0) {
  					p->cost[_rc5_NT] = 0;
  					p->rule._rc5 = q->rule._rc5;
  				}
  				if (q->cost[_addrg_NT] == 0) {
  					p->cost[_addrg_NT] = 0;
  					p->rule._addrg = q->rule._addrg;
  				}
  				if (q->cost[_call_NT] == 0) {
  					p->cost[_call_NT] = 0;
  					p->rule._call = q->rule._call;
  				}
  				if (q->cost[_rel_NT] == 0) {
  					p->cost[_rel_NT] = 0;
  					p->rule._rel = q->rule._rel;
  				}
  			}
  			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 = 16;
  			_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[_stk13_NT] == 0) {
  					p->cost[_stk13_NT] = 0;
  					p->rule._stk13 = q->rule._stk13;
  				}
  				if (q->cost[_stk_NT] == 0) {
  					p->cost[_stk_NT] = 0;
  					p->rule._stk = q->rule._stk;
  				}
  				if (q->cost[_con13_NT] == 0) {
  					p->cost[_con13_NT] = 0;
  					p->rule._con13 = q->rule._con13;
  				}
  				if (q->cost[_base_NT] == 0) {
  					p->cost[_base_NT] = 0;
  					p->rule._base = q->rule._base;
  				}
  				if (q->cost[_addr_NT] == 0) {
  					p->cost[_addr_NT] = 0;
  					p->rule._addr = q->rule._addr;
  				}
  				if (q->cost[_addrl_NT] == 0) {
  					p->cost[_addrl_NT] = 0;
  					p->rule._addrl = q->rule._addrl;
  				}
  				if (q->cost[_spill_NT] == 0) {
  					p->cost[_spill_NT] = 0;
  					p->rule._spill = q->rule._spill;
  				}
  				if (q->cost[_rc_NT] == 0) {
  					p->cost[_rc_NT] = 0;
  					p->rule._rc = q->rule._rc;
  				}
  				if (q->cost[_rc5_NT] == 0) {
  					p->cost[_rc5_NT] = 0;
  					p->rule._rc5 = q->rule._rc5;
  				}
  				if (q->cost[_addrg_NT] == 0) {
  					p->cost[_addrg_NT] = 0;
  					p->rule._addrg = q->rule._addrg;
  				}
  				if (q->cost[_call_NT] == 0) {
  					p->cost[_call_NT] = 0;
  					p->rule._call = q->rule._call;
  				}
  				if (q->cost[_rel_NT] == 0) {
  					p->cost[_rel_NT] = 0;
  					p->rule._rel = q->rule._rel;
  				}
  			}
  			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 = 17;
  			_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[_stk13_NT] == 0) {
  					p->cost[_stk13_NT] = 0;
  					p->rule._stk13 = q->rule._stk13;
  				}
  				if (q->cost[_stk_NT] == 0) {
  					p->cost[_stk_NT] = 0;
  					p->rule._stk = q->rule._stk;
  				}
  				if (q->cost[_con13_NT] == 0) {
  					p->cost[_con13_NT] = 0;
  					p->rule._con13 = q->rule._con13;
  				}
  				if (q->cost[_base_NT] == 0) {
  					p->cost[_base_NT] = 0;
  					p->rule._base = q->rule._base;
  				}
  				if (q->cost[_addr_NT] == 0) {
  					p->cost[_addr_NT] = 0;
  					p->rule._addr = q->rule._addr;
  				}
  				if (q->cost[_addrl_NT] == 0) {
  					p->cost[_addrl_NT] = 0;
  					p->rule._addrl = q->rule._addrl;
  				}
  				if (q->cost[_spill_NT] == 0) {
  					p->cost[_spill_NT] = 0;
  					p->rule._spill = q->rule._spill;
  				}
  				if (q->cost[_rc_NT] == 0) {
  					p->cost[_rc_NT] = 0;
  					p->rule._rc = q->rule._rc;
  				}
  				if (q->cost[_rc5_NT] == 0) {
  					p->cost[_rc5_NT] = 0;
  					p->rule._rc5 = q->rule._rc5;
  				}
  				if (q->cost[_addrg_NT] == 0) {
  					p->cost[_addrg_NT] = 0;
  					p->rule._addrg = q->rule._addrg;
  				}
  				if (q->cost[_call_NT] == 0) {
  					p->cost[_call_NT] = 0;
  					p->rule._call = q->rule._call;
  				}
  				if (q->cost[_rel_NT] == 0) {
  					p->cost[_rel_NT] = 0;
  					p->rule._rel = q->rule._rel;
  				}
  			}
  			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 = 18;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 73: /* INDIRB */
  		_label(LEFT_CHILD(a));
  		break;
  	case 85: /* CVCI */
  		_label(LEFT_CHILD(a));
  		if (	/* reg: CVCI(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 = 22;
  				_closure_reg(a, c + 0);
  			}
  		}
  		/* reg: CVCI(reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 67;
  			_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 = 24;
  				_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 = 69;
  			_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] + 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 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 = 92;
  			_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] + 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 130: /* CVID */
  		_label(LEFT_CHILD(a));
  		/* reg: CVID(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 = 93;
  			_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 = 26;
  			_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 = 34;
  			_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 = 27;
  			_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 = 35;
  			_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 = 28;
  			_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 = 29;
  			_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 = 23;
  				_closure_reg(a, c + 0);
  			}
  		}
  		/* reg: CVSI(reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 68;
  			_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 = 25;
  				_closure_reg(a, c + 0);
  			}
  		}
  		/* reg: CVSU(reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 70;
  			_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 = 30;
  			_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 = 36;
  			_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 = 33;
  			_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 = 37;
  			_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 = 31;
  			_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 = 32;
  			_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 = 88;
  			_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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 95;
  			_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 = 65;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 209: /* CALLF */
  		_label(LEFT_CHILD(a));
  		/* reg: CALLF(call) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_call_NT] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 72;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 210: /* CALLD */
  		_label(LEFT_CHILD(a));
  		/* reg: CALLD(call) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_call_NT] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 71;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 213: /* CALLI */
  		_label(LEFT_CHILD(a));
  		/* reg: CALLI(call) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_call_NT] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 73;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 216: /* CALLV */
  		_label(LEFT_CHILD(a));
  		/* stmt: CALLV(call) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_call_NT] + 2;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 34;
  		}
  		break;
  	case 217: /* CALLB */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: CALLB(call,reg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_call_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;
  		}
  		break;
  	case 225: /* LOADF */
  		_label(LEFT_CHILD(a));
  		/* reg: LOADF(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 = 89;
  			_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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 94;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 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 = 38;
  			_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 = 41;
  			_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 = 39;
  			_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 = 42;
  			_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 = 40;
  			_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 = 37;
  		}
  		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 = 36;
  		}
  		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 = 38;
  		}
  		break;
  	case 263: /* ADDRGP */
  		/* reg: ADDRGP */
  		c = 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 11;
  			_closure_reg(a, c + 0);
  		}
  		/* addrg: ADDRGP */
  		c = 0;
  		if (c + 0 < p->cost[_addrg_NT]) {
  			p->cost[_addrg_NT] = c + 0;
  			p->rule._addrg = 1;
  		}
  		/* call: ADDRGP */
  		c = 0;
  		if (c + 0 < p->cost[_call_NT]) {
  			p->cost[_call_NT] = c + 0;
  			p->rule._call = 1;
  		}
  		break;
  	case 279: /* ADDRFP */
  		/* stk13: ADDRFP */
  		c = imm(a);
  		if (c + 0 < p->cost[_stk13_NT]) {
  			p->cost[_stk13_NT] = c + 0;
  			p->rule._stk13 = 1;
  			_closure_stk13(a, c + 0);
  		}
  		/* stk: ADDRFP */
  		c = 2;
  		if (c + 0 < p->cost[_stk_NT]) {
  			p->cost[_stk_NT] = c + 0;
  			p->rule._stk = 1;
  			_closure_stk(a, c + 0);
  		}
  		/* reg: ADDRFP */
  		c = 3;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 13;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 295: /* ADDRLP */
  		/* stk13: ADDRLP */
  		c = imm(a);
  		if (c + 0 < p->cost[_stk13_NT]) {
  			p->cost[_stk13_NT] = c + 0;
  			p->rule._stk13 = 2;
  			_closure_stk13(a, c + 0);
  		}
  		/* stk: ADDRLP */
  		c = 2;
  		if (c + 0 < p->cost[_stk_NT]) {
  			p->cost[_stk_NT] = c + 0;
  			p->rule._stk = 2;
  			_closure_stk(a, c + 0);
  		}
  		/* reg: ADDRLP */
  		c = 3;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 14;
  			_closure_reg(a, c + 0);
  		}
  		/* addrl: ADDRLP */
  		c = imm(a);
  		if (c + 0 < p->cost[_addrl_NT]) {
  			p->cost[_addrl_NT] = c + 0;
  			p->rule._addrl = 1;
  		}
  		/* spill: ADDRLP */
  		c = !imm(a);
  		if (c + 0 < p->cost[_spill_NT]) {
  			p->cost[_spill_NT] = c + 0;
  			p->rule._spill = 1;
  		}
  		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 = 81;
  			_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 = 80;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 309: /* ADDI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* base: ADDI(reg,con13) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con13_NT] + 0;
  		if (c + 0 < p->cost[_base_NT]) {
  			p->cost[_base_NT] = c + 0;
  			p->rule._base = 1;
  			_closure_base(a, c + 0);
  		}
  		/* addr: 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[_addr_NT]) {
  			p->cost[_addr_NT] = c + 0;
  			p->rule._addr = 2;
  			_closure_addr(a, c + 0);
  		}
  		/* reg: ADDI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 49;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 310: /* ADDU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* base: ADDU(reg,con13) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con13_NT] + 0;
  		if (c + 0 < p->cost[_base_NT]) {
  			p->cost[_base_NT] = c + 0;
  			p->rule._base = 3;
  			_closure_base(a, c + 0);
  		}
  		/* addr: 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[_addr_NT]) {
  			p->cost[_addr_NT] = c + 0;
  			p->rule._addr = 4;
  			_closure_addr(a, c + 0);
  		}
  		/* reg: ADDU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 51;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 311: /* ADDP */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* base: ADDP(reg,con13) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con13_NT] + 0;
  		if (c + 0 < p->cost[_base_NT]) {
  			p->cost[_base_NT] = c + 0;
  			p->rule._base = 2;
  			_closure_base(a, c + 0);
  		}
  		/* addr: 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[_addr_NT]) {
  			p->cost[_addr_NT] = c + 0;
  			p->rule._addr = 3;
  			_closure_addr(a, c + 0);
  		}
  		/* reg: ADDP(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 50;
  			_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 = 87;
  			_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 = 86;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 325: /* SUBI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: SUBI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 55;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 326: /* SUBU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: SUBU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 57;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 327: /* SUBP */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: SUBP(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 56;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 341: /* LSHI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: LSHI(reg,rc5) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 58;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 342: /* LSHU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: LSHU(reg,rc5) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_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 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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 76;
  			_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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 77;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 373: /* RSHI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: RSHI(reg,rc5) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 60;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 374: /* RSHU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: RSHU(reg,rc5) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc5_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 390: /* BANDU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: BANDU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 52;
  			_closure_reg(a, c + 0);
  		}
  		if (	/* reg: BANDU(reg,BCOMU(rc)) */
  			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[_rc_NT] + 1;
  			if (c + 0 < p->cost[_reg_NT]) {
  				p->cost[_reg_NT] = c + 0;
  				p->rule._reg = 62;
  				_closure_reg(a, c + 0);
  			}
  		}
  		break;
  	case 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);
  		}
  		break;
  	case 422: /* BORU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: BORU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 53;
  			_closure_reg(a, c + 0);
  		}
  		if (	/* reg: BORU(reg,BCOMU(rc)) */
  			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[_rc_NT] + 1;
  			if (c + 0 < p->cost[_reg_NT]) {
  				p->cost[_reg_NT] = c + 0;
  				p->rule._reg = 63;
  				_closure_reg(a, c + 0);
  			}
  		}
  		break;
  	case 438: /* BXORU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* reg: BXORU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 1;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 54;
  			_closure_reg(a, c + 0);
  		}
  		if (	/* reg: BXORU(reg,BCOMU(rc)) */
  			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[_rc_NT] + 1;
  			if (c + 0 < p->cost[_reg_NT]) {
  				p->cost[_reg_NT] = c + 0;
  				p->rule._reg = 64;
  				_closure_reg(a, c + 0);
  			}
  		}
  		break;
  	case 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 = 83;
  			_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 = 82;
  			_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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 74;
  			_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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 75;
  			_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 = 85;
  			_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 = 84;
  			_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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 78;
  			_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] + 2;
  		if (c + 0 < p->cost[_reg_NT]) {
  			p->cost[_reg_NT] = c + 0;
  			p->rule._reg = 79;
  			_closure_reg(a, c + 0);
  		}
  		break;
  	case 481: /* EQF */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: EQF(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 2;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 482: /* EQD */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: EQD(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 1;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 485: /* EQI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: EQI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 24;
  		}
  		break;
  	case 497: /* GEF */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: GEF(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 4;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 498: /* GED */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: GED(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 3;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 501: /* GEI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: GEI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 25;
  		}
  		break;
  	case 502: /* GEU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: GEU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 26;
  		}
  		break;
  	case 513: /* GTF */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: GTF(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 6;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 514: /* GTD */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: GTD(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 5;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 517: /* GTI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: GTI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 27;
  		}
  		break;
  	case 518: /* GTU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: GTU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 28;
  		}
  		break;
  	case 529: /* LEF */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: LEF(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 8;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 530: /* LED */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: LED(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 7;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 533: /* LEI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: LEI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 29;
  		}
  		break;
  	case 534: /* LEU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: LEU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 30;
  		}
  		break;
  	case 545: /* LTF */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: LTF(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 10;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 546: /* LTD */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: LTD(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 9;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 549: /* LTI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: LTI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 31;
  		}
  		break;
  	case 550: /* LTU */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: LTU(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 32;
  		}
  		break;
  	case 561: /* NEF */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: NEF(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 12;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 562: /* NED */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* rel: NED(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[_rel_NT]) {
  			p->cost[_rel_NT] = c + 0;
  			p->rule._rel = 11;
  			_closure_rel(a, c + 0);
  		}
  		break;
  	case 565: /* NEI */
  		_label(LEFT_CHILD(a));
  		_label(RIGHT_CHILD(a));
  		/* stmt: NEI(reg,rc) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_reg_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_rc_NT] + 3;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 33;
  		}
  		break;
  	case 584: /* JUMPV */
  		_label(LEFT_CHILD(a));
  		/* stmt: JUMPV(addrg) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addrg_NT] + 2;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 21;
  		}
  		/* stmt: JUMPV(addr) */
  		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 2;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 22;
  		}
  		break;
  	case 600: /* LABELV */
  		/* stmt: LABELV */
  		c = 0;
  		if (c + 0 < p->cost[_stmt_NT]) {
  			p->cost[_stmt_NT] = c + 0;
  			p->rule._stmt = 23;
  		}
  		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 136: /* call: ADDRGP */
  	case 125: /* stmt: LABELV */
  	case 122: /* addrg: ADDRGP */
  	case 107: /* rc5: CNSTI */
  	case 94: /* reg: CNSTU */
  	case 93: /* reg: CNSTS */
  	case 92: /* reg: CNSTP */
  	case 91: /* reg: CNSTI */
  	case 90: /* reg: CNSTC */
  	case 62: /* spill: ADDRLP */
  	case 57: /* addrl: ADDRLP */
  	case 35: /* con13: CNSTU */
  	case 34: /* con13: CNSTS */
  	case 33: /* con13: CNSTP */
  	case 32: /* con13: CNSTI */
  	case 31: /* con13: CNSTC */
  	case 30: /* reg: ADDRLP */
  	case 29: /* reg: ADDRFP */
  	case 28: /* stk: ADDRLP */
  	case 27: /* stk: ADDRFP */
  	case 25: /* stk13: ADDRLP */
  	case 24: /* stk13: ADDRFP */
  	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 182: /* stmt: rel */
  	case 137: /* call: addr */
  	case 108: /* rc5: reg */
  	case 97: /* rc: reg */
  	case 96: /* rc: con13 */
  	case 95: /* reg: con */
  	case 46: /* addr: stk */
  	case 42: /* addr: base */
  	case 41: /* base: stk13 */
  	case 40: /* base: con13 */
  	case 39: /* base: reg */
  	case 26: /* reg: stk13 */
  	case 18: /* stmt: reg */
  		kids[0] = p;
  		break;
  	case 184: /* reg: NEGD(reg) */
  	case 183: /* reg: LOADD(reg) */
  	case 169: /* reg: CVID(reg) */
  	case 168: /* reg: CVDI(reg) */
  	case 167: /* reg: CVFD(reg) */
  	case 166: /* reg: CVDF(reg) */
  	case 165: /* reg: LOADF(reg) */
  	case 164: /* reg: NEGF(reg) */
  	case 149: /* stmt: ARGF(reg) */
  	case 148: /* stmt: ARGD(reg) */
  	case 147: /* stmt: ARGP(reg) */
  	case 146: /* stmt: ARGI(reg) */
  	case 145: /* stmt: RETI(reg) */
  	case 144: /* stmt: RETF(reg) */
  	case 143: /* stmt: RETD(reg) */
  	case 141: /* stmt: CALLV(call) */
  	case 140: /* reg: CALLI(call) */
  	case 139: /* reg: CALLF(call) */
  	case 138: /* reg: CALLD(call) */
  	case 124: /* stmt: JUMPV(addr) */
  	case 123: /* stmt: JUMPV(addrg) */
  	case 121: /* reg: CVSU(reg) */
  	case 120: /* reg: CVCU(reg) */
  	case 119: /* reg: CVSI(reg) */
  	case 118: /* reg: CVCI(reg) */
  	case 117: /* reg: BCOMU(reg) */
  	case 116: /* reg: NEGI(reg) */
  	case 89: /* reg: LOADU(reg) */
  	case 88: /* reg: LOADS(reg) */
  	case 87: /* reg: LOADP(reg) */
  	case 86: /* reg: LOADI(reg) */
  	case 85: /* reg: LOADC(reg) */
  	case 84: /* reg: CVUS(reg) */
  	case 83: /* reg: CVUC(reg) */
  	case 82: /* reg: CVIS(reg) */
  	case 81: /* reg: CVIC(reg) */
  	case 80: /* reg: CVUS(reg) */
  	case 79: /* reg: CVUP(reg) */
  	case 78: /* reg: CVUI(reg) */
  	case 77: /* reg: CVUC(reg) */
  	case 76: /* reg: CVPU(reg) */
  	case 75: /* reg: CVIU(reg) */
  	case 74: /* reg: CVIS(reg) */
  	case 73: /* reg: CVIC(reg) */
  	case 60: /* reg: INDIRD(base) */
  	case 58: /* reg: INDIRD(addrl) */
  	case 51: /* reg: INDIRF(addr) */
  	case 50: /* reg: INDIRP(addr) */
  	case 49: /* reg: INDIRI(addr) */
  	case 48: /* reg: INDIRS(addr) */
  	case 47: /* 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 181: /* rel: NEF(reg,reg) */
  	case 180: /* rel: NED(reg,reg) */
  	case 179: /* rel: LTF(reg,reg) */
  	case 178: /* rel: LTD(reg,reg) */
  	case 177: /* rel: LEF(reg,reg) */
  	case 176: /* rel: LED(reg,reg) */
  	case 175: /* rel: GTF(reg,reg) */
  	case 174: /* rel: GTD(reg,reg) */
  	case 173: /* rel: GEF(reg,reg) */
  	case 172: /* rel: GED(reg,reg) */
  	case 171: /* rel: EQF(reg,reg) */
  	case 170: /* rel: EQD(reg,reg) */
  	case 163: /* reg: SUBF(reg,reg) */
  	case 162: /* reg: SUBD(reg,reg) */
  	case 161: /* reg: MULF(reg,reg) */
  	case 160: /* reg: MULD(reg,reg) */
  	case 159: /* reg: DIVF(reg,reg) */
  	case 158: /* reg: DIVD(reg,reg) */
  	case 157: /* reg: ADDF(reg,reg) */
  	case 156: /* reg: ADDD(reg,reg) */
  	case 155: /* reg: MULU(reg,reg) */
  	case 154: /* reg: MULI(reg,reg) */
  	case 153: /* reg: MODU(reg,reg) */
  	case 152: /* reg: MODI(reg,reg) */
  	case 151: /* reg: DIVU(reg,reg) */
  	case 150: /* reg: DIVI(reg,reg) */
  	case 142: /* stmt: CALLB(call,reg) */
  	case 135: /* stmt: NEI(reg,rc) */
  	case 134: /* stmt: LTU(reg,rc) */
  	case 133: /* stmt: LTI(reg,rc) */
  	case 132: /* stmt: LEU(reg,rc) */
  	case 131: /* stmt: LEI(reg,rc) */
  	case 130: /* stmt: GTU(reg,rc) */
  	case 129: /* stmt: GTI(reg,rc) */
  	case 128: /* stmt: GEU(reg,rc) */
  	case 127: /* stmt: GEI(reg,rc) */
  	case 126: /* stmt: EQI(reg,rc) */
  	case 112: /* reg: RSHU(reg,rc5) */
  	case 111: /* reg: RSHI(reg,rc5) */
  	case 110: /* reg: LSHU(reg,rc5) */
  	case 109: /* reg: LSHI(reg,rc5) */
  	case 106: /* reg: SUBU(reg,rc) */
  	case 105: /* reg: SUBP(reg,rc) */
  	case 104: /* reg: SUBI(reg,rc) */
  	case 103: /* reg: BXORU(reg,rc) */
  	case 102: /* reg: BORU(reg,rc) */
  	case 101: /* reg: BANDU(reg,rc) */
  	case 100: /* reg: ADDU(reg,rc) */
  	case 99: /* reg: ADDP(reg,rc) */
  	case 98: /* reg: ADDI(reg,rc) */
  	case 68: /* stmt: ASGND(spill,reg) */
  	case 67: /* stmt: ASGNF(spill,reg) */
  	case 66: /* stmt: ASGNP(spill,reg) */
  	case 65: /* stmt: ASGNI(spill,reg) */
  	case 64: /* stmt: ASGNS(spill,reg) */
  	case 63: /* stmt: ASGNC(spill,reg) */
  	case 61: /* stmt: ASGND(base,reg) */
  	case 59: /* stmt: ASGND(addrl,reg) */
  	case 56: /* stmt: ASGNF(addr,reg) */
  	case 55: /* stmt: ASGNP(addr,reg) */
  	case 54: /* stmt: ASGNI(addr,reg) */
  	case 53: /* stmt: ASGNS(addr,reg) */
  	case 52: /* stmt: ASGNC(addr,reg) */
  	case 45: /* addr: ADDU(reg,reg) */
  	case 44: /* addr: ADDP(reg,reg) */
  	case 43: /* addr: ADDI(reg,reg) */
  	case 38: /* base: ADDU(reg,con13) */
  	case 37: /* base: ADDP(reg,con13) */
  	case 36: /* base: ADDI(reg,con13) */
  		kids[0] = LEFT_CHILD(p);
  		kids[1] = RIGHT_CHILD(p);
  		break;
  	case 72: /* reg: CVSU(INDIRS(addr)) */
  	case 71: /* reg: CVCU(INDIRC(addr)) */
  	case 70: /* reg: CVSI(INDIRS(addr)) */
  	case 69: /* reg: CVCI(INDIRC(addr)) */
  		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
  		break;
  	case 185: /* stmt: ASGNB(reg,INDIRB(reg)) */
  	case 115: /* reg: BXORU(reg,BCOMU(rc)) */
  	case 114: /* reg: BORU(reg,BCOMU(rc)) */
  	case 113: /* reg: BANDU(reg,BCOMU(rc)) */
  		kids[0] = LEFT_CHILD(p);
  		kids[1] = LEFT_CHILD(RIGHT_CHILD(p));
  		break;
  	default:
  		fatal("_kids", "Bad rule number %d\n", eruleno);
  	}
  }
  
  static void progend(){}
  static void progbeg(argc, argv) 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 (strcmp(argv[i], "-p") == 0 || strcmp(argv[i], "-pg") == 0)
  			pflag = 1;
  	for (i = 0; i < 8; i++) {
  		greg[i +  0] = mkreg(stringf("g%d", i), i +  0, 1, IREG);
  		greg[i +  8] = mkreg(stringf("o%d", i), i +  8, 1, IREG);
  		greg[i + 16] = mkreg(stringf("l%d", i), i + 16, 1, IREG);
  		greg[i + 24] = mkreg(stringf("i%d", i), i + 24, 1, IREG);
  	}
  	for (i = 0; i < 32; i++)
  		freg[i]  = mkreg("%d", i, 1, FREG);
  	for (i = 0; i < 31; i += 2)
  		freg2[i] = mkreg("%d", i, 3, FREG);
  	rmap[C] = rmap[S] = rmap[P] = rmap[B] = rmap[U] = rmap[I] =
  		mkwildcard(greg);
  	rmap[F] = mkwildcard(freg);
  	rmap[D] = mkwildcard(freg2);
  	tmask[IREG] = 0x3fff3e00;
  	vmask[IREG] = 0x3ff00000;
  	tmask[FREG]  = ~(unsigned)0;
  	vmask[FREG]  = 0;
  }
  static void target(p) Node p; {
  	assert(p);
  	switch (p->op) {
  	case CNSTC: case CNSTI: case CNSTS: case CNSTU: case CNSTP:
  		if (range(p, 0, 0) == 0) {
  			setreg(p, greg[0]);
  			p->x.registered = 1;
  		}
  		break;
  	case CALLD: setreg(p, freg2[0]);     break;
  	case CALLF: setreg(p, freg[0]);      break;
  	case CALLI:
  	case CALLV: setreg(p, oreg[0]);      break;
  	case RETD:  rtarget(p, 0, freg2[0]); break;
  	case RETF:  rtarget(p, 0, freg[0]);  break;
  	case RETI:
  		rtarget(p, 0, ireg[0]);
  		p->kids[0]->x.registered = 1;
  		break;
  	case ARGI: case ARGP:
  		if (p->syms[RX]->u.c.v.i < 6) {
  			rtarget(p, 0, oreg[p->syms[RX]->u.c.v.i]);
  			p->op = LOAD+optype(p->op);
  			setreg(p, oreg[p->syms[RX]->u.c.v.i]);
  		}
  		break;
  	case DIVI: case MODI: case MULI:
  	case DIVU: case MODU: case MULU:
  		setreg(p, oreg[0]);
  		rtarget(p, 0, oreg[0]);
  		rtarget(p, 1, oreg[1]);
  		break;
  	}
  }
  static void clobber(p) Node p; {
  	assert(p);
  	switch (p->op) {
  	case CALLB: case CALLD: case CALLF: case CALLI:
  		spill(~(unsigned)3, FREG, p);
  		break;
  	case CALLV:
  		spill(oreg[0]->x.regnode->mask, IREG, p);
  		spill(~(unsigned)3, FREG, p);
  		break;
  	case ARGF:
  		if (p->syms[2]->u.c.v.i <= 6)
  			spill((1<<(p->syms[2]->u.c.v.i + 8)), IREG, p);
  		break;
  	case ARGD:
  		if (p->syms[2]->u.c.v.i <= 5)
  			spill((3<<(p->syms[2]->u.c.v.i + 8))&0xff00, IREG, p);
  		break;
  	case DIVI: case MODI: case MULI:
  	case DIVU: case MODU: case MULU:
  		spill(0x00003e00, IREG, p); break;
  	}
  }
  static int imm(p) Node p; {
  	return range(p, -4096, 4095);
  }
  static void doarg(p) Node p; {
  	assert(p && p->syms[0] && p->op != ARG+B);
  	p->syms[RX] = intconst(mkactual(4,
  		p->syms[0]->u.c.v.i)/4);
  }
  static void emit2(p) Node p; {
  	switch (p->op) {
  	case ARGF: {
  		int n = p->syms[RX]->u.c.v.i;
  		print("st %%f%d,[%%sp+4*%d+68]\n",
  			getregnum(p->x.kids[0]), n);
  		if (n <= 5)
  			print("ld [%%sp+4*%d+68],%%o%d\n", n, n);
  		break;
  	}
  	case ARGD: {
  		int n = p->syms[RX]->u.c.v.i;
  		int src = getregnum(p->x.kids[0]);
  		print("st %%f%d,[%%sp+4*%d+68]\n", src, n);
  		print("st %%f%d,[%%sp+4*%d+68]\n", src+1, n+1);
  		if (n <= 5)
  			print("ld [%%sp+4*%d+68],%%o%d\n", n, n);
  		if (n <= 4)
  			print("ld [%%sp+4*%d+68],%%o%d\n", n+1, n+1);
  		break;
  	}
  	case LOADD: {
  		int dst = getregnum(p);
  		int src = getregnum(p->x.kids[0]);
  		print("fmovs %%f%d,%%f%d; ", src,   dst);
  		print("fmovs %%f%d,%%f%d\n", src+1, dst+1);
  		break;
  	}
  	case NEGD: {
  		int dst = getregnum(p);
  		int src = getregnum(p->x.kids[0]);
  		print("fnegs %%f%d,%%f%d; ", src,   dst);
  		print("fmovs %%f%d,%%f%d\n", src+1, dst+1);
  		break;
  	}
  	case ASGNB: {
  		static int tmpregs[] = { 1, 2, 3 };
  		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;
  	}
  	}
  }
  static void local(p) Symbol p; {
  	if (retstruct) {
  		p->x.name = stringd(4*16);
  		p->x.offset = 4*16;
  		retstruct = 0;
  		return;
  	}
  	if (isscalar(p->type) && !p->addressed && !isfloat(p->type))
  		p->sclass = REGISTER;
  	if (glevel && glevel != 3) p->sclass = AUTO;	/* glevel!=3 is for Norman's debugger */
  	if (askregvar(p, rmap[ttob(p->type)]) == 0)
  		mkauto(p);
  }
  static void function(f, caller, callee, ncalls)
  Symbol f, callee[], caller[]; int ncalls; {
  	int autos = 0, i, leaf, reg, varargs;
  
  	for (i = 0; callee[i]; i++)
  		;
  	varargs = variadic(f->type)
  		|| i > 0 && strcmp(callee[i-1]->name,
  			"__builtin_va_alist") == 0;
  usedmask[0] = usedmask[1] = 0;
  freemask[0] = freemask[1] = ~(unsigned)0;
  	for (i = 0; i < 8; i++)
  		ireg[i]->x.regnode->vbl = NULL;
  	offset = 68;
  	maxargoffset = 24;
  	reg = 0;
  	for (i = 0; callee[i]; i++) {
  		Symbol p = callee[i], q = caller[i];
  		int size = roundup(q->type->size, 4);
  		assert(q);
  		if (isfloat(p->type) || reg >= 6) {
  			p->x.offset = q->x.offset = offset;
  			p->x.name = q->x.name = stringd(offset);
  			p->sclass = q->sclass = AUTO;
  			autos++;
  		}
  		else if (p->addressed || varargs)
  			{
  				p->x.offset = offset;
  				p->x.name = stringd(p->x.offset);
  				p->sclass = AUTO;
  				q->sclass = REGISTER;
  				askregvar(q, ireg[reg]);
  				assert(q->x.regnode);
  				autos++;
  			}
  		else if (glevel && glevel != 3) {
  							p->x.offset = offset;
  							p->x.name = stringd(p->x.offset);
  							p->sclass = AUTO;
  							q->sclass = REGISTER;
  							askregvar(q, ireg[reg]);
  							assert(q->x.regnode);
  							autos++;
  						}
  
  		else {
  			p->sclass = q->sclass = REGISTER;
  			askregvar(p, ireg[reg]);
  			assert(p->x.regnode);
  			q->x.name = p->x.name;
  		}
  		offset += size;
  		reg += isstruct(p->type) ? 1 : size/4;
  	}
  	assert(caller[i] == 0);
  	offset = maxoffset = 0;
  	retstruct = isstruct(freturn(f->type));
  	gencode(caller, callee);
  	maxargoffset = roundup(maxargoffset, 4);
  	framesize = roundup(maxoffset + maxargoffset + 4*(16+1), 8);
  	assert(!varargs || autos);
  	leaf = (!ncalls
  		&& !maxoffset && !autos
  		&& !isstruct(freturn(f->type))
  		&& !(usedmask[IREG]&0x00ffff01)
  		&& !(usedmask[FREG]&~(unsigned)3)
  		&& !pflag && !glevel);
  	print(".align 4\n.proc 4\n%s:\n", f->x.name);
  	if (leaf) {
  		for (i = 0; caller[i] && callee[i]; i++) {
  			Symbol p = caller[i], q = callee[i];
  			if (p->sclass == REGISTER && q->sclass == REGISTER)
  				assert(q->x.regnode),
  				assert(q->x.regnode->set == IREG),
  				assert(q->x.regnode->number >= 24),
  				assert(q->x.regnode->number <= 31),
  				p->x.name = greg[q->x.regnode->number - 16]->x.name;
  			}
  		rename();
  	} else if (framesize <= 4095)
  		print("save %%sp,%d,%%sp\n", -framesize);
  	else
  		print("set %d,%%g1; save %%sp,%%g1,%%sp\n", -framesize);
  	if (varargs)
  		for (; reg < 6; reg++)
  			print("st %%i%d,[%%fp+%d]\n", reg, 4*reg + 68);
  	else
  		offset = 4*(16 + 1);
  		reg = 0;
  		for (i = 0; caller[i]; i++) {
  			Symbol p = caller[i];
  			if (isdouble(p->type) && reg <= 4) {
  				print("st %%r%d,[%%fp+%d]\n",
  					ireg[reg++]->x.regnode->number, offset);
  				print("st %%r%d,[%%fp+%d]\n",
  					ireg[reg++]->x.regnode->number, offset + 4);
  			} else if (isfloat(p->type) && reg <= 5)
  				print("st %%r%d,[%%fp+%d]\n",
  					ireg[reg++]->x.regnode->number, offset);
  			else
  				reg++;
  			offset += roundup(p->type->size, 4);
  		}
  if (pflag) {
  	int lab = genlabel(1);
  	print("set L%d,%%o0; call mcount; nop\n", lab);
  	print(".seg \"data\"\n.align 4; L%d:.word 0\n.seg \"text\"\n", lab);
  }
  	emitcode();
  	if (!leaf)
  		print("ret; restore\n");
  	else {
  		rename();
  		print("retl; nop\n");
  	}
  }
  #define exch(x, y, t) (((t) = x), ((x) = (y)), ((y) = (t)))
  
  static void rename() {
  	int i;
  
  	for (i = 0; i < 8; i++) {
  		char *ptmp;
  		int itmp;
  		if (ireg[i]->x.regnode->vbl)
  			ireg[i]->x.regnode->vbl->x.name = oreg[i]->x.name;
  		exch(ireg[i]->x.name, oreg[i]->x.name, ptmp);
  		exch(ireg[i]->x.regnode->number,
  			oreg[i]->x.regnode->number, itmp);
  	}
  }
  static void defconst(ty, v) int ty; Value v; {
  	switch (ty) {
  	case C: print(".byte %d\n",   v.uc); return;
  	case S: print(".half %d\n",   v.ss); return;
  	case I: print(".word %d\n",   v.i ); return;
  	case U: print(".word 0x%x\n", v.u ); return;
  	case P: print(".word 0x%x\n", v.p ); return;
  	case F:
  		print(".word 0x%x\n", *(unsigned *)&v.f);
  		return;
  case D: {
  	unsigned *p = (unsigned *)&v.d;
  	print(".word 0x%x\n.word 0x%x\n", p[swap], p[!swap]);
  	return;
  	}
  	}
  	assert(0);
  }
  
  static void defaddress(p) Symbol p; {
  	print(".word %s\n", p->x.name);
  }
  
  static void defstring(n, str) int n; char *str; {
  	char *s;
  
  	for (s = str; s < str + n; s++)
  		print(".byte %d\n", (*s)&0377);
  }
  
  static void address(q, p, n) Symbol q, p; int n; {
  	q->x.offset = p->x.offset + n;
  	if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN)
  		q->x.name = stringf("%s%s%d", p->x.name, n >= 0 ? "+" : "", n);
  	else
  		q->x.name = stringd(q->x.offset);
  }
  static void export(p) Symbol p; {
  	print(".global %s\n", p->x.name);
  }
  static void import(p) Symbol p; {}
  static void defsymbol(p) Symbol p; {
  	if (p->scope >= LOCAL && p->sclass == STATIC)
  		p->x.name = stringf("%d", genlabel(1));
  	else
  		assert(p->scope != CONSTANTS || isint(p->type) || isptr(p->type)),
  		p->x.name = p->name;
  	if (p->scope >= LABELS)
  		p->x.name = stringf(p->generated ? "L%s" : "_%s",
  			p->x.name);
  }
  static void segment(n) int n; {
  	cseg = n;
  	switch (n) {
  	case CODE: print(".seg \"text\"\n"); break;
  	case BSS:  print(".seg \"bss\"\n");  break;
  	case DATA: print(".seg \"data\"\n"); break;
  	case LIT:  print(".seg \"text\"\n"); break;
  	}
  }
  static void space(n) int n; {
  	if (cseg != BSS)
  		print(".skip %d\n", n);
  }
  static void global(p) Symbol p; {
  	print(".align %d\n", p->type->align);
  	assert(p->u.seg);
  	if (p->u.seg == BSS
  	&& (p->sclass == STATIC || Aflag >= 2))
  		print(".reserve %s,%d\n", p->x.name, p->type->size);
  	else if (p->u.seg == BSS)
  		print(".common %s,%d\n",  p->x.name, p->type->size);
  	else
  		print("%s:\n", p->x.name);
  }
  static void blkfetch(k, off, reg, tmp)
  int k, off, reg, tmp; {
  	assert(k == 1 || k == 2 || k == 4);
  	assert(salign >= k);
  	if (k == 1)
  		print("ldub [%%r%d+%d],%%r%d\n", reg, off, tmp);
  	else if (k == 2)
  		print("lduh [%%r%d+%d],%%r%d\n", reg, off, tmp);
  	else
  		print("ld [%%r%d+%d],%%r%d\n",   reg, off, tmp);
  }
  static void blkstore(k, off, reg, tmp)
  int k, off, reg, tmp; {
  	assert(k == 1 || k == 2 || k == 4);
  	assert(dalign >= k);
  	if (k == 1)
  		print("stb %%r%d,[%%r%d+%d]\n", tmp, reg, off);
  	else if (k == 2)
  		print("sth %%r%d,[%%r%d+%d]\n", tmp, reg, off);
  	else
  		print("st %%r%d,[%%r%d+%d]\n",  tmp, reg, off);
  }
  static void blkloop(dreg, doff, sreg, soff, size, tmps)
  int dreg, doff, sreg, soff, size, tmps[]; {
  	if ((size&~7) < 4096) {
  		print("add %%r%d,%d,%%r%d\n", sreg, size&~7, sreg);
  		print("add %%r%d,%d,%%r%d\n", dreg, size&~7, tmps[2]);
  	} else {
  		print("set %d,%%r%d\n", size&~7, tmps[2]);
  		print("add %%r%d,%%r%d,%%r%d\n", sreg, tmps[2], sreg);
  		print("add %%r%d,%%r%d,%%r%d\n", dreg, tmps[2], tmps[2]);
  	}
  	blkcopy(tmps[2], doff, sreg, soff, size&7, tmps);
  	print("1: dec 8,%%r%d\n", tmps[2]);
  	blkcopy(tmps[2], doff, sreg, soff - 8, 8, tmps);
  	print("cmp %%r%d,%%r%d; ", tmps[2], dreg);
  	print("bgt 1b; ");
  	print("dec 8,%%r%d\n", sreg);
  }
  static void defsymbol2(p) Symbol p; {
  	if (p->scope >= LOCAL && p->sclass == STATIC)
  		p->x.name = stringf(".%d", genlabel(1));
  	else
  		assert(p->scope != CONSTANTS || isint(p->type) || isptr(p->type)),
  		p->x.name = p->name;
  	if (p->scope >= LABELS)
  		p->x.name = stringf(p->generated ? ".L%s" : "%s",
  			p->x.name);
  }
  
  static void global2(p) Symbol p; {
  	assert(p->u.seg);
  	if (p->sclass != STATIC && !p->generated)
  		print(".type %s,#%s\n", p->x.name,
  			isfunc(p->type) ? "function" : "object");
  	if (p->u.seg == BSS && p->sclass == STATIC)
  		print(".local %s\n.common %s,%d,%d\n", p->x.name, p->x.name,
  			p->type->size, p->type->align);
  	else if (p->u.seg == BSS && Aflag >= 2)
  		print(".align %d\n%s:.skip %d\n", p->type->align, p->x.name,
  			p->type->size);
  	else if (p->u.seg == BSS)
  		print(".common %s,%d,%d\n", p->x.name, p->type->size, p->type->align);
  	else
  		print(".align %d\n%s:\n", p->type->align, p->x.name);
  }
  
  static void segment2(n) int n; {
  	cseg = n;
  	switch (n) {
  	case CODE: print(".section \".text\"\n");   break;
  	case BSS:  print(".section \".bss\"\n");    break;
  	case DATA: print(".section \".data\"\n");   break;
  	case LIT:  print(".section \".rodata\"\n"); break;
  	}
  }
  #ifdef sparc
  #include <stab.h>
  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(ty, lev) 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 .stabs entry for type ty */
  static void dbxout(ty) Type ty; {
  	ty = unqual(ty);
  	if (!ty->x.printed) {
  		int col = 0;
  		print(".stabs \""), col += 8;
  		if (ty->u.sym && !(isfunc(ty) || isarray(ty) || isptr(ty)))
  			print("%s", ty->u.sym->name), col += strlen(ty->u.sym->name);
  		print(":%c", isstruct(ty) || isenum(ty) ? 'T' : 't'), col += 2;
  		emittype(ty, 0, col);
  		print("\",%d,0,0,0\n", N_LSYM);
  	}
  }
  
  /* dbxtype - emit a stabs entry for type ty, return type code */
  static int dbxtype(ty) 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(ty, lev, col) Type ty; int lev, col; {
  	int tc = ty->x.typeno;
  
  	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) {
  		ty->x.typeno = tc = ++ntypes;
  /*              fprint(2,"`%t'=%d\n", ty, tc); */
  	}
  	print("%d", tc), col += 3;
  	if (ty->x.printed)
  		return col;
  	ty->x.printed = 1;
  	switch (ty->op) {
  	case VOID:	/* void is defined as itself */
  		print("=%d", tc), col += 1+3;
  		break;
  	case CHAR:	/* unsigned char is a subrange of int */
  		if (ty == unsignedchar)
  			print("=r1;0;255;"), col += 10;
  		else	/* following pcc, char is a subrange of itself */
  			print("=r%d;-128;127;", tc), col += 2+3+10;
  		break;
  	case SHORT:	/* short is a subrange of int */
  		if (ty == unsignedshort)
  			print("=r1;0;65535;"), col += 12;
  		else	/* signed */
  			print("=r1;-32768;32767;"), col += 17;
  		break;
  	case INT:	/* int is a subrange of itself */
  		print("=r1;%d;%d;", INT_MIN, INT_MAX), col += 4+11+1+10+1;
  		break;
  	case UNSIGNED:	/* unsigned is a subrange of int */
  		print("=r1;0;-1;"), col += 9;
  		break;
  	case FLOAT: case DOUBLE:	/* float, double get sizes instead of ranges */
  		print("=r1;%d;0;", ty->size), col += 4+1+3;
  		break;
  	case POINTER:
  		print("=*"), col += 2;
  		col = emittype(ty->type, lev + 1, col);
  		break;
  	case FUNCTION:
  		print("=f"), col += 2;
  		col = emittype(ty->type, lev + 1, col);
  		break;
  	case ARRAY:	/* array includes subscript as an int range */
  		if (ty->size && ty->type->size)
  			print("=ar1;0;%d;", ty->size/ty->type->size - 1), col += 7+3+1;
  		else
  			print("=ar1;0;-1;"), col += 10;
  		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("\\\\\",%d,0,0,0\n.stabs \"", N_LSYM);
  				col = 8;
  			}
  		}
  		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("\\\\\",%d,0,0,0\n.stabs \"", N_LSYM);
  				col = 8;
  			}
  		}
  		print(";"), col += 1;
  		break;
  		}
  	default:
  		assert(0);
  	}
  	return col;
  }
  
  /* stabblock - output a stab entry for '{' or '}' at level lev */
  static void stabblock(brace, lev, p) int brace, lev; Symbol *p; {
  	if (brace == '{')
  		while (*p)
  			stabsym(*p++);
  	print(".stabd 0x%x,0,%d\n", brace == '{' ? N_LBRAC : N_RBRAC, lev);
  }
  
  /* stabfend - end of function p */
  static void stabfend(p, line) Symbol p; int line; {}
  
  /* stabinit - initialize stab output */
  static void stabinit(file, argc, argv) int argc; char *file, *argv[]; {
  	typedef void (*Closure) ARGS((Symbol, void *));
  
  	if (file && *file) {
  		(*IR->segment)(CODE);
  		print("Ltext:.stabs \"%s\",0x%x,0,0,Ltext\n", file, N_SO);
  		currentfile = file;
  	}
  	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(cp) Coordinate *cp; {
  	if (cp->file && cp->file != currentfile) {
  		int lab = genlabel(1);
  		print("L%d: .stabs \"%s\",0x%x,0,0,L%d\n", lab,
  				cp->file, N_SOL, lab);
  		currentfile = cp->file;
  	}
  	print(".stabd 0x%x,0,%d\n", N_SLINE, cp->y);
  }
  
  /* stabsym - output a stab entry for symbol p */
  static void stabsym(p) Symbol p; {
  	int code, tc, sz = p->type->size;
  
  	if (p->generated || p->computed)
  		return;
  	if (isfunc(p->type)) {
  		print(".stabs \"%s:%c%d\",%d,0,0,%s\n", p->name,
  			p->sclass == STATIC ? 'f' : 'F', dbxtype(freturn(p->type)),
  			N_FUN, p->x.name);
  		return;
  	}
  	if (!IR->wants_argb && p->scope == PARAM && p->structarg) {
  		assert(isptr(p->type) && isstruct(p->type->type));
  		tc = dbxtype(p->type->type);
  		sz = p->type->type->size;
  	} else
  		tc = dbxtype(p->type);
  	if (p->sclass == AUTO && p->scope == GLOBAL || p->sclass == EXTERN) {
  		print(".stabs \"%s:G", p->name);
  		code = N_GSYM;
  	} else if (p->sclass == STATIC) {
  		print(".stabs \"%s:%c%d\",%d,0,0,%s\n", p->name, p->scope == GLOBAL ? 'S' : 'V',
  			tc, p->u.seg == BSS ? N_LCSYM : N_STSYM, p->x.name);
  		return;
  	} else if (p->sclass == REGISTER) {
  		if (p->scope > PARAM) {
  			int r = p->x.regnode->number;
  			if (p->x.regnode->set == FREG)
  				r += 32;	/* floating point */
  			print(".stabs \"%s:r%d\",%d,0,", p->name, tc, N_RSYM);
  			print("%d,%d\n", sz, r);
  		}
  		return;
  	} else if (p->scope == PARAM) {
  		print(".stabs \"%s:p", p->name);
  		code = N_PSYM;
  	} else if (p->scope >= LOCAL) {
  		print(".stabs \"%s:", p->name);
  		code = N_LSYM;
  	} else
  		assert(0);
  	print("%d\",%d,0,0,%s\n", tc, code,
  		p->scope >= PARAM && p->sclass != EXTERN ? p->x.name : "0");
  }
  
  /* stabtype - output a stab entry for type *p */
  static void stabtype(p) Symbol p; {
  	if (p->type) {
  		if (p->sclass == 0)
  			dbxtype(p->type);
  		else if (p->sclass == TYPEDEF)
  			print(".stabs \"%s:t%d\",%d,0,0,0\n", p->name, dbxtype(p->type), N_LSYM);
  	}
  }
  #else
  #define stabblock 0
  #define stabinit 0
  #define stabline 0
  #define stabsym 0
  #define stabtype 0
  #endif
  Interface sparcIR = {
  	1, 1, 0,  /* char */
  	2, 2, 0,  /* short */
  	4, 4, 0,  /* int */
  	4, 4, 1,  /* float */
  	8, 8, 1,  /* double */
  	4, 4, 0,  /* T * */
  	0, 1, 0,  /* struct */
  	0,  /* little_endian */
  	1,  /* mulops_calls */
  	1,  /* wants_callb */
  	0,  /* 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, 0, 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,
  
  	}
  };
  
  Interface solarisIR = {
  	1, 1, 0,  /* char */
  	2, 2, 0,  /* short */
  	4, 4, 0,  /* int */
  	4, 4, 1,  /* float */
  	8, 8, 1,  /* double */
  	4, 4, 0,  /* T * */
  	0, 1, 0,  /* struct */
  	0,	/* little_endian */
  	1,	/* mulops_calls */
  	1,	/* wants_callb */
  	0,	/* wants_argb */
  	1,	/* left_to_right */
  	0,	/* wants_dag */
  	address,
  	blockbeg,
  	blockend,
  	defaddress,
  	defconst,
  	defstring,
  	defsymbol2,
  	emit,
  	export,
  	function,
  	gen,
  	global2,
  	import,
  	local,
  	progbeg,
  	progend,
  	segment2,
  	space,
  	stabblock, 0, 0, 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,
  
  	}
  };
  