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

static void address(Symbol, Symbol, long);
static void defaddress(Symbol);
static void defconst(int, int, Value);
static void defstring(int, char *);
static void defsymbol(Symbol);
static void emit2(Node);
static void export(Symbol);
static void function(Symbol, Symbol [], Symbol [], int);
static void global(Symbol);
static void import(Symbol);
static void local(Symbol);
static void progbeg(int, char **);
static void progend(void);
static void segment(int);
static void space(int);
static void blockbeg(Env* env);
static void blockend(Env* env);
 
extern void stackemit(Node forest);
extern Node stackgen(Node forest);
extern void swtch(Symbol label);
extern FILE* logfile;


/*
generated at Tue May 13 12:28:24 2014
by $Id: lburg.c,v 2.10 2002/03/08 18:45:21 drh Exp $
*/
static void _kids(NODEPTR_TYPE, int, NODEPTR_TYPE[]);
static void _label(NODEPTR_TYPE);
static int _rule(void*, int);

#define _stmt_NT 1
#define _sread8_NT 2
#define _sread_NT 3
#define _drop_NT 4
#define _stk_NT 5
#define _stk2_NT 6
#define _tuck1_NT 7
#define _tuck2_NT 8
#define _tuck3_NT 9
#define _tuck4_NT 10
#define _var_NT 11
#define _cnst1_NT 12
#define _cnst2_NT 13
#define _cnst4_NT 14
#define _cnst32_NT 15
#define _con9_NT 16
#define _ucon9_NT 17
#define _cnst_NT 18
#define _glob_NT 19
#define _local_NT 20
#define _zero_NT 21
#define _cnst_m1_NT 22
#define _cpyst_NT 23
#define _cpystb_NT 24
#define _cpystw_NT 25
#define _tuckst_NT 26
#define _addr_NT 27

static char *_ntname[] = {
	0,
	"stmt",
	"sread8",
	"sread",
	"drop",
	"stk",
	"stk2",
	"tuck1",
	"tuck2",
	"tuck3",
	"tuck4",
	"var",
	"cnst1",
	"cnst2",
	"cnst4",
	"cnst32",
	"con9",
	"ucon9",
	"cnst",
	"glob",
	"local",
	"zero",
	"cnst_m1",
	"cpyst",
	"cpystb",
	"cpystw",
	"tuckst",
	"addr",
	0
};

struct _state {
	short cost[28];
	struct {
		unsigned int _stmt:8;
		unsigned int _sread8:2;
		unsigned int _sread:3;
		unsigned int _drop:1;
		unsigned int _stk:7;
		unsigned int _stk2:6;
		unsigned int _tuck1:4;
		unsigned int _tuck2:4;
		unsigned int _tuck3:4;
		unsigned int _tuck4:4;
		unsigned int _var:3;
		unsigned int _cnst1:3;
		unsigned int _cnst2:3;
		unsigned int _cnst4:3;
		unsigned int _cnst32:1;
		unsigned int _con9:4;
		unsigned int _ucon9:4;
		unsigned int _cnst:4;
		unsigned int _glob:1;
		unsigned int _local:2;
		unsigned int _zero:3;
		unsigned int _cnst_m1:1;
		unsigned int _cpyst:2;
		unsigned int _cpystb:2;
		unsigned int _cpystw:2;
		unsigned int _tuckst:2;
		unsigned int _addr:2;
	} rule;
};

static short _nts_0[] = { 0 };
static short _nts_1[] = { _drop_NT, 0 };
static short _nts_2[] = { _sread_NT, 0 };
static short _nts_3[] = { _sread8_NT, 0 };
static short _nts_4[] = { _stk_NT, 0 };
static short _nts_5[] = { _tuck1_NT, 0 };
static short _nts_6[] = { _tuck2_NT, 0 };
static short _nts_7[] = { _tuck3_NT, 0 };
static short _nts_8[] = { _tuck4_NT, 0 };
static short _nts_9[] = { _stk_NT, _var_NT, 0 };
static short _nts_10[] = { _cnst2_NT, 0 };
static short _nts_11[] = { _cnst4_NT, 0 };
static short _nts_12[] = { _cnst_NT, 0 };
static short _nts_13[] = { _stk2_NT, 0 };
static short _nts_14[] = { _glob_NT, 0 };
static short _nts_15[] = { _stk_NT, _local_NT, 0 };
static short _nts_16[] = { _stk2_NT, _local_NT, 0 };
static short _nts_17[] = { _stk_NT, _stk_NT, 0 };
static short _nts_18[] = { _stk2_NT, _stk_NT, 0 };
static short _nts_19[] = { _stk_NT, _cpystb_NT, 0 };
static short _nts_20[] = { _stk_NT, _cpystw_NT, 0 };
static short _nts_21[] = { _stk_NT, _cpyst_NT, 0 };
static short _nts_22[] = { _stk_NT, _tuckst_NT, 0 };
static short _nts_23[] = { _local_NT, 0 };
static short _nts_24[] = { _stk2_NT, _stk2_NT, 0 };
static short _nts_25[] = { _stk_NT, _cnst1_NT, 0 };
static short _nts_26[] = { _stk_NT, _cnst_m1_NT, 0 };
static short _nts_27[] = { _stk_NT, _cnst2_NT, 0 };
static short _nts_28[] = { _stk_NT, _con9_NT, 0 };
static short _nts_29[] = { _stk_NT, _cnst4_NT, 0 };
static short _nts_30[] = { _stk_NT, _zero_NT, 0 };
static short _nts_31[] = { _stk_NT, _ucon9_NT, 0 };
static short _nts_32[] = { _stk2_NT, _cnst1_NT, 0 };
static short _nts_33[] = { _stk_NT, _cnst_NT, 0 };
static short _nts_34[] = { _stk2_NT, _cnst32_NT, 0 };
static short _nts_35[] = { _addr_NT, 0 };
static short _nts_36[] = { _addr_NT, _stk_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_0,	/* 7 */
	_nts_0,	/* 8 */
	_nts_0,	/* 9 */
	_nts_0,	/* 10 */
	_nts_0,	/* 11 */
	_nts_1,	/* 12 */
	_nts_1,	/* 13 */
	_nts_1,	/* 14 */
	_nts_1,	/* 15 */
	_nts_1,	/* 16 */
	_nts_1,	/* 17 */
	_nts_1,	/* 18 */
	_nts_1,	/* 19 */
	_nts_2,	/* 20 */
	_nts_2,	/* 21 */
	_nts_2,	/* 22 */
	_nts_2,	/* 23 */
	_nts_2,	/* 24 */
	_nts_2,	/* 25 */
	_nts_2,	/* 26 */
	_nts_2,	/* 27 */
	_nts_3,	/* 28 */
	_nts_3,	/* 29 */
	_nts_3,	/* 30 */
	_nts_4,	/* 31 */
	_nts_4,	/* 32 */
	_nts_4,	/* 33 */
	_nts_4,	/* 34 */
	_nts_4,	/* 35 */
	_nts_4,	/* 36 */
	_nts_4,	/* 37 */
	_nts_4,	/* 38 */
	_nts_4,	/* 39 */
	_nts_4,	/* 40 */
	_nts_4,	/* 41 */
	_nts_4,	/* 42 */
	_nts_4,	/* 43 */
	_nts_4,	/* 44 */
	_nts_4,	/* 45 */
	_nts_4,	/* 46 */
	_nts_4,	/* 47 */
	_nts_4,	/* 48 */
	_nts_4,	/* 49 */
	_nts_4,	/* 50 */
	_nts_4,	/* 51 */
	_nts_4,	/* 52 */
	_nts_4,	/* 53 */
	_nts_4,	/* 54 */
	_nts_4,	/* 55 */
	_nts_4,	/* 56 */
	_nts_4,	/* 57 */
	_nts_4,	/* 58 */
	_nts_4,	/* 59 */
	_nts_4,	/* 60 */
	_nts_4,	/* 61 */
	_nts_4,	/* 62 */
	_nts_5,	/* 63 */
	_nts_6,	/* 64 */
	_nts_7,	/* 65 */
	_nts_8,	/* 66 */
	_nts_5,	/* 67 */
	_nts_6,	/* 68 */
	_nts_7,	/* 69 */
	_nts_8,	/* 70 */
	_nts_9,	/* 71 */
	_nts_9,	/* 72 */
	_nts_9,	/* 73 */
	_nts_9,	/* 74 */
	_nts_9,	/* 75 */
	_nts_9,	/* 76 */
	_nts_9,	/* 77 */
	_nts_9,	/* 78 */
	_nts_0,	/* 79 */
	_nts_0,	/* 80 */
	_nts_0,	/* 81 */
	_nts_0,	/* 82 */
	_nts_0,	/* 83 */
	_nts_0,	/* 84 */
	_nts_0,	/* 85 */
	_nts_0,	/* 86 */
	_nts_0,	/* 87 */
	_nts_0,	/* 88 */
	_nts_0,	/* 89 */
	_nts_0,	/* 90 */
	_nts_0,	/* 91 */
	_nts_0,	/* 92 */
	_nts_0,	/* 93 */
	_nts_0,	/* 94 */
	_nts_0,	/* 95 */
	_nts_0,	/* 96 */
	_nts_0,	/* 97 */
	_nts_0,	/* 98 */
	_nts_0,	/* 99 */
	_nts_0,	/* 100 */
	_nts_0,	/* 101 */
	_nts_0,	/* 102 */
	_nts_0,	/* 103 */
	_nts_0,	/* 104 */
	_nts_0,	/* 105 */
	_nts_0,	/* 106 */
	_nts_0,	/* 107 */
	_nts_0,	/* 108 */
	_nts_0,	/* 109 */
	_nts_0,	/* 110 */
	_nts_0,	/* 111 */
	_nts_0,	/* 112 */
	_nts_0,	/* 113 */
	_nts_0,	/* 114 */
	_nts_0,	/* 115 */
	_nts_0,	/* 116 */
	_nts_0,	/* 117 */
	_nts_0,	/* 118 */
	_nts_10,	/* 119 */
	_nts_11,	/* 120 */
	_nts_0,	/* 121 */
	_nts_0,	/* 122 */
	_nts_0,	/* 123 */
	_nts_0,	/* 124 */
	_nts_0,	/* 125 */
	_nts_0,	/* 126 */
	_nts_0,	/* 127 */
	_nts_0,	/* 128 */
	_nts_12,	/* 129 */
	_nts_0,	/* 130 */
	_nts_0,	/* 131 */
	_nts_4,	/* 132 */
	_nts_13,	/* 133 */
	_nts_0,	/* 134 */
	_nts_0,	/* 135 */
	_nts_0,	/* 136 */
	_nts_14,	/* 137 */
	_nts_0,	/* 138 */
	_nts_0,	/* 139 */
	_nts_0,	/* 140 */
	_nts_0,	/* 141 */
	_nts_0,	/* 142 */
	_nts_0,	/* 143 */
	_nts_0,	/* 144 */
	_nts_0,	/* 145 */
	_nts_0,	/* 146 */
	_nts_0,	/* 147 */
	_nts_0,	/* 148 */
	_nts_15,	/* 149 */
	_nts_15,	/* 150 */
	_nts_15,	/* 151 */
	_nts_15,	/* 152 */
	_nts_15,	/* 153 */
	_nts_15,	/* 154 */
	_nts_15,	/* 155 */
	_nts_15,	/* 156 */
	_nts_16,	/* 157 */
	_nts_16,	/* 158 */
	_nts_16,	/* 159 */
	_nts_17,	/* 160 */
	_nts_17,	/* 161 */
	_nts_17,	/* 162 */
	_nts_17,	/* 163 */
	_nts_17,	/* 164 */
	_nts_17,	/* 165 */
	_nts_17,	/* 166 */
	_nts_17,	/* 167 */
	_nts_18,	/* 168 */
	_nts_18,	/* 169 */
	_nts_18,	/* 170 */
	_nts_0,	/* 171 */
	_nts_0,	/* 172 */
	_nts_0,	/* 173 */
	_nts_0,	/* 174 */
	_nts_0,	/* 175 */
	_nts_0,	/* 176 */
	_nts_0,	/* 177 */
	_nts_0,	/* 178 */
	_nts_0,	/* 179 */
	_nts_19,	/* 180 */
	_nts_19,	/* 181 */
	_nts_20,	/* 182 */
	_nts_20,	/* 183 */
	_nts_21,	/* 184 */
	_nts_21,	/* 185 */
	_nts_21,	/* 186 */
	_nts_21,	/* 187 */
	_nts_4,	/* 188 */
	_nts_4,	/* 189 */
	_nts_4,	/* 190 */
	_nts_22,	/* 191 */
	_nts_22,	/* 192 */
	_nts_22,	/* 193 */
	_nts_22,	/* 194 */
	_nts_23,	/* 195 */
	_nts_23,	/* 196 */
	_nts_23,	/* 197 */
	_nts_23,	/* 198 */
	_nts_23,	/* 199 */
	_nts_23,	/* 200 */
	_nts_23,	/* 201 */
	_nts_23,	/* 202 */
	_nts_23,	/* 203 */
	_nts_23,	/* 204 */
	_nts_23,	/* 205 */
	_nts_4,	/* 206 */
	_nts_4,	/* 207 */
	_nts_4,	/* 208 */
	_nts_4,	/* 209 */
	_nts_4,	/* 210 */
	_nts_4,	/* 211 */
	_nts_4,	/* 212 */
	_nts_4,	/* 213 */
	_nts_4,	/* 214 */
	_nts_4,	/* 215 */
	_nts_4,	/* 216 */
	_nts_17,	/* 217 */
	_nts_17,	/* 218 */
	_nts_17,	/* 219 */
	_nts_17,	/* 220 */
	_nts_17,	/* 221 */
	_nts_17,	/* 222 */
	_nts_24,	/* 223 */
	_nts_24,	/* 224 */
	_nts_24,	/* 225 */
	_nts_24,	/* 226 */
	_nts_24,	/* 227 */
	_nts_24,	/* 228 */
	_nts_25,	/* 229 */
	_nts_25,	/* 230 */
	_nts_25,	/* 231 */
	_nts_26,	/* 232 */
	_nts_26,	/* 233 */
	_nts_26,	/* 234 */
	_nts_27,	/* 235 */
	_nts_27,	/* 236 */
	_nts_27,	/* 237 */
	_nts_28,	/* 238 */
	_nts_28,	/* 239 */
	_nts_28,	/* 240 */
	_nts_29,	/* 241 */
	_nts_29,	/* 242 */
	_nts_29,	/* 243 */
	_nts_30,	/* 244 */
	_nts_30,	/* 245 */
	_nts_30,	/* 246 */
	_nts_25,	/* 247 */
	_nts_25,	/* 248 */
	_nts_25,	/* 249 */
	_nts_31,	/* 250 */
	_nts_31,	/* 251 */
	_nts_31,	/* 252 */
	_nts_17,	/* 253 */
	_nts_17,	/* 254 */
	_nts_17,	/* 255 */
	_nts_24,	/* 256 */
	_nts_24,	/* 257 */
	_nts_17,	/* 258 */
	_nts_17,	/* 259 */
	_nts_17,	/* 260 */
	_nts_17,	/* 261 */
	_nts_17,	/* 262 */
	_nts_17,	/* 263 */
	_nts_17,	/* 264 */
	_nts_17,	/* 265 */
	_nts_17,	/* 266 */
	_nts_24,	/* 267 */
	_nts_24,	/* 268 */
	_nts_24,	/* 269 */
	_nts_24,	/* 270 */
	_nts_24,	/* 271 */
	_nts_24,	/* 272 */
	_nts_24,	/* 273 */
	_nts_24,	/* 274 */
	_nts_13,	/* 275 */
	_nts_13,	/* 276 */
	_nts_13,	/* 277 */
	_nts_32,	/* 278 */
	_nts_32,	/* 279 */
	_nts_32,	/* 280 */
	_nts_32,	/* 281 */
	_nts_33,	/* 282 */
	_nts_33,	/* 283 */
	_nts_33,	/* 284 */
	_nts_33,	/* 285 */
	_nts_18,	/* 286 */
	_nts_18,	/* 287 */
	_nts_18,	/* 288 */
	_nts_18,	/* 289 */
	_nts_17,	/* 290 */
	_nts_17,	/* 291 */
	_nts_17,	/* 292 */
	_nts_17,	/* 293 */
	_nts_4,	/* 294 */
	_nts_4,	/* 295 */
	_nts_4,	/* 296 */
	_nts_17,	/* 297 */
	_nts_17,	/* 298 */
	_nts_17,	/* 299 */
	_nts_17,	/* 300 */
	_nts_4,	/* 301 */
	_nts_24,	/* 302 */
	_nts_24,	/* 303 */
	_nts_24,	/* 304 */
	_nts_24,	/* 305 */
	_nts_13,	/* 306 */
	_nts_4,	/* 307 */
	_nts_4,	/* 308 */
	_nts_4,	/* 309 */
	_nts_13,	/* 310 */
	_nts_4,	/* 311 */
	_nts_4,	/* 312 */
	_nts_4,	/* 313 */
	_nts_13,	/* 314 */
	_nts_4,	/* 315 */
	_nts_4,	/* 316 */
	_nts_4,	/* 317 */
	_nts_13,	/* 318 */
	_nts_34,	/* 319 */
	_nts_34,	/* 320 */
	_nts_34,	/* 321 */
	_nts_4,	/* 322 */
	_nts_4,	/* 323 */
	_nts_4,	/* 324 */
	_nts_13,	/* 325 */
	_nts_4,	/* 326 */
	_nts_13,	/* 327 */
	_nts_4,	/* 328 */
	_nts_13,	/* 329 */
	_nts_4,	/* 330 */
	_nts_4,	/* 331 */
	_nts_13,	/* 332 */
	_nts_4,	/* 333 */
	_nts_13,	/* 334 */
	_nts_4,	/* 335 */
	_nts_13,	/* 336 */
	_nts_4,	/* 337 */
	_nts_4,	/* 338 */
	_nts_13,	/* 339 */
	_nts_4,	/* 340 */
	_nts_13,	/* 341 */
	_nts_4,	/* 342 */
	_nts_4,	/* 343 */
	_nts_0,	/* 344 */
	_nts_14,	/* 345 */
	_nts_4,	/* 346 */
	_nts_17,	/* 347 */
	_nts_17,	/* 348 */
	_nts_17,	/* 349 */
	_nts_17,	/* 350 */
	_nts_17,	/* 351 */
	_nts_17,	/* 352 */
	_nts_17,	/* 353 */
	_nts_17,	/* 354 */
	_nts_17,	/* 355 */
	_nts_17,	/* 356 */
	_nts_17,	/* 357 */
	_nts_17,	/* 358 */
	_nts_17,	/* 359 */
	_nts_17,	/* 360 */
	_nts_17,	/* 361 */
	_nts_17,	/* 362 */
	_nts_17,	/* 363 */
	_nts_17,	/* 364 */
	_nts_17,	/* 365 */
	_nts_17,	/* 366 */
	_nts_24,	/* 367 */
	_nts_24,	/* 368 */
	_nts_24,	/* 369 */
	_nts_24,	/* 370 */
	_nts_24,	/* 371 */
	_nts_24,	/* 372 */
	_nts_24,	/* 373 */
	_nts_24,	/* 374 */
	_nts_24,	/* 375 */
	_nts_24,	/* 376 */
	_nts_24,	/* 377 */
	_nts_24,	/* 378 */
	_nts_30,	/* 379 */
	_nts_30,	/* 380 */
	_nts_30,	/* 381 */
	_nts_30,	/* 382 */
	_nts_30,	/* 383 */
	_nts_30,	/* 384 */
	_nts_30,	/* 385 */
	_nts_30,	/* 386 */
	_nts_17,	/* 387 */
	_nts_17,	/* 388 */
	_nts_17,	/* 389 */
	_nts_17,	/* 390 */
	_nts_17,	/* 391 */
	_nts_17,	/* 392 */
	_nts_17,	/* 393 */
	_nts_17,	/* 394 */
	_nts_17,	/* 395 */
	_nts_17,	/* 396 */
	_nts_24,	/* 397 */
	_nts_24,	/* 398 */
	_nts_24,	/* 399 */
	_nts_24,	/* 400 */
	_nts_24,	/* 401 */
	_nts_24,	/* 402 */
	_nts_0,	/* 403 */
	_nts_0,	/* 404 */
	_nts_35,	/* 405 */
	_nts_35,	/* 406 */
	_nts_35,	/* 407 */
	_nts_35,	/* 408 */
	_nts_35,	/* 409 */
	_nts_35,	/* 410 */
	_nts_35,	/* 411 */
	_nts_35,	/* 412 */
	_nts_36,	/* 413 */
	_nts_4,	/* 414 */
	_nts_4,	/* 415 */
	_nts_4,	/* 416 */
	_nts_4,	/* 417 */
	_nts_4,	/* 418 */
	_nts_4,	/* 419 */
	_nts_4,	/* 420 */
	_nts_4,	/* 421 */
	_nts_17,	/* 422 */
	_nts_13,	/* 423 */
	_nts_13,	/* 424 */
	_nts_13,	/* 425 */
	_nts_4,	/* 426 */
	_nts_4,	/* 427 */
	_nts_4,	/* 428 */
	_nts_4,	/* 429 */
	_nts_0,	/* 430 */
	_nts_4,	/* 431 */
	_nts_4,	/* 432 */
	_nts_4,	/* 433 */
	_nts_4,	/* 434 */
	_nts_13,	/* 435 */
	_nts_13,	/* 436 */
	_nts_13,	/* 437 */
	_nts_17,	/* 438 */
};

static char *_templates[] = {
/* 0 */	0,
/* 1 */	"\n",	/* sread8: STACKP */
/* 2 */	"rrot\n",	/* sread8: STACKP */
/* 3 */	"rot4\nrot4\n",	/* sread8: STACKP */
/* 4 */	"\n",	/* sread: STACKP */
/* 5 */	"swap\n",	/* sread: STACKP */
/* 6 */	"rot\n",	/* sread: STACKP */
/* 7 */	"rot4\n",	/* sread: STACKP */
/* 8 */	"copy%b\n",	/* sread: COPYP */
/* 9 */	"any\n",	/* sread: COPYP */
/* 10 */	"drop%b\n",	/* drop: STACKP */
/* 11 */	"ERROR - FORGOTTEN VIRTUAL!\n",	/* sread: VREGP */
/* 12 */	"\n",	/* stmt: INDIRI1(drop) */
/* 13 */	"\n",	/* stmt: INDIRU1(drop) */
/* 14 */	"\n",	/* stmt: INDIRI2(drop) */
/* 15 */	"\n",	/* stmt: INDIRU2(drop) */
/* 16 */	"\n",	/* stmt: INDIRF4(drop) */
/* 17 */	"\n",	/* stmt: INDIRI4(drop) */
/* 18 */	"\n",	/* stmt: INDIRP4(drop) */
/* 19 */	"\n",	/* stmt: INDIRU4(drop) */
/* 20 */	"\n",	/* stk: INDIRI1(sread) */
/* 21 */	"\n",	/* stk: INDIRU1(sread) */
/* 22 */	"\n",	/* stk: INDIRI2(sread) */
/* 23 */	"\n",	/* stk: INDIRU2(sread) */
/* 24 */	"\n",	/* stk: INDIRF4(sread) */
/* 25 */	"\n",	/* stk: INDIRI4(sread) */
/* 26 */	"\n",	/* stk: INDIRP4(sread) */
/* 27 */	"\n",	/* stk: INDIRU4(sread) */
/* 28 */	"\n",	/* stk2: INDIRI8(sread8) */
/* 29 */	"\n",	/* stk2: INDIRF8(sread8) */
/* 30 */	"\n",	/* stk2: INDIRU8(sread8) */
/* 31 */	"\n",	/* tuck1: TUCKI1(stk) */
/* 32 */	"\n",	/* tuck1: TUCKU1(stk) */
/* 33 */	"\n",	/* tuck1: TUCKI2(stk) */
/* 34 */	"\n",	/* tuck1: TUCKU2(stk) */
/* 35 */	"\n",	/* tuck1: TUCKI4(stk) */
/* 36 */	"\n",	/* tuck1: TUCKU4(stk) */
/* 37 */	"\n",	/* tuck1: TUCKF4(stk) */
/* 38 */	"\n",	/* tuck1: TUCKP4(stk) */
/* 39 */	"\n",	/* tuck2: TUCKI1(stk) */
/* 40 */	"\n",	/* tuck2: TUCKU1(stk) */
/* 41 */	"\n",	/* tuck2: TUCKI2(stk) */
/* 42 */	"\n",	/* tuck2: TUCKU2(stk) */
/* 43 */	"\n",	/* tuck2: TUCKI4(stk) */
/* 44 */	"\n",	/* tuck2: TUCKU4(stk) */
/* 45 */	"\n",	/* tuck2: TUCKF4(stk) */
/* 46 */	"\n",	/* tuck2: TUCKP4(stk) */
/* 47 */	"\n",	/* tuck3: TUCKI1(stk) */
/* 48 */	"\n",	/* tuck3: TUCKU1(stk) */
/* 49 */	"\n",	/* tuck3: TUCKI2(stk) */
/* 50 */	"\n",	/* tuck3: TUCKU2(stk) */
/* 51 */	"\n",	/* tuck3: TUCKI4(stk) */
/* 52 */	"\n",	/* tuck3: TUCKU4(stk) */
/* 53 */	"\n",	/* tuck3: TUCKF4(stk) */
/* 54 */	"\n",	/* tuck3: TUCKP4(stk) */
/* 55 */	"\n",	/* tuck4: TUCKI1(stk) */
/* 56 */	"\n",	/* tuck4: TUCKU1(stk) */
/* 57 */	"\n",	/* tuck4: TUCKI2(stk) */
/* 58 */	"\n",	/* tuck4: TUCKU2(stk) */
/* 59 */	"\n",	/* tuck4: TUCKI4(stk) */
/* 60 */	"\n",	/* tuck4: TUCKU4(stk) */
/* 61 */	"\n",	/* tuck4: TUCKF4(stk) */
/* 62 */	"\n",	/* tuck4: TUCKP4(stk) */
/* 63 */	"copy1\n",	/* stk: tuck1 */
/* 64 */	"tuck2\n",	/* stk: tuck2 */
/* 65 */	"tuck3\n",	/* stk: tuck3 */
/* 66 */	"tuck4\n",	/* stk: tuck4 */
/* 67 */	"\n",	/* stmt: tuck1 */
/* 68 */	"swap\n",	/* stmt: tuck2 */
/* 69 */	"rrot\n",	/* stmt: tuck3 */
/* 70 */	"rrot4\n",	/* stmt: tuck4 */
/* 71 */	"\n",	/* stmt: ASGNI1(stk,var) */
/* 72 */	"\n",	/* stmt: ASGNU1(stk,var) */
/* 73 */	"\n",	/* stmt: ASGNI2(stk,var) */
/* 74 */	"\n",	/* stmt: ASGNU2(stk,var) */
/* 75 */	"\n",	/* stmt: ASGNF4(stk,var) */
/* 76 */	"\n",	/* stmt: ASGNI4(stk,var) */
/* 77 */	"\n",	/* stmt: ASGNP4(stk,var) */
/* 78 */	"\n",	/* stmt: ASGNU4(stk,var) */
/* 79 */	"\n",	/* var: STACKP */
/* 80 */	"swap\n",	/* var: STACKP */
/* 81 */	"rrot\n",	/* var: STACKP */
/* 82 */	"rrot4\n",	/* var: STACKP */
/* 83 */	"",	/* cnst1: CNSTI1 */
/* 84 */	"",	/* cnst1: CNSTU1 */
/* 85 */	"",	/* cnst1: CNSTI2 */
/* 86 */	"",	/* cnst1: CNSTU2 */
/* 87 */	"",	/* cnst1: CNSTI4 */
/* 88 */	"",	/* cnst1: CNSTU4 */
/* 89 */	"",	/* cnst2: CNSTI1 */
/* 90 */	"",	/* cnst2: CNSTU1 */
/* 91 */	"",	/* cnst2: CNSTI2 */
/* 92 */	"",	/* cnst2: CNSTU2 */
/* 93 */	"",	/* cnst2: CNSTI4 */
/* 94 */	"",	/* cnst2: CNSTU4 */
/* 95 */	"",	/* cnst4: CNSTI1 */
/* 96 */	"",	/* cnst4: CNSTU1 */
/* 97 */	"",	/* cnst4: CNSTI2 */
/* 98 */	"",	/* cnst4: CNSTU2 */
/* 99 */	"",	/* cnst4: CNSTI4 */
/* 100 */	"",	/* cnst4: CNSTU4 */
/* 101 */	"",	/* cnst32: CNSTI4 */
/* 102 */	"%a",	/* con9: CNSTI1 */
/* 103 */	"%a",	/* con9: CNSTU1 */
/* 104 */	"%a",	/* con9: CNSTI2 */
/* 105 */	"%a",	/* con9: CNSTU2 */
/* 106 */	"%a",	/* con9: CNSTU2 */
/* 107 */	"%a",	/* con9: CNSTI4 */
/* 108 */	"%a",	/* con9: CNSTU4 */
/* 109 */	"%a",	/* con9: CNSTU4 */
/* 110 */	"%a",	/* con9: CNSTP4 */
/* 111 */	"%a",	/* ucon9: CNSTI1 */
/* 112 */	"%a",	/* ucon9: CNSTU1 */
/* 113 */	"%a",	/* ucon9: CNSTI2 */
/* 114 */	"%a",	/* ucon9: CNSTU2 */
/* 115 */	"%a",	/* ucon9: CNSTU2 */
/* 116 */	"%a",	/* ucon9: CNSTI4 */
/* 117 */	"%a",	/* ucon9: CNSTU4 */
/* 118 */	"%a",	/* ucon9: CNSTP4 */
/* 119 */	"lit2\n",	/* stk: cnst2 */
/* 120 */	"lit4\n",	/* stk: cnst4 */
/* 121 */	"%a",	/* cnst: CNSTI1 */
/* 122 */	"%a",	/* cnst: CNSTI2 */
/* 123 */	"%a",	/* cnst: CNSTI4 */
/* 124 */	"%a",	/* cnst: CNSTF4 */
/* 125 */	"%a",	/* cnst: CNSTU1 */
/* 126 */	"%a",	/* cnst: CNSTU2 */
/* 127 */	"%a",	/* cnst: CNSTU4 */
/* 128 */	"%a",	/* cnst: CNSTP4 */
/* 129 */	"lit %0\n",	/* stk: cnst */
/* 130 */	"lit %a\ntlz\ninv\nadd1\n",	/* stk2: CNSTI4 */
/* 131 */	"lit %a\nlit0\n",	/* stk2: CNSTU4 */
/* 132 */	"drop1\n",	/* stmt: stk */
/* 133 */	"drop1\ndrop1\n",	/* stmt: stk2 */
/* 134 */	"%a",	/* glob: ADDRGP4 */
/* 135 */	"%a",	/* local: ADDRLP4 */
/* 136 */	"%a",	/* local: ADDRFP4 */
/* 137 */	"lit %0\n",	/* stk: glob */
/* 138 */	"dead\n",	/* stk: NOOP */
/* 139 */	"Error - Address of parameter\n",	/* stk: ADDRFP4 */
/* 140 */	"#\n",	/* stk: ADDRLP4 */
/* 141 */	"",	/* zero: CNSTI1 */
/* 142 */	"",	/* zero: CNSTI2 */
/* 143 */	"",	/* zero: CNSTI4 */
/* 144 */	"",	/* zero: CNSTU1 */
/* 145 */	"",	/* zero: CNSTU2 */
/* 146 */	"",	/* zero: CNSTU4 */
/* 147 */	"",	/* zero: CNSTP4 */
/* 148 */	"",	/* cnst_m1: CNSTI4 */
/* 149 */	"#\n",	/* stmt: ASGNI1(stk,local) */
/* 150 */	"#\n",	/* stmt: ASGNU1(stk,local) */
/* 151 */	"#\n",	/* stmt: ASGNI2(stk,local) */
/* 152 */	"#\n",	/* stmt: ASGNU2(stk,local) */
/* 153 */	"#\n",	/* stmt: ASGNI4(stk,local) */
/* 154 */	"#\n",	/* stmt: ASGNU4(stk,local) */
/* 155 */	"#\n",	/* stmt: ASGNF4(stk,local) */
/* 156 */	"#\n",	/* stmt: ASGNP4(stk,local) */
/* 157 */	"#\n",	/* stmt: ASGNI8(stk2,local) */
/* 158 */	"#\n",	/* stmt: ASGNU8(stk2,local) */
/* 159 */	"#\n",	/* stmt: ASGNF8(stk2,local) */
/* 160 */	"stb\ndrop1\n",	/* stmt: ASGNI1(stk,stk) */
/* 161 */	"stb\ndrop1\n",	/* stmt: ASGNU1(stk,stk) */
/* 162 */	"stw\ndrop1\n",	/* stmt: ASGNI2(stk,stk) */
/* 163 */	"stw\ndrop1\n",	/* stmt: ASGNU2(stk,stk) */
/* 164 */	"stl\ndrop1\n",	/* stmt: ASGNI4(stk,stk) */
/* 165 */	"stl\ndrop1\n",	/* stmt: ASGNU4(stk,stk) */
/* 166 */	"stl\ndrop1\n",	/* stmt: ASGNP4(stk,stk) */
/* 167 */	"stl\ndrop1\n",	/* stmt: ASGNF4(stk,stk) */
/* 168 */	"stli\nstl\ndrop1\n",	/* stmt: ASGNI8(stk2,stk) */
/* 169 */	"stli\nstl\ndrop1\n",	/* stmt: ASGNU8(stk2,stk) */
/* 170 */	"stli\nstl\ndrop1\n",	/* stmt: ASGNF8(stk2,stk) */
/* 171 */	"swap\nstl\n",	/* cpyst: COPYP */
/* 172 */	"rot\nstl\nswap\n",	/* cpyst: COPYP */
/* 173 */	"rot4\nstl\nrrot\n",	/* cpyst: COPYP */
/* 174 */	"swap\nstb\n",	/* cpystb: COPYP */
/* 175 */	"rot\nstb\nswap\n",	/* cpystb: COPYP */
/* 176 */	"rot4\nstb\nrrot\n",	/* cpystb: COPYP */
/* 177 */	"swap\nstw\n",	/* cpystw: COPYP */
/* 178 */	"rot\nstw\nswap\n",	/* cpystw: COPYP */
/* 179 */	"rot4\nstw\nrrot\n",	/* cpystw: COPYP */
/* 180 */	"\n",	/* stmt: ASGNU1(stk,INDIRP4(cpystb)) */
/* 181 */	"\n",	/* stmt: ASGNI1(stk,INDIRP4(cpystb)) */
/* 182 */	"\n",	/* stmt: ASGNU2(stk,INDIRP4(cpystw)) */
/* 183 */	"\n",	/* stmt: ASGNI2(stk,INDIRP4(cpystw)) */
/* 184 */	"\n",	/* stmt: ASGNI4(stk,INDIRP4(cpyst)) */
/* 185 */	"\n",	/* stmt: ASGNU4(stk,INDIRP4(cpyst)) */
/* 186 */	"\n",	/* stmt: ASGNF4(stk,INDIRP4(cpyst)) */
/* 187 */	"\n",	/* stmt: ASGNP4(stk,INDIRP4(cpyst)) */
/* 188 */	"stl\n",	/* tuckst: TUCKP4(stk) */
/* 189 */	"stl\nswap\n",	/* tuckst: TUCKP4(stk) */
/* 190 */	"stl\nsrrot\n",	/* tuckst: TUCKP4(stk) */
/* 191 */	"\n",	/* stmt: ASGNI4(stk,tuckst) */
/* 192 */	"\n",	/* stmt: ASGNU4(stk,tuckst) */
/* 193 */	"\n",	/* stmt: ASGNF4(stk,tuckst) */
/* 194 */	"\n",	/* stmt: ASGNP4(stk,tuckst) */
/* 195 */	"#\n",	/* stk: INDIRI1(local) */
/* 196 */	"#\n",	/* stk: INDIRU1(local) */
/* 197 */	"#\n",	/* stk: INDIRI2(local) */
/* 198 */	"#\n",	/* stk: INDIRU2(local) */
/* 199 */	"#\n",	/* stk: INDIRP4(local) */
/* 200 */	"#\n",	/* stk: INDIRI4(local) */
/* 201 */	"#\n",	/* stk: INDIRU4(local) */
/* 202 */	"#\n",	/* stk: INDIRF4(local) */
/* 203 */	"#\n",	/* stk2: INDIRI8(local) */
/* 204 */	"#\n",	/* stk2: INDIRU8(local) */
/* 205 */	"#\n",	/* stk2: INDIRF8(local) */
/* 206 */	"ldb\nsxb\n",	/* stk: INDIRI1(stk) */
/* 207 */	"ldb\n",	/* stk: INDIRU1(stk) */
/* 208 */	"ldw\nsxw\n",	/* stk: INDIRI2(stk) */
/* 209 */	"ldw\n",	/* stk: INDIRU2(stk) */
/* 210 */	"ldl\n",	/* stk: INDIRI4(stk) */
/* 211 */	"ldl\n",	/* stk: INDIRU4(stk) */
/* 212 */	"ldl\n",	/* stk: INDIRP4(stk) */
/* 213 */	"ldl\n",	/* stk: INDIRF4(stk) */
/* 214 */	"ldli\nswap\nldl\nswap\n",	/* stk2: INDIRI8(stk) */
/* 215 */	"ldli\nswap\nldl\nswap\n",	/* stk2: INDIRU8(stk) */
/* 216 */	"ldli\nswap\nldl\nswap\n",	/* stk2: INDIRF8(stk) */
/* 217 */	"call __mod__\n",	/* stk: MODI4(stk,stk) */
/* 218 */	"lit0\nswap\ndivmod64\ndrop2\n",	/* stk: MODU4(stk,stk) */
/* 219 */	"mul32\ndrop1\n",	/* stk: MULI4(stk,stk) */
/* 220 */	"mul32\ndrop1\n",	/* stk: MULU4(stk,stk) */
/* 221 */	"call __div__\n",	/* stk: DIVI4(stk,stk) */
/* 222 */	"lit0\nswap\ndivmod64\ndrop1\n",	/* stk: DIVU4(stk,stk) */
/* 223 */	"call __mod64__\n",	/* stk2: MODI8(stk2,stk2) */
/* 224 */	"call __modu64__\n",	/* stk2: MODU8(stk2,stk2) */
/* 225 */	"call __mul64__\n",	/* stk2: MULI8(stk2,stk2) */
/* 226 */	"call __mul64__\n",	/* stk2: MULU8(stk2,stk2) */
/* 227 */	"call __div64__\n",	/* stk2: DIVI8(stk2,stk2) */
/* 228 */	"call __divu64__\n",	/* stk2: DIVU8(stk2,stk2) */
/* 229 */	"add1\n",	/* stk: ADDI4(stk,cnst1) */
/* 230 */	"add1\n",	/* stk: ADDP4(stk,cnst1) */
/* 231 */	"add1\n",	/* stk: ADDU4(stk,cnst1) */
/* 232 */	"sub1\n",	/* stk: ADDI4(stk,cnst_m1) */
/* 233 */	"sub1\n",	/* stk: ADDP4(stk,cnst_m1) */
/* 234 */	"sub1\n",	/* stk: ADDU4(stk,cnst_m1) */
/* 235 */	"add2\n",	/* stk: ADDI4(stk,cnst2) */
/* 236 */	"add2\n",	/* stk: ADDP4(stk,cnst2) */
/* 237 */	"add2\n",	/* stk: ADDU4(stk,cnst2) */
/* 238 */	"addl tos  %1\n",	/* stk: ADDI4(stk,con9) */
/* 239 */	"addl tos  %1\n",	/* stk: ADDP4(stk,con9) */
/* 240 */	"addl tos  %1\n",	/* stk: ADDU4(stk,con9) */
/* 241 */	"add4\n",	/* stk: ADDI4(stk,cnst4) */
/* 242 */	"add4\n",	/* stk: ADDP4(stk,cnst4) */
/* 243 */	"add4\n",	/* stk: ADDU4(stk,cnst4) */
/* 244 */	"\n",	/* stk: ADDI4(stk,zero) */
/* 245 */	"\n",	/* stk: ADDP4(stk,zero) */
/* 246 */	"\n",	/* stk: ADDU4(stk,zero) */
/* 247 */	"sub1\n",	/* stk: SUBI4(stk,cnst1) */
/* 248 */	"sub1\n",	/* stk: SUBP4(stk,cnst1) */
/* 249 */	"sub1\n",	/* stk: SUBU4(stk,cnst1) */
/* 250 */	"addl tos  -%1\n",	/* stk: SUBI4(stk,ucon9) */
/* 251 */	"addl tos  -%1\n",	/* stk: SUBP4(stk,ucon9) */
/* 252 */	"addl tos  -%1\n",	/* stk: SUBU4(stk,ucon9) */
/* 253 */	"add\n",	/* stk: ADDI4(stk,stk) */
/* 254 */	"add\n",	/* stk: ADDP4(stk,stk) */
/* 255 */	"add\n",	/* stk: ADDU4(stk,stk) */
/* 256 */	"swap\nrot4\nadd\nrrot\naddc\n",	/* stk2: ADDI8(stk2,stk2) */
/* 257 */	"swap\nrot4\nadd\nrrot\naddc\n",	/* stk2: ADDU8(stk2,stk2) */
/* 258 */	"and\n",	/* stk: BANDI4(stk,stk) */
/* 259 */	"or\n",	/* stk: BORI4(stk,stk) */
/* 260 */	"xor\n",	/* stk: BXORI4(stk,stk) */
/* 261 */	"and\n",	/* stk: BANDU4(stk,stk) */
/* 262 */	"or\n",	/* stk: BORU4(stk,stk) */
/* 263 */	"xor\n",	/* stk: BXORU4(stk,stk) */
/* 264 */	"sub\n",	/* stk: SUBI4(stk,stk) */
/* 265 */	"sub\n",	/* stk: SUBP4(stk,stk) */
/* 266 */	"sub\n",	/* stk: SUBU4(stk,stk) */
/* 267 */	"swap\nrot4\nand\nrrot\nand\n",	/* stk2: BANDI8(stk2,stk2) */
/* 268 */	"swap\nrot4\nand\nrrot\nand\n",	/* stk2: BANDU8(stk2,stk2) */
/* 269 */	"swap\nrot4\nor\nrrot\nor\n",	/* stk2: BORI8(stk2,stk2) */
/* 270 */	"swap\nrot4\nor\nrrot\nor\n",	/* stk2: BORU8(stk2,stk2) */
/* 271 */	"swap\nrot4\nxor\nrrot\nxor\n",	/* stk2: BXORI8(stk2,stk2) */
/* 272 */	"swap\nrot4\nxor\nrrot\nxor\n",	/* stk2: BXORU8(stk2,stk2) */
/* 273 */	"swap\nrot4\nsub\nrrot\nsubc\n",	/* stk2: SUBI8(stk2,stk2) */
/* 274 */	"swap\nrot4\nsub\nrrot\nsubc\n",	/* stk2: SUBU8(stk2,stk2) */
/* 275 */	"inv\nswap\ninv\nswap\n",	/* stk2: BCOMI8(stk2) */
/* 276 */	"inv\nswap\ninv\nswap\n",	/* stk2: BCOMU8(stk2) */
/* 277 */	"swap\ninv\nadd1\nswap\ninv\ntcs\nadd\nadd1\n",	/* stk2: NEGI4(stk2) */
/* 278 */	"swap\nshl\nswap\nshlc\n",	/* stk2: LSHI8(stk2,cnst1) */
/* 279 */	"swap\nshl\nswap\nshlc\n",	/* stk2: LSHU8(stk2,cnst1) */
/* 280 */	"asr\nswap\nshrc\nswap\n",	/* stk2: RSHI8(stk2,cnst1) */
/* 281 */	"shr\nswap\nshrc\nswap\n",	/* stk2: RSHU8(stk2,cnst1) */
/* 282 */	"#\n",	/* stk: LSHI4(stk,cnst) */
/* 283 */	"#\n",	/* stk: LSHU4(stk,cnst) */
/* 284 */	"#\n",	/* stk: RSHI4(stk,cnst) */
/* 285 */	"#\n",	/* stk: RSHU4(stk,cnst) */
/* 286 */	"call __bshl64__\n",	/* stk2: LSHI8(stk2,stk) */
/* 287 */	"call __bshl64__\n",	/* stk2: LSHU8(stk2,stk) */
/* 288 */	"call __basr64__\n",	/* stk2: RSHI8(stk2,stk) */
/* 289 */	"call __blsr64__\n",	/* stk2: RSHU8(stk2,stk) */
/* 290 */	"call __bshl__\n",	/* stk: LSHI4(stk,stk) */
/* 291 */	"call __bshl__\n",	/* stk: LSHU4(stk,stk) */
/* 292 */	"call __basr__\n",	/* stk: RSHI4(stk,stk) */
/* 293 */	"call __blsr__\n",	/* stk: RSHU4(stk,stk) */
/* 294 */	"inv\n",	/* stk: BCOMI4(stk) */
/* 295 */	"inv\n",	/* stk: BCOMU4(stk) */
/* 296 */	"inv\nadd1\n",	/* stk: NEGI4(stk) */
/* 297 */	"call _ufo_add_f32\n",	/* stk: ADDF4(stk,stk) */
/* 298 */	"call _ufo_div_f32\n",	/* stk: DIVF4(stk,stk) */
/* 299 */	"call _ufo_mul_f32\n",	/* stk: MULF4(stk,stk) */
/* 300 */	"call _ufo_sub_f32\n",	/* stk: SUBF4(stk,stk) */
/* 301 */	"call _ufo_neg_f32\n",	/* stk: NEGF4(stk) */
/* 302 */	"call _ufo_add_f64\n",	/* stk2: ADDF8(stk2,stk2) */
/* 303 */	"call _ufo_div_f64\n",	/* stk2: DIVF8(stk2,stk2) */
/* 304 */	"call _ufo_mul_f64\n",	/* stk2: MULF8(stk2,stk2) */
/* 305 */	"call _ufo_sub_f64\n",	/* stk2: SUBF8(stk2,stk2) */
/* 306 */	"call _ufo_neg_f64\n",	/* stk2: NEGF8(stk2) */
/* 307 */	"sxb\n",	/* stk: CVII1(stk) */
/* 308 */	"sxw\n",	/* stk: CVII2(stk) */
/* 309 */	"\n",	/* stk: CVII4(stk) */
/* 310 */	"drop1\n",	/* stk: CVII4(stk2) */
/* 311 */	"lit #ff\nand\n",	/* stk: CVIU1(stk) */
/* 312 */	"lit #ffff\nand\n",	/* stk: CVIU2(stk) */
/* 313 */	"\n",	/* stk: CVIU4(stk) */
/* 314 */	"drop2\n",	/* stk: CVIU4(stk2) */
/* 315 */	"sxb\n",	/* stk: CVUI1(stk) */
/* 316 */	"sxw\n",	/* stk: CVUI2(stk) */
/* 317 */	"\n",	/* stk: CVUI4(stk) */
/* 318 */	"drop1\n",	/* stk: CVUI4(stk2) */
/* 319 */	"drop2\ncopy1\ntlz\ninv\nadd1\n",	/* stk2: RSHI8(stk2,cnst32) */
/* 320 */	"drop2\nlit0\n",	/* stk2: RSHU8(stk2,cnst32) */
/* 321 */	"drop2\n",	/* stk: CVII4(RSHI8(stk2,cnst32)) */
/* 322 */	"lit #ff\nand\n",	/* stk: CVUU1(stk) */
/* 323 */	"lit #ffff\nand\n",	/* stk: CVUU2(stk) */
/* 324 */	"\n",	/* stk: CVUU4(stk) */
/* 325 */	"drop1\n",	/* stk: CVUU4(stk2) */
/* 326 */	"lit0\n",	/* stk2: CVIU8(stk) */
/* 327 */	"\n",	/* stk2: CVIU8(stk2) */
/* 328 */	"lit0\n",	/* stk2: CVUI8(stk) */
/* 329 */	"\n",	/* stk2: CVUI8(stk2) */
/* 330 */	"copy1\ntlz\ninv\nadd1\n",	/* stk2: CVII8(stk) */
/* 331 */	"lit0\n",	/* stk2: CVUU8(stk) */
/* 332 */	"call _ufo_f64_to_f32\n",	/* stk: CVFF4(stk2) */
/* 333 */	"call _ufo_i32_to_f32\n",	/* stk: CVIF4(stk) */
/* 334 */	"call _ufo_i64_to_f32\n",	/* stk: CVIF4(stk2) */
/* 335 */	"call _ufo_f32_to_i32\n",	/* stk: CVFI4(stk) */
/* 336 */	"call _ufo_f64_to_i32\n",	/* stk: CVFI4(stk2) */
/* 337 */	"call _ufo_f32_to_f64\n",	/* stk2: CVFF8(stk) */
/* 338 */	"call _ufo_i32_to_f64\n",	/* stk2: CVIF8(stk) */
/* 339 */	"call _ufo_i64_to_f64\n",	/* stk2: CVIF8(stk2) */
/* 340 */	"call _ufo_f32_to_i64\n",	/* stk2: CVFI8(stk) */
/* 341 */	"call _ufo_f64_to_i64\n",	/* stk2: CVFI8(stk2) */
/* 342 */	"\n",	/* stk: CVPU4(stk) */
/* 343 */	"\n",	/* stk: CVUP4(stk) */
/* 344 */	"%a:\n",	/* stmt: LABELV */
/* 345 */	"br %0\n",	/* stmt: JUMPV(glob) */
/* 346 */	"stpc\n",	/* stmt: JUMPV(stk) */
/* 347 */	"ceq\nbrnz %a\n",	/* stmt: EQI4(stk,stk) */
/* 348 */	"ceq\nbrnz %a\n",	/* stmt: EQU4(stk,stk) */
/* 349 */	"cne\nbrnz %a\n",	/* stmt: NEI4(stk,stk) */
/* 350 */	"cne\nbrnz %a\n",	/* stmt: NEU4(stk,stk) */
/* 351 */	"clt\nbrz %a\n",	/* stmt: GEI4(stk,stk) */
/* 352 */	"cgt\nbrnz %a\n",	/* stmt: GTI4(stk,stk) */
/* 353 */	"cgt\nbrz %a\n",	/* stmt: LEI4(stk,stk) */
/* 354 */	"clt\nbrnz %a\n",	/* stmt: LTI4(stk,stk) */
/* 355 */	"clt\nbrz %a\n",	/* stmt: GEU4(CVPU4(stk),stk) */
/* 356 */	"cgt\nbrnz %a\n",	/* stmt: GTU4(CVPU4(stk),stk) */
/* 357 */	"cgt\nbrz %a\n",	/* stmt: LEU4(CVPU4(stk),stk) */
/* 358 */	"clt\nbrnz %a\n",	/* stmt: LTU4(CVPU4(stk),stk) */
/* 359 */	"clt\nbrz %a\n",	/* stmt: GEU4(stk,CVPU4(stk)) */
/* 360 */	"cgt\nbrnz %a\n",	/* stmt: GTU4(stk,CVPU4(stk)) */
/* 361 */	"cgt\nbrz %a\n",	/* stmt: LEU4(stk,CVPU4(stk)) */
/* 362 */	"clt\nbrnz %a\n",	/* stmt: LTU4(stk,CVPU4(stk)) */
/* 363 */	"clt\nbrz %a\n",	/* stmt: GEU4(CVPU4(stk),CVPU4(stk)) */
/* 364 */	"cgt\nbrnz %a\n",	/* stmt: GTU4(CVPU4(stk),CVPU4(stk)) */
/* 365 */	"cgt\nbrz %a\n",	/* stmt: LEU4(CVPU4(stk),CVPU4(stk)) */
/* 366 */	"clt\nbrnz %a\n",	/* stmt: LTU4(CVPU4(stk),CVPU4(stk)) */
/* 367 */	"rot\nceq\nrrot\nceq\nand\nbrnz %a\n",	/* stmt: EQI8(stk2,stk2) */
/* 368 */	"rot\nceq\nrrot\nceq\nand\nbrnz %a\n",	/* stmt: EQU8(stk2,stk2) */
/* 369 */	"rot\ncne\nrrot\ncne\nor\nbrnz %a\n",	/* stmt: NEI8(stk2,stk2) */
/* 370 */	"rot\ncne\nrrot\ncne\nor\nbrnz %a\n",	/* stmt: NEU8(stk2,stk2) */
/* 371 */	"call cmp_int64\ntlz\nbrz %a\n",	/* stmt: GEI8(stk2,stk2) */
/* 372 */	"call cmp_int64\ntgz\nbrnz %a\n",	/* stmt: GTI8(stk2,stk2) */
/* 373 */	"call cmp_int64\ntgz\nbrz %a\n",	/* stmt: LEI8(stk2,stk2) */
/* 374 */	"call cmp_int64\ntlz\nbrnz %a\n",	/* stmt: LTI8(stk2,stk2) */
/* 375 */	"call cmp_uint64\ntlz\nbrz %a\n",	/* stmt: GEU8(stk2,stk2) */
/* 376 */	"call cmp_uint64\ntgz\nbrnz %a\n",	/* stmt: GTU8(stk2,stk2) */
/* 377 */	"call cmp_uint64\ntgz\nbrz %a\n",	/* stmt: LEU8(stk2,stk2) */
/* 378 */	"call cmp_uint64\ntlz\nbrnz %a\n",	/* stmt: LTU8(stk2,stk2) */
/* 379 */	"tlz\nbrz %a\n",	/* stmt: GEI4(stk,zero) */
/* 380 */	"tgz\nbrnz %a\n",	/* stmt: GTI4(stk,zero) */
/* 381 */	"tgz\nbrz %a\n",	/* stmt: LEI4(stk,zero) */
/* 382 */	"tlz\nbrnz %a\n",	/* stmt: LTI4(stk,zero) */
/* 383 */	"brz %a\n",	/* stmt: EQI4(stk,zero) */
/* 384 */	"brz %a\n",	/* stmt: EQU4(stk,zero) */
/* 385 */	"brnz %a\n",	/* stmt: NEI4(stk,zero) */
/* 386 */	"brnz %a\n",	/* stmt: NEU4(stk,zero) */
/* 387 */	"lit1\nror\ntuck2\nxor\nrrot\nxor\ncgt\nbrz %a\n",	/* stmt: GEU4(stk,stk) */
/* 388 */	"lit1\nror\ntuck2\nxor\nrrot\nxor\nclt\nbrnz %a\n",	/* stmt: GTU4(stk,stk) */
/* 389 */	"lit1\nror\ntuck2\nxor\nrrot\nxor\nclt\nbrz %a\n",	/* stmt: LEU4(stk,stk) */
/* 390 */	"lit1\nror\ntuck2\nxor\nrrot\nxor\ncgt\nbrnz %a\n",	/* stmt: LTU4(stk,stk) */
/* 391 */	"call _ufo_f32_eq\nbrnz %a\n",	/* stmt: EQF4(stk,stk) */
/* 392 */	"call _ufo_f32_le\nbrnz %a\n",	/* stmt: LEF4(stk,stk) */
/* 393 */	"call _ufo_f32_lt\nbrnz %a\n",	/* stmt: LTF4(stk,stk) */
/* 394 */	"call _ufo_f32_lt\nbrz %a\n",	/* stmt: GEF4(stk,stk) */
/* 395 */	"call _ufo_f32_le\nbrz %a\n",	/* stmt: GTF4(stk,stk) */
/* 396 */	"call _ufo_f32_eq\nbrz %a\n",	/* stmt: NEF4(stk,stk) */
/* 397 */	"call _ufo_f64_eq\nbrnz %a\n",	/* stmt: EQF8(stk2,stk2) */
/* 398 */	"call _ufo_f64_le\nbrnz %a\n",	/* stmt: LEF8(stk2,stk2) */
/* 399 */	"call _ufo_f64_lt\nbrnz %a\n",	/* stmt: LTF8(stk2,stk2) */
/* 400 */	"call _ufo_f64_lt\nbrz %a\n",	/* stmt: GEF8(stk2,stk2) */
/* 401 */	"call _ufo_f64_le\nbrz %a\n",	/* stmt: GTF8(stk2,stk2) */
/* 402 */	"call _ufo_f64_eq\nbrz %a\n",	/* stmt: NEF8(stk2,stk2) */
/* 403 */	"%a",	/* addr: ADDRGP4 */
/* 404 */	"%a",	/* addr: CNSTP4 */
/* 405 */	"#\n",	/* stk: CALLF4(addr) */
/* 406 */	"#\n",	/* stk: CALLI4(addr) */
/* 407 */	"#\n",	/* stk: CALLP4(addr) */
/* 408 */	"#\n",	/* stk: CALLU4(addr) */
/* 409 */	"#\n",	/* stk2: CALLF8(addr) */
/* 410 */	"#\n",	/* stk2: CALLI8(addr) */
/* 411 */	"#\n",	/* stk2: CALLU8(addr) */
/* 412 */	"#\n",	/* stmt: CALLV(addr) */
/* 413 */	"#\n",	/* stmt: CALLB(addr,stk) */
/* 414 */	"#\n",	/* stk: CALLF4(stk) */
/* 415 */	"#\n",	/* stk: CALLI4(stk) */
/* 416 */	"#\n",	/* stk: CALLP4(stk) */
/* 417 */	"#\n",	/* stk: CALLU4(stk) */
/* 418 */	"# ; 2\n",	/* stk2: CALLF8(stk) */
/* 419 */	"# ; 2\n",	/* stk2: CALLI8(stk) */
/* 420 */	"# ; 2\n",	/* stk2: CALLU8(stk) */
/* 421 */	"#\n",	/* stmt: CALLV(stk) */
/* 422 */	"#\n",	/* stmt: CALLB(stk,stk) */
/* 423 */	"\n",	/* stmt: RETF8(stk2) */
/* 424 */	"\n",	/* stmt: RETI8(stk2) */
/* 425 */	"\n",	/* stmt: RETU8(stk2) */
/* 426 */	"\n",	/* stmt: RETF4(stk) */
/* 427 */	"\n",	/* stmt: RETI4(stk) */
/* 428 */	"\n",	/* stmt: RETU4(stk) */
/* 429 */	"\n",	/* stmt: RETP4(stk) */
/* 430 */	"\n",	/* stmt: RETV */
/* 431 */	"#\n",	/* stmt: ARGF4(stk) */
/* 432 */	"#\n",	/* stmt: ARGI4(stk) */
/* 433 */	"#\n",	/* stmt: ARGP4(stk) */
/* 434 */	"#\n",	/* stmt: ARGU4(stk) */
/* 435 */	"#\n",	/* stmt: ARGF8(stk2) */
/* 436 */	"#\n",	/* stmt: ARGI8(stk2) */
/* 437 */	"#\n",	/* stmt: ARGU8(stk2) */
/* 438 */	"#\n",	/* stmt: ASGNB(INDIRB(stk),stk) */
};

static char _isinstruction[] = {
/* 0 */	0,
/* 1 */	1,	/* \n */
/* 2 */	1,	/* rrot\n */
/* 3 */	1,	/* rot4\nrot4\n */
/* 4 */	1,	/* \n */
/* 5 */	1,	/* swap\n */
/* 6 */	1,	/* rot\n */
/* 7 */	1,	/* rot4\n */
/* 8 */	1,	/* copy%b\n */
/* 9 */	1,	/* any\n */
/* 10 */	1,	/* drop%b\n */
/* 11 */	1,	/* ERROR - FORGOTTEN VIRTUAL!\n */
/* 12 */	1,	/* \n */
/* 13 */	1,	/* \n */
/* 14 */	1,	/* \n */
/* 15 */	1,	/* \n */
/* 16 */	1,	/* \n */
/* 17 */	1,	/* \n */
/* 18 */	1,	/* \n */
/* 19 */	1,	/* \n */
/* 20 */	1,	/* \n */
/* 21 */	1,	/* \n */
/* 22 */	1,	/* \n */
/* 23 */	1,	/* \n */
/* 24 */	1,	/* \n */
/* 25 */	1,	/* \n */
/* 26 */	1,	/* \n */
/* 27 */	1,	/* \n */
/* 28 */	1,	/* \n */
/* 29 */	1,	/* \n */
/* 30 */	1,	/* \n */
/* 31 */	1,	/* \n */
/* 32 */	1,	/* \n */
/* 33 */	1,	/* \n */
/* 34 */	1,	/* \n */
/* 35 */	1,	/* \n */
/* 36 */	1,	/* \n */
/* 37 */	1,	/* \n */
/* 38 */	1,	/* \n */
/* 39 */	1,	/* \n */
/* 40 */	1,	/* \n */
/* 41 */	1,	/* \n */
/* 42 */	1,	/* \n */
/* 43 */	1,	/* \n */
/* 44 */	1,	/* \n */
/* 45 */	1,	/* \n */
/* 46 */	1,	/* \n */
/* 47 */	1,	/* \n */
/* 48 */	1,	/* \n */
/* 49 */	1,	/* \n */
/* 50 */	1,	/* \n */
/* 51 */	1,	/* \n */
/* 52 */	1,	/* \n */
/* 53 */	1,	/* \n */
/* 54 */	1,	/* \n */
/* 55 */	1,	/* \n */
/* 56 */	1,	/* \n */
/* 57 */	1,	/* \n */
/* 58 */	1,	/* \n */
/* 59 */	1,	/* \n */
/* 60 */	1,	/* \n */
/* 61 */	1,	/* \n */
/* 62 */	1,	/* \n */
/* 63 */	1,	/* copy1\n */
/* 64 */	1,	/* tuck2\n */
/* 65 */	1,	/* tuck3\n */
/* 66 */	1,	/* tuck4\n */
/* 67 */	1,	/* \n */
/* 68 */	1,	/* swap\n */
/* 69 */	1,	/* rrot\n */
/* 70 */	1,	/* rrot4\n */
/* 71 */	1,	/* \n */
/* 72 */	1,	/* \n */
/* 73 */	1,	/* \n */
/* 74 */	1,	/* \n */
/* 75 */	1,	/* \n */
/* 76 */	1,	/* \n */
/* 77 */	1,	/* \n */
/* 78 */	1,	/* \n */
/* 79 */	1,	/* \n */
/* 80 */	1,	/* swap\n */
/* 81 */	1,	/* rrot\n */
/* 82 */	1,	/* rrot4\n */
/* 83 */	0,	/*  */
/* 84 */	0,	/*  */
/* 85 */	0,	/*  */
/* 86 */	0,	/*  */
/* 87 */	0,	/*  */
/* 88 */	0,	/*  */
/* 89 */	0,	/*  */
/* 90 */	0,	/*  */
/* 91 */	0,	/*  */
/* 92 */	0,	/*  */
/* 93 */	0,	/*  */
/* 94 */	0,	/*  */
/* 95 */	0,	/*  */
/* 96 */	0,	/*  */
/* 97 */	0,	/*  */
/* 98 */	0,	/*  */
/* 99 */	0,	/*  */
/* 100 */	0,	/*  */
/* 101 */	0,	/*  */
/* 102 */	0,	/* %a */
/* 103 */	0,	/* %a */
/* 104 */	0,	/* %a */
/* 105 */	0,	/* %a */
/* 106 */	0,	/* %a */
/* 107 */	0,	/* %a */
/* 108 */	0,	/* %a */
/* 109 */	0,	/* %a */
/* 110 */	0,	/* %a */
/* 111 */	0,	/* %a */
/* 112 */	0,	/* %a */
/* 113 */	0,	/* %a */
/* 114 */	0,	/* %a */
/* 115 */	0,	/* %a */
/* 116 */	0,	/* %a */
/* 117 */	0,	/* %a */
/* 118 */	0,	/* %a */
/* 119 */	1,	/* lit2\n */
/* 120 */	1,	/* lit4\n */
/* 121 */	0,	/* %a */
/* 122 */	0,	/* %a */
/* 123 */	0,	/* %a */
/* 124 */	0,	/* %a */
/* 125 */	0,	/* %a */
/* 126 */	0,	/* %a */
/* 127 */	0,	/* %a */
/* 128 */	0,	/* %a */
/* 129 */	1,	/* lit %0\n */
/* 130 */	1,	/* lit %a\ntlz\ninv\nadd1\n */
/* 131 */	1,	/* lit %a\nlit0\n */
/* 132 */	1,	/* drop1\n */
/* 133 */	1,	/* drop1\ndrop1\n */
/* 134 */	0,	/* %a */
/* 135 */	0,	/* %a */
/* 136 */	0,	/* %a */
/* 137 */	1,	/* lit %0\n */
/* 138 */	1,	/* dead\n */
/* 139 */	1,	/* Error - Address of parameter\n */
/* 140 */	1,	/* #\n */
/* 141 */	0,	/*  */
/* 142 */	0,	/*  */
/* 143 */	0,	/*  */
/* 144 */	0,	/*  */
/* 145 */	0,	/*  */
/* 146 */	0,	/*  */
/* 147 */	0,	/*  */
/* 148 */	0,	/*  */
/* 149 */	1,	/* #\n */
/* 150 */	1,	/* #\n */
/* 151 */	1,	/* #\n */
/* 152 */	1,	/* #\n */
/* 153 */	1,	/* #\n */
/* 154 */	1,	/* #\n */
/* 155 */	1,	/* #\n */
/* 156 */	1,	/* #\n */
/* 157 */	1,	/* #\n */
/* 158 */	1,	/* #\n */
/* 159 */	1,	/* #\n */
/* 160 */	1,	/* stb\ndrop1\n */
/* 161 */	1,	/* stb\ndrop1\n */
/* 162 */	1,	/* stw\ndrop1\n */
/* 163 */	1,	/* stw\ndrop1\n */
/* 164 */	1,	/* stl\ndrop1\n */
/* 165 */	1,	/* stl\ndrop1\n */
/* 166 */	1,	/* stl\ndrop1\n */
/* 167 */	1,	/* stl\ndrop1\n */
/* 168 */	1,	/* stli\nstl\ndrop1\n */
/* 169 */	1,	/* stli\nstl\ndrop1\n */
/* 170 */	1,	/* stli\nstl\ndrop1\n */
/* 171 */	1,	/* swap\nstl\n */
/* 172 */	1,	/* rot\nstl\nswap\n */
/* 173 */	1,	/* rot4\nstl\nrrot\n */
/* 174 */	1,	/* swap\nstb\n */
/* 175 */	1,	/* rot\nstb\nswap\n */
/* 176 */	1,	/* rot4\nstb\nrrot\n */
/* 177 */	1,	/* swap\nstw\n */
/* 178 */	1,	/* rot\nstw\nswap\n */
/* 179 */	1,	/* rot4\nstw\nrrot\n */
/* 180 */	1,	/* \n */
/* 181 */	1,	/* \n */
/* 182 */	1,	/* \n */
/* 183 */	1,	/* \n */
/* 184 */	1,	/* \n */
/* 185 */	1,	/* \n */
/* 186 */	1,	/* \n */
/* 187 */	1,	/* \n */
/* 188 */	1,	/* stl\n */
/* 189 */	1,	/* stl\nswap\n */
/* 190 */	1,	/* stl\nsrrot\n */
/* 191 */	1,	/* \n */
/* 192 */	1,	/* \n */
/* 193 */	1,	/* \n */
/* 194 */	1,	/* \n */
/* 195 */	1,	/* #\n */
/* 196 */	1,	/* #\n */
/* 197 */	1,	/* #\n */
/* 198 */	1,	/* #\n */
/* 199 */	1,	/* #\n */
/* 200 */	1,	/* #\n */
/* 201 */	1,	/* #\n */
/* 202 */	1,	/* #\n */
/* 203 */	1,	/* #\n */
/* 204 */	1,	/* #\n */
/* 205 */	1,	/* #\n */
/* 206 */	1,	/* ldb\nsxb\n */
/* 207 */	1,	/* ldb\n */
/* 208 */	1,	/* ldw\nsxw\n */
/* 209 */	1,	/* ldw\n */
/* 210 */	1,	/* ldl\n */
/* 211 */	1,	/* ldl\n */
/* 212 */	1,	/* ldl\n */
/* 213 */	1,	/* ldl\n */
/* 214 */	1,	/* ldli\nswap\nldl\nswap\n */
/* 215 */	1,	/* ldli\nswap\nldl\nswap\n */
/* 216 */	1,	/* ldli\nswap\nldl\nswap\n */
/* 217 */	1,	/* call __mod__\n */
/* 218 */	1,	/* lit0\nswap\ndivmod64\ndrop2\n */
/* 219 */	1,	/* mul32\ndrop1\n */
/* 220 */	1,	/* mul32\ndrop1\n */
/* 221 */	1,	/* call __div__\n */
/* 222 */	1,	/* lit0\nswap\ndivmod64\ndrop1\n */
/* 223 */	1,	/* call __mod64__\n */
/* 224 */	1,	/* call __modu64__\n */
/* 225 */	1,	/* call __mul64__\n */
/* 226 */	1,	/* call __mul64__\n */
/* 227 */	1,	/* call __div64__\n */
/* 228 */	1,	/* call __divu64__\n */
/* 229 */	1,	/* add1\n */
/* 230 */	1,	/* add1\n */
/* 231 */	1,	/* add1\n */
/* 232 */	1,	/* sub1\n */
/* 233 */	1,	/* sub1\n */
/* 234 */	1,	/* sub1\n */
/* 235 */	1,	/* add2\n */
/* 236 */	1,	/* add2\n */
/* 237 */	1,	/* add2\n */
/* 238 */	1,	/* addl tos  %1\n */
/* 239 */	1,	/* addl tos  %1\n */
/* 240 */	1,	/* addl tos  %1\n */
/* 241 */	1,	/* add4\n */
/* 242 */	1,	/* add4\n */
/* 243 */	1,	/* add4\n */
/* 244 */	1,	/* \n */
/* 245 */	1,	/* \n */
/* 246 */	1,	/* \n */
/* 247 */	1,	/* sub1\n */
/* 248 */	1,	/* sub1\n */
/* 249 */	1,	/* sub1\n */
/* 250 */	1,	/* addl tos  -%1\n */
/* 251 */	1,	/* addl tos  -%1\n */
/* 252 */	1,	/* addl tos  -%1\n */
/* 253 */	1,	/* add\n */
/* 254 */	1,	/* add\n */
/* 255 */	1,	/* add\n */
/* 256 */	1,	/* swap\nrot4\nadd\nrrot\naddc\n */
/* 257 */	1,	/* swap\nrot4\nadd\nrrot\naddc\n */
/* 258 */	1,	/* and\n */
/* 259 */	1,	/* or\n */
/* 260 */	1,	/* xor\n */
/* 261 */	1,	/* and\n */
/* 262 */	1,	/* or\n */
/* 263 */	1,	/* xor\n */
/* 264 */	1,	/* sub\n */
/* 265 */	1,	/* sub\n */
/* 266 */	1,	/* sub\n */
/* 267 */	1,	/* swap\nrot4\nand\nrrot\nand\n */
/* 268 */	1,	/* swap\nrot4\nand\nrrot\nand\n */
/* 269 */	1,	/* swap\nrot4\nor\nrrot\nor\n */
/* 270 */	1,	/* swap\nrot4\nor\nrrot\nor\n */
/* 271 */	1,	/* swap\nrot4\nxor\nrrot\nxor\n */
/* 272 */	1,	/* swap\nrot4\nxor\nrrot\nxor\n */
/* 273 */	1,	/* swap\nrot4\nsub\nrrot\nsubc\n */
/* 274 */	1,	/* swap\nrot4\nsub\nrrot\nsubc\n */
/* 275 */	1,	/* inv\nswap\ninv\nswap\n */
/* 276 */	1,	/* inv\nswap\ninv\nswap\n */
/* 277 */	1,	/* swap\ninv\nadd1\nswap\ninv\ntcs\nadd\nadd1\n */
/* 278 */	1,	/* swap\nshl\nswap\nshlc\n */
/* 279 */	1,	/* swap\nshl\nswap\nshlc\n */
/* 280 */	1,	/* asr\nswap\nshrc\nswap\n */
/* 281 */	1,	/* shr\nswap\nshrc\nswap\n */
/* 282 */	1,	/* #\n */
/* 283 */	1,	/* #\n */
/* 284 */	1,	/* #\n */
/* 285 */	1,	/* #\n */
/* 286 */	1,	/* call __bshl64__\n */
/* 287 */	1,	/* call __bshl64__\n */
/* 288 */	1,	/* call __basr64__\n */
/* 289 */	1,	/* call __blsr64__\n */
/* 290 */	1,	/* call __bshl__\n */
/* 291 */	1,	/* call __bshl__\n */
/* 292 */	1,	/* call __basr__\n */
/* 293 */	1,	/* call __blsr__\n */
/* 294 */	1,	/* inv\n */
/* 295 */	1,	/* inv\n */
/* 296 */	1,	/* inv\nadd1\n */
/* 297 */	1,	/* call _ufo_add_f32\n */
/* 298 */	1,	/* call _ufo_div_f32\n */
/* 299 */	1,	/* call _ufo_mul_f32\n */
/* 300 */	1,	/* call _ufo_sub_f32\n */
/* 301 */	1,	/* call _ufo_neg_f32\n */
/* 302 */	1,	/* call _ufo_add_f64\n */
/* 303 */	1,	/* call _ufo_div_f64\n */
/* 304 */	1,	/* call _ufo_mul_f64\n */
/* 305 */	1,	/* call _ufo_sub_f64\n */
/* 306 */	1,	/* call _ufo_neg_f64\n */
/* 307 */	1,	/* sxb\n */
/* 308 */	1,	/* sxw\n */
/* 309 */	1,	/* \n */
/* 310 */	1,	/* drop1\n */
/* 311 */	1,	/* lit #ff\nand\n */
/* 312 */	1,	/* lit #ffff\nand\n */
/* 313 */	1,	/* \n */
/* 314 */	1,	/* drop2\n */
/* 315 */	1,	/* sxb\n */
/* 316 */	1,	/* sxw\n */
/* 317 */	1,	/* \n */
/* 318 */	1,	/* drop1\n */
/* 319 */	1,	/* drop2\ncopy1\ntlz\ninv\nadd1\n */
/* 320 */	1,	/* drop2\nlit0\n */
/* 321 */	1,	/* drop2\n */
/* 322 */	1,	/* lit #ff\nand\n */
/* 323 */	1,	/* lit #ffff\nand\n */
/* 324 */	1,	/* \n */
/* 325 */	1,	/* drop1\n */
/* 326 */	1,	/* lit0\n */
/* 327 */	1,	/* \n */
/* 328 */	1,	/* lit0\n */
/* 329 */	1,	/* \n */
/* 330 */	1,	/* copy1\ntlz\ninv\nadd1\n */
/* 331 */	1,	/* lit0\n */
/* 332 */	1,	/* call _ufo_f64_to_f32\n */
/* 333 */	1,	/* call _ufo_i32_to_f32\n */
/* 334 */	1,	/* call _ufo_i64_to_f32\n */
/* 335 */	1,	/* call _ufo_f32_to_i32\n */
/* 336 */	1,	/* call _ufo_f64_to_i32\n */
/* 337 */	1,	/* call _ufo_f32_to_f64\n */
/* 338 */	1,	/* call _ufo_i32_to_f64\n */
/* 339 */	1,	/* call _ufo_i64_to_f64\n */
/* 340 */	1,	/* call _ufo_f32_to_i64\n */
/* 341 */	1,	/* call _ufo_f64_to_i64\n */
/* 342 */	1,	/* \n */
/* 343 */	1,	/* \n */
/* 344 */	1,	/* %a:\n */
/* 345 */	1,	/* br %0\n */
/* 346 */	1,	/* stpc\n */
/* 347 */	1,	/* ceq\nbrnz %a\n */
/* 348 */	1,	/* ceq\nbrnz %a\n */
/* 349 */	1,	/* cne\nbrnz %a\n */
/* 350 */	1,	/* cne\nbrnz %a\n */
/* 351 */	1,	/* clt\nbrz %a\n */
/* 352 */	1,	/* cgt\nbrnz %a\n */
/* 353 */	1,	/* cgt\nbrz %a\n */
/* 354 */	1,	/* clt\nbrnz %a\n */
/* 355 */	1,	/* clt\nbrz %a\n */
/* 356 */	1,	/* cgt\nbrnz %a\n */
/* 357 */	1,	/* cgt\nbrz %a\n */
/* 358 */	1,	/* clt\nbrnz %a\n */
/* 359 */	1,	/* clt\nbrz %a\n */
/* 360 */	1,	/* cgt\nbrnz %a\n */
/* 361 */	1,	/* cgt\nbrz %a\n */
/* 362 */	1,	/* clt\nbrnz %a\n */
/* 363 */	1,	/* clt\nbrz %a\n */
/* 364 */	1,	/* cgt\nbrnz %a\n */
/* 365 */	1,	/* cgt\nbrz %a\n */
/* 366 */	1,	/* clt\nbrnz %a\n */
/* 367 */	1,	/* rot\nceq\nrrot\nceq\nand\nbrnz %a\n */
/* 368 */	1,	/* rot\nceq\nrrot\nceq\nand\nbrnz %a\n */
/* 369 */	1,	/* rot\ncne\nrrot\ncne\nor\nbrnz %a\n */
/* 370 */	1,	/* rot\ncne\nrrot\ncne\nor\nbrnz %a\n */
/* 371 */	1,	/* call cmp_int64\ntlz\nbrz %a\n */
/* 372 */	1,	/* call cmp_int64\ntgz\nbrnz %a\n */
/* 373 */	1,	/* call cmp_int64\ntgz\nbrz %a\n */
/* 374 */	1,	/* call cmp_int64\ntlz\nbrnz %a\n */
/* 375 */	1,	/* call cmp_uint64\ntlz\nbrz %a\n */
/* 376 */	1,	/* call cmp_uint64\ntgz\nbrnz %a\n */
/* 377 */	1,	/* call cmp_uint64\ntgz\nbrz %a\n */
/* 378 */	1,	/* call cmp_uint64\ntlz\nbrnz %a\n */
/* 379 */	1,	/* tlz\nbrz %a\n */
/* 380 */	1,	/* tgz\nbrnz %a\n */
/* 381 */	1,	/* tgz\nbrz %a\n */
/* 382 */	1,	/* tlz\nbrnz %a\n */
/* 383 */	1,	/* brz %a\n */
/* 384 */	1,	/* brz %a\n */
/* 385 */	1,	/* brnz %a\n */
/* 386 */	1,	/* brnz %a\n */
/* 387 */	1,	/* lit1\nror\ntuck2\nxor\nrrot\nxor\ncgt\nbrz %a\n */
/* 388 */	1,	/* lit1\nror\ntuck2\nxor\nrrot\nxor\nclt\nbrnz %a\n */
/* 389 */	1,	/* lit1\nror\ntuck2\nxor\nrrot\nxor\nclt\nbrz %a\n */
/* 390 */	1,	/* lit1\nror\ntuck2\nxor\nrrot\nxor\ncgt\nbrnz %a\n */
/* 391 */	1,	/* call _ufo_f32_eq\nbrnz %a\n */
/* 392 */	1,	/* call _ufo_f32_le\nbrnz %a\n */
/* 393 */	1,	/* call _ufo_f32_lt\nbrnz %a\n */
/* 394 */	1,	/* call _ufo_f32_lt\nbrz %a\n */
/* 395 */	1,	/* call _ufo_f32_le\nbrz %a\n */
/* 396 */	1,	/* call _ufo_f32_eq\nbrz %a\n */
/* 397 */	1,	/* call _ufo_f64_eq\nbrnz %a\n */
/* 398 */	1,	/* call _ufo_f64_le\nbrnz %a\n */
/* 399 */	1,	/* call _ufo_f64_lt\nbrnz %a\n */
/* 400 */	1,	/* call _ufo_f64_lt\nbrz %a\n */
/* 401 */	1,	/* call _ufo_f64_le\nbrz %a\n */
/* 402 */	1,	/* call _ufo_f64_eq\nbrz %a\n */
/* 403 */	0,	/* %a */
/* 404 */	0,	/* %a */
/* 405 */	1,	/* #\n */
/* 406 */	1,	/* #\n */
/* 407 */	1,	/* #\n */
/* 408 */	1,	/* #\n */
/* 409 */	1,	/* #\n */
/* 410 */	1,	/* #\n */
/* 411 */	1,	/* #\n */
/* 412 */	1,	/* #\n */
/* 413 */	1,	/* #\n */
/* 414 */	1,	/* #\n */
/* 415 */	1,	/* #\n */
/* 416 */	1,	/* #\n */
/* 417 */	1,	/* #\n */
/* 418 */	1,	/* # ; 2\n */
/* 419 */	1,	/* # ; 2\n */
/* 420 */	1,	/* # ; 2\n */
/* 421 */	1,	/* #\n */
/* 422 */	1,	/* #\n */
/* 423 */	1,	/* \n */
/* 424 */	1,	/* \n */
/* 425 */	1,	/* \n */
/* 426 */	1,	/* \n */
/* 427 */	1,	/* \n */
/* 428 */	1,	/* \n */
/* 429 */	1,	/* \n */
/* 430 */	1,	/* \n */
/* 431 */	1,	/* #\n */
/* 432 */	1,	/* #\n */
/* 433 */	1,	/* #\n */
/* 434 */	1,	/* #\n */
/* 435 */	1,	/* #\n */
/* 436 */	1,	/* #\n */
/* 437 */	1,	/* #\n */
/* 438 */	1,	/* #\n */
};

static char *_string[] = {
/* 0 */	0,
/* 1 */	"sread8: STACKP",
/* 2 */	"sread8: STACKP",
/* 3 */	"sread8: STACKP",
/* 4 */	"sread: STACKP",
/* 5 */	"sread: STACKP",
/* 6 */	"sread: STACKP",
/* 7 */	"sread: STACKP",
/* 8 */	"sread: COPYP",
/* 9 */	"sread: COPYP",
/* 10 */	"drop: STACKP",
/* 11 */	"sread: VREGP",
/* 12 */	"stmt: INDIRI1(drop)",
/* 13 */	"stmt: INDIRU1(drop)",
/* 14 */	"stmt: INDIRI2(drop)",
/* 15 */	"stmt: INDIRU2(drop)",
/* 16 */	"stmt: INDIRF4(drop)",
/* 17 */	"stmt: INDIRI4(drop)",
/* 18 */	"stmt: INDIRP4(drop)",
/* 19 */	"stmt: INDIRU4(drop)",
/* 20 */	"stk: INDIRI1(sread)",
/* 21 */	"stk: INDIRU1(sread)",
/* 22 */	"stk: INDIRI2(sread)",
/* 23 */	"stk: INDIRU2(sread)",
/* 24 */	"stk: INDIRF4(sread)",
/* 25 */	"stk: INDIRI4(sread)",
/* 26 */	"stk: INDIRP4(sread)",
/* 27 */	"stk: INDIRU4(sread)",
/* 28 */	"stk2: INDIRI8(sread8)",
/* 29 */	"stk2: INDIRF8(sread8)",
/* 30 */	"stk2: INDIRU8(sread8)",
/* 31 */	"tuck1: TUCKI1(stk)",
/* 32 */	"tuck1: TUCKU1(stk)",
/* 33 */	"tuck1: TUCKI2(stk)",
/* 34 */	"tuck1: TUCKU2(stk)",
/* 35 */	"tuck1: TUCKI4(stk)",
/* 36 */	"tuck1: TUCKU4(stk)",
/* 37 */	"tuck1: TUCKF4(stk)",
/* 38 */	"tuck1: TUCKP4(stk)",
/* 39 */	"tuck2: TUCKI1(stk)",
/* 40 */	"tuck2: TUCKU1(stk)",
/* 41 */	"tuck2: TUCKI2(stk)",
/* 42 */	"tuck2: TUCKU2(stk)",
/* 43 */	"tuck2: TUCKI4(stk)",
/* 44 */	"tuck2: TUCKU4(stk)",
/* 45 */	"tuck2: TUCKF4(stk)",
/* 46 */	"tuck2: TUCKP4(stk)",
/* 47 */	"tuck3: TUCKI1(stk)",
/* 48 */	"tuck3: TUCKU1(stk)",
/* 49 */	"tuck3: TUCKI2(stk)",
/* 50 */	"tuck3: TUCKU2(stk)",
/* 51 */	"tuck3: TUCKI4(stk)",
/* 52 */	"tuck3: TUCKU4(stk)",
/* 53 */	"tuck3: TUCKF4(stk)",
/* 54 */	"tuck3: TUCKP4(stk)",
/* 55 */	"tuck4: TUCKI1(stk)",
/* 56 */	"tuck4: TUCKU1(stk)",
/* 57 */	"tuck4: TUCKI2(stk)",
/* 58 */	"tuck4: TUCKU2(stk)",
/* 59 */	"tuck4: TUCKI4(stk)",
/* 60 */	"tuck4: TUCKU4(stk)",
/* 61 */	"tuck4: TUCKF4(stk)",
/* 62 */	"tuck4: TUCKP4(stk)",
/* 63 */	"stk: tuck1",
/* 64 */	"stk: tuck2",
/* 65 */	"stk: tuck3",
/* 66 */	"stk: tuck4",
/* 67 */	"stmt: tuck1",
/* 68 */	"stmt: tuck2",
/* 69 */	"stmt: tuck3",
/* 70 */	"stmt: tuck4",
/* 71 */	"stmt: ASGNI1(stk,var)",
/* 72 */	"stmt: ASGNU1(stk,var)",
/* 73 */	"stmt: ASGNI2(stk,var)",
/* 74 */	"stmt: ASGNU2(stk,var)",
/* 75 */	"stmt: ASGNF4(stk,var)",
/* 76 */	"stmt: ASGNI4(stk,var)",
/* 77 */	"stmt: ASGNP4(stk,var)",
/* 78 */	"stmt: ASGNU4(stk,var)",
/* 79 */	"var: STACKP",
/* 80 */	"var: STACKP",
/* 81 */	"var: STACKP",
/* 82 */	"var: STACKP",
/* 83 */	"cnst1: CNSTI1",
/* 84 */	"cnst1: CNSTU1",
/* 85 */	"cnst1: CNSTI2",
/* 86 */	"cnst1: CNSTU2",
/* 87 */	"cnst1: CNSTI4",
/* 88 */	"cnst1: CNSTU4",
/* 89 */	"cnst2: CNSTI1",
/* 90 */	"cnst2: CNSTU1",
/* 91 */	"cnst2: CNSTI2",
/* 92 */	"cnst2: CNSTU2",
/* 93 */	"cnst2: CNSTI4",
/* 94 */	"cnst2: CNSTU4",
/* 95 */	"cnst4: CNSTI1",
/* 96 */	"cnst4: CNSTU1",
/* 97 */	"cnst4: CNSTI2",
/* 98 */	"cnst4: CNSTU2",
/* 99 */	"cnst4: CNSTI4",
/* 100 */	"cnst4: CNSTU4",
/* 101 */	"cnst32: CNSTI4",
/* 102 */	"con9: CNSTI1",
/* 103 */	"con9: CNSTU1",
/* 104 */	"con9: CNSTI2",
/* 105 */	"con9: CNSTU2",
/* 106 */	"con9: CNSTU2",
/* 107 */	"con9: CNSTI4",
/* 108 */	"con9: CNSTU4",
/* 109 */	"con9: CNSTU4",
/* 110 */	"con9: CNSTP4",
/* 111 */	"ucon9: CNSTI1",
/* 112 */	"ucon9: CNSTU1",
/* 113 */	"ucon9: CNSTI2",
/* 114 */	"ucon9: CNSTU2",
/* 115 */	"ucon9: CNSTU2",
/* 116 */	"ucon9: CNSTI4",
/* 117 */	"ucon9: CNSTU4",
/* 118 */	"ucon9: CNSTP4",
/* 119 */	"stk: cnst2",
/* 120 */	"stk: cnst4",
/* 121 */	"cnst: CNSTI1",
/* 122 */	"cnst: CNSTI2",
/* 123 */	"cnst: CNSTI4",
/* 124 */	"cnst: CNSTF4",
/* 125 */	"cnst: CNSTU1",
/* 126 */	"cnst: CNSTU2",
/* 127 */	"cnst: CNSTU4",
/* 128 */	"cnst: CNSTP4",
/* 129 */	"stk: cnst",
/* 130 */	"stk2: CNSTI4",
/* 131 */	"stk2: CNSTU4",
/* 132 */	"stmt: stk",
/* 133 */	"stmt: stk2",
/* 134 */	"glob: ADDRGP4",
/* 135 */	"local: ADDRLP4",
/* 136 */	"local: ADDRFP4",
/* 137 */	"stk: glob",
/* 138 */	"stk: NOOP",
/* 139 */	"stk: ADDRFP4",
/* 140 */	"stk: ADDRLP4",
/* 141 */	"zero: CNSTI1",
/* 142 */	"zero: CNSTI2",
/* 143 */	"zero: CNSTI4",
/* 144 */	"zero: CNSTU1",
/* 145 */	"zero: CNSTU2",
/* 146 */	"zero: CNSTU4",
/* 147 */	"zero: CNSTP4",
/* 148 */	"cnst_m1: CNSTI4",
/* 149 */	"stmt: ASGNI1(stk,local)",
/* 150 */	"stmt: ASGNU1(stk,local)",
/* 151 */	"stmt: ASGNI2(stk,local)",
/* 152 */	"stmt: ASGNU2(stk,local)",
/* 153 */	"stmt: ASGNI4(stk,local)",
/* 154 */	"stmt: ASGNU4(stk,local)",
/* 155 */	"stmt: ASGNF4(stk,local)",
/* 156 */	"stmt: ASGNP4(stk,local)",
/* 157 */	"stmt: ASGNI8(stk2,local)",
/* 158 */	"stmt: ASGNU8(stk2,local)",
/* 159 */	"stmt: ASGNF8(stk2,local)",
/* 160 */	"stmt: ASGNI1(stk,stk)",
/* 161 */	"stmt: ASGNU1(stk,stk)",
/* 162 */	"stmt: ASGNI2(stk,stk)",
/* 163 */	"stmt: ASGNU2(stk,stk)",
/* 164 */	"stmt: ASGNI4(stk,stk)",
/* 165 */	"stmt: ASGNU4(stk,stk)",
/* 166 */	"stmt: ASGNP4(stk,stk)",
/* 167 */	"stmt: ASGNF4(stk,stk)",
/* 168 */	"stmt: ASGNI8(stk2,stk)",
/* 169 */	"stmt: ASGNU8(stk2,stk)",
/* 170 */	"stmt: ASGNF8(stk2,stk)",
/* 171 */	"cpyst: COPYP",
/* 172 */	"cpyst: COPYP",
/* 173 */	"cpyst: COPYP",
/* 174 */	"cpystb: COPYP",
/* 175 */	"cpystb: COPYP",
/* 176 */	"cpystb: COPYP",
/* 177 */	"cpystw: COPYP",
/* 178 */	"cpystw: COPYP",
/* 179 */	"cpystw: COPYP",
/* 180 */	"stmt: ASGNU1(stk,INDIRP4(cpystb))",
/* 181 */	"stmt: ASGNI1(stk,INDIRP4(cpystb))",
/* 182 */	"stmt: ASGNU2(stk,INDIRP4(cpystw))",
/* 183 */	"stmt: ASGNI2(stk,INDIRP4(cpystw))",
/* 184 */	"stmt: ASGNI4(stk,INDIRP4(cpyst))",
/* 185 */	"stmt: ASGNU4(stk,INDIRP4(cpyst))",
/* 186 */	"stmt: ASGNF4(stk,INDIRP4(cpyst))",
/* 187 */	"stmt: ASGNP4(stk,INDIRP4(cpyst))",
/* 188 */	"tuckst: TUCKP4(stk)",
/* 189 */	"tuckst: TUCKP4(stk)",
/* 190 */	"tuckst: TUCKP4(stk)",
/* 191 */	"stmt: ASGNI4(stk,tuckst)",
/* 192 */	"stmt: ASGNU4(stk,tuckst)",
/* 193 */	"stmt: ASGNF4(stk,tuckst)",
/* 194 */	"stmt: ASGNP4(stk,tuckst)",
/* 195 */	"stk: INDIRI1(local)",
/* 196 */	"stk: INDIRU1(local)",
/* 197 */	"stk: INDIRI2(local)",
/* 198 */	"stk: INDIRU2(local)",
/* 199 */	"stk: INDIRP4(local)",
/* 200 */	"stk: INDIRI4(local)",
/* 201 */	"stk: INDIRU4(local)",
/* 202 */	"stk: INDIRF4(local)",
/* 203 */	"stk2: INDIRI8(local)",
/* 204 */	"stk2: INDIRU8(local)",
/* 205 */	"stk2: INDIRF8(local)",
/* 206 */	"stk: INDIRI1(stk)",
/* 207 */	"stk: INDIRU1(stk)",
/* 208 */	"stk: INDIRI2(stk)",
/* 209 */	"stk: INDIRU2(stk)",
/* 210 */	"stk: INDIRI4(stk)",
/* 211 */	"stk: INDIRU4(stk)",
/* 212 */	"stk: INDIRP4(stk)",
/* 213 */	"stk: INDIRF4(stk)",
/* 214 */	"stk2: INDIRI8(stk)",
/* 215 */	"stk2: INDIRU8(stk)",
/* 216 */	"stk2: INDIRF8(stk)",
/* 217 */	"stk: MODI4(stk,stk)",
/* 218 */	"stk: MODU4(stk,stk)",
/* 219 */	"stk: MULI4(stk,stk)",
/* 220 */	"stk: MULU4(stk,stk)",
/* 221 */	"stk: DIVI4(stk,stk)",
/* 222 */	"stk: DIVU4(stk,stk)",
/* 223 */	"stk2: MODI8(stk2,stk2)",
/* 224 */	"stk2: MODU8(stk2,stk2)",
/* 225 */	"stk2: MULI8(stk2,stk2)",
/* 226 */	"stk2: MULU8(stk2,stk2)",
/* 227 */	"stk2: DIVI8(stk2,stk2)",
/* 228 */	"stk2: DIVU8(stk2,stk2)",
/* 229 */	"stk: ADDI4(stk,cnst1)",
/* 230 */	"stk: ADDP4(stk,cnst1)",
/* 231 */	"stk: ADDU4(stk,cnst1)",
/* 232 */	"stk: ADDI4(stk,cnst_m1)",
/* 233 */	"stk: ADDP4(stk,cnst_m1)",
/* 234 */	"stk: ADDU4(stk,cnst_m1)",
/* 235 */	"stk: ADDI4(stk,cnst2)",
/* 236 */	"stk: ADDP4(stk,cnst2)",
/* 237 */	"stk: ADDU4(stk,cnst2)",
/* 238 */	"stk: ADDI4(stk,con9)",
/* 239 */	"stk: ADDP4(stk,con9)",
/* 240 */	"stk: ADDU4(stk,con9)",
/* 241 */	"stk: ADDI4(stk,cnst4)",
/* 242 */	"stk: ADDP4(stk,cnst4)",
/* 243 */	"stk: ADDU4(stk,cnst4)",
/* 244 */	"stk: ADDI4(stk,zero)",
/* 245 */	"stk: ADDP4(stk,zero)",
/* 246 */	"stk: ADDU4(stk,zero)",
/* 247 */	"stk: SUBI4(stk,cnst1)",
/* 248 */	"stk: SUBP4(stk,cnst1)",
/* 249 */	"stk: SUBU4(stk,cnst1)",
/* 250 */	"stk: SUBI4(stk,ucon9)",
/* 251 */	"stk: SUBP4(stk,ucon9)",
/* 252 */	"stk: SUBU4(stk,ucon9)",
/* 253 */	"stk: ADDI4(stk,stk)",
/* 254 */	"stk: ADDP4(stk,stk)",
/* 255 */	"stk: ADDU4(stk,stk)",
/* 256 */	"stk2: ADDI8(stk2,stk2)",
/* 257 */	"stk2: ADDU8(stk2,stk2)",
/* 258 */	"stk: BANDI4(stk,stk)",
/* 259 */	"stk: BORI4(stk,stk)",
/* 260 */	"stk: BXORI4(stk,stk)",
/* 261 */	"stk: BANDU4(stk,stk)",
/* 262 */	"stk: BORU4(stk,stk)",
/* 263 */	"stk: BXORU4(stk,stk)",
/* 264 */	"stk: SUBI4(stk,stk)",
/* 265 */	"stk: SUBP4(stk,stk)",
/* 266 */	"stk: SUBU4(stk,stk)",
/* 267 */	"stk2: BANDI8(stk2,stk2)",
/* 268 */	"stk2: BANDU8(stk2,stk2)",
/* 269 */	"stk2: BORI8(stk2,stk2)",
/* 270 */	"stk2: BORU8(stk2,stk2)",
/* 271 */	"stk2: BXORI8(stk2,stk2)",
/* 272 */	"stk2: BXORU8(stk2,stk2)",
/* 273 */	"stk2: SUBI8(stk2,stk2)",
/* 274 */	"stk2: SUBU8(stk2,stk2)",
/* 275 */	"stk2: BCOMI8(stk2)",
/* 276 */	"stk2: BCOMU8(stk2)",
/* 277 */	"stk2: NEGI4(stk2)",
/* 278 */	"stk2: LSHI8(stk2,cnst1)",
/* 279 */	"stk2: LSHU8(stk2,cnst1)",
/* 280 */	"stk2: RSHI8(stk2,cnst1)",
/* 281 */	"stk2: RSHU8(stk2,cnst1)",
/* 282 */	"stk: LSHI4(stk,cnst)",
/* 283 */	"stk: LSHU4(stk,cnst)",
/* 284 */	"stk: RSHI4(stk,cnst)",
/* 285 */	"stk: RSHU4(stk,cnst)",
/* 286 */	"stk2: LSHI8(stk2,stk)",
/* 287 */	"stk2: LSHU8(stk2,stk)",
/* 288 */	"stk2: RSHI8(stk2,stk)",
/* 289 */	"stk2: RSHU8(stk2,stk)",
/* 290 */	"stk: LSHI4(stk,stk)",
/* 291 */	"stk: LSHU4(stk,stk)",
/* 292 */	"stk: RSHI4(stk,stk)",
/* 293 */	"stk: RSHU4(stk,stk)",
/* 294 */	"stk: BCOMI4(stk)",
/* 295 */	"stk: BCOMU4(stk)",
/* 296 */	"stk: NEGI4(stk)",
/* 297 */	"stk: ADDF4(stk,stk)",
/* 298 */	"stk: DIVF4(stk,stk)",
/* 299 */	"stk: MULF4(stk,stk)",
/* 300 */	"stk: SUBF4(stk,stk)",
/* 301 */	"stk: NEGF4(stk)",
/* 302 */	"stk2: ADDF8(stk2,stk2)",
/* 303 */	"stk2: DIVF8(stk2,stk2)",
/* 304 */	"stk2: MULF8(stk2,stk2)",
/* 305 */	"stk2: SUBF8(stk2,stk2)",
/* 306 */	"stk2: NEGF8(stk2)",
/* 307 */	"stk: CVII1(stk)",
/* 308 */	"stk: CVII2(stk)",
/* 309 */	"stk: CVII4(stk)",
/* 310 */	"stk: CVII4(stk2)",
/* 311 */	"stk: CVIU1(stk)",
/* 312 */	"stk: CVIU2(stk)",
/* 313 */	"stk: CVIU4(stk)",
/* 314 */	"stk: CVIU4(stk2)",
/* 315 */	"stk: CVUI1(stk)",
/* 316 */	"stk: CVUI2(stk)",
/* 317 */	"stk: CVUI4(stk)",
/* 318 */	"stk: CVUI4(stk2)",
/* 319 */	"stk2: RSHI8(stk2,cnst32)",
/* 320 */	"stk2: RSHU8(stk2,cnst32)",
/* 321 */	"stk: CVII4(RSHI8(stk2,cnst32))",
/* 322 */	"stk: CVUU1(stk)",
/* 323 */	"stk: CVUU2(stk)",
/* 324 */	"stk: CVUU4(stk)",
/* 325 */	"stk: CVUU4(stk2)",
/* 326 */	"stk2: CVIU8(stk)",
/* 327 */	"stk2: CVIU8(stk2)",
/* 328 */	"stk2: CVUI8(stk)",
/* 329 */	"stk2: CVUI8(stk2)",
/* 330 */	"stk2: CVII8(stk)",
/* 331 */	"stk2: CVUU8(stk)",
/* 332 */	"stk: CVFF4(stk2)",
/* 333 */	"stk: CVIF4(stk)",
/* 334 */	"stk: CVIF4(stk2)",
/* 335 */	"stk: CVFI4(stk)",
/* 336 */	"stk: CVFI4(stk2)",
/* 337 */	"stk2: CVFF8(stk)",
/* 338 */	"stk2: CVIF8(stk)",
/* 339 */	"stk2: CVIF8(stk2)",
/* 340 */	"stk2: CVFI8(stk)",
/* 341 */	"stk2: CVFI8(stk2)",
/* 342 */	"stk: CVPU4(stk)",
/* 343 */	"stk: CVUP4(stk)",
/* 344 */	"stmt: LABELV",
/* 345 */	"stmt: JUMPV(glob)",
/* 346 */	"stmt: JUMPV(stk)",
/* 347 */	"stmt: EQI4(stk,stk)",
/* 348 */	"stmt: EQU4(stk,stk)",
/* 349 */	"stmt: NEI4(stk,stk)",
/* 350 */	"stmt: NEU4(stk,stk)",
/* 351 */	"stmt: GEI4(stk,stk)",
/* 352 */	"stmt: GTI4(stk,stk)",
/* 353 */	"stmt: LEI4(stk,stk)",
/* 354 */	"stmt: LTI4(stk,stk)",
/* 355 */	"stmt: GEU4(CVPU4(stk),stk)",
/* 356 */	"stmt: GTU4(CVPU4(stk),stk)",
/* 357 */	"stmt: LEU4(CVPU4(stk),stk)",
/* 358 */	"stmt: LTU4(CVPU4(stk),stk)",
/* 359 */	"stmt: GEU4(stk,CVPU4(stk))",
/* 360 */	"stmt: GTU4(stk,CVPU4(stk))",
/* 361 */	"stmt: LEU4(stk,CVPU4(stk))",
/* 362 */	"stmt: LTU4(stk,CVPU4(stk))",
/* 363 */	"stmt: GEU4(CVPU4(stk),CVPU4(stk))",
/* 364 */	"stmt: GTU4(CVPU4(stk),CVPU4(stk))",
/* 365 */	"stmt: LEU4(CVPU4(stk),CVPU4(stk))",
/* 366 */	"stmt: LTU4(CVPU4(stk),CVPU4(stk))",
/* 367 */	"stmt: EQI8(stk2,stk2)",
/* 368 */	"stmt: EQU8(stk2,stk2)",
/* 369 */	"stmt: NEI8(stk2,stk2)",
/* 370 */	"stmt: NEU8(stk2,stk2)",
/* 371 */	"stmt: GEI8(stk2,stk2)",
/* 372 */	"stmt: GTI8(stk2,stk2)",
/* 373 */	"stmt: LEI8(stk2,stk2)",
/* 374 */	"stmt: LTI8(stk2,stk2)",
/* 375 */	"stmt: GEU8(stk2,stk2)",
/* 376 */	"stmt: GTU8(stk2,stk2)",
/* 377 */	"stmt: LEU8(stk2,stk2)",
/* 378 */	"stmt: LTU8(stk2,stk2)",
/* 379 */	"stmt: GEI4(stk,zero)",
/* 380 */	"stmt: GTI4(stk,zero)",
/* 381 */	"stmt: LEI4(stk,zero)",
/* 382 */	"stmt: LTI4(stk,zero)",
/* 383 */	"stmt: EQI4(stk,zero)",
/* 384 */	"stmt: EQU4(stk,zero)",
/* 385 */	"stmt: NEI4(stk,zero)",
/* 386 */	"stmt: NEU4(stk,zero)",
/* 387 */	"stmt: GEU4(stk,stk)",
/* 388 */	"stmt: GTU4(stk,stk)",
/* 389 */	"stmt: LEU4(stk,stk)",
/* 390 */	"stmt: LTU4(stk,stk)",
/* 391 */	"stmt: EQF4(stk,stk)",
/* 392 */	"stmt: LEF4(stk,stk)",
/* 393 */	"stmt: LTF4(stk,stk)",
/* 394 */	"stmt: GEF4(stk,stk)",
/* 395 */	"stmt: GTF4(stk,stk)",
/* 396 */	"stmt: NEF4(stk,stk)",
/* 397 */	"stmt: EQF8(stk2,stk2)",
/* 398 */	"stmt: LEF8(stk2,stk2)",
/* 399 */	"stmt: LTF8(stk2,stk2)",
/* 400 */	"stmt: GEF8(stk2,stk2)",
/* 401 */	"stmt: GTF8(stk2,stk2)",
/* 402 */	"stmt: NEF8(stk2,stk2)",
/* 403 */	"addr: ADDRGP4",
/* 404 */	"addr: CNSTP4",
/* 405 */	"stk: CALLF4(addr)",
/* 406 */	"stk: CALLI4(addr)",
/* 407 */	"stk: CALLP4(addr)",
/* 408 */	"stk: CALLU4(addr)",
/* 409 */	"stk2: CALLF8(addr)",
/* 410 */	"stk2: CALLI8(addr)",
/* 411 */	"stk2: CALLU8(addr)",
/* 412 */	"stmt: CALLV(addr)",
/* 413 */	"stmt: CALLB(addr,stk)",
/* 414 */	"stk: CALLF4(stk)",
/* 415 */	"stk: CALLI4(stk)",
/* 416 */	"stk: CALLP4(stk)",
/* 417 */	"stk: CALLU4(stk)",
/* 418 */	"stk2: CALLF8(stk)",
/* 419 */	"stk2: CALLI8(stk)",
/* 420 */	"stk2: CALLU8(stk)",
/* 421 */	"stmt: CALLV(stk)",
/* 422 */	"stmt: CALLB(stk,stk)",
/* 423 */	"stmt: RETF8(stk2)",
/* 424 */	"stmt: RETI8(stk2)",
/* 425 */	"stmt: RETU8(stk2)",
/* 426 */	"stmt: RETF4(stk)",
/* 427 */	"stmt: RETI4(stk)",
/* 428 */	"stmt: RETU4(stk)",
/* 429 */	"stmt: RETP4(stk)",
/* 430 */	"stmt: RETV",
/* 431 */	"stmt: ARGF4(stk)",
/* 432 */	"stmt: ARGI4(stk)",
/* 433 */	"stmt: ARGP4(stk)",
/* 434 */	"stmt: ARGU4(stk)",
/* 435 */	"stmt: ARGF8(stk2)",
/* 436 */	"stmt: ARGI8(stk2)",
/* 437 */	"stmt: ARGU8(stk2)",
/* 438 */	"stmt: ASGNB(INDIRB(stk),stk)",
};

static short _decode_stmt[] = {
	0,
	12,
	13,
	14,
	15,
	16,
	17,
	18,
	19,
	67,
	68,
	69,
	70,
	71,
	72,
	73,
	74,
	75,
	76,
	77,
	78,
	132,
	133,
	149,
	150,
	151,
	152,
	153,
	154,
	155,
	156,
	157,
	158,
	159,
	160,
	161,
	162,
	163,
	164,
	165,
	166,
	167,
	168,
	169,
	170,
	180,
	181,
	182,
	183,
	184,
	185,
	186,
	187,
	191,
	192,
	193,
	194,
	344,
	345,
	346,
	347,
	348,
	349,
	350,
	351,
	352,
	353,
	354,
	355,
	356,
	357,
	358,
	359,
	360,
	361,
	362,
	363,
	364,
	365,
	366,
	367,
	368,
	369,
	370,
	371,
	372,
	373,
	374,
	375,
	376,
	377,
	378,
	379,
	380,
	381,
	382,
	383,
	384,
	385,
	386,
	387,
	388,
	389,
	390,
	391,
	392,
	393,
	394,
	395,
	396,
	397,
	398,
	399,
	400,
	401,
	402,
	412,
	413,
	421,
	422,
	423,
	424,
	425,
	426,
	427,
	428,
	429,
	430,
	431,
	432,
	433,
	434,
	435,
	436,
	437,
	438,
};

static short _decode_sread8[] = {
	0,
	1,
	2,
	3,
};

static short _decode_sread[] = {
	0,
	4,
	5,
	6,
	7,
	8,
	9,
	11,
};

static short _decode_drop[] = {
	0,
	10,
};

static short _decode_stk[] = {
	0,
	20,
	21,
	22,
	23,
	24,
	25,
	26,
	27,
	63,
	64,
	65,
	66,
	119,
	120,
	129,
	137,
	138,
	139,
	140,
	195,
	196,
	197,
	198,
	199,
	200,
	201,
	202,
	206,
	207,
	208,
	209,
	210,
	211,
	212,
	213,
	217,
	218,
	219,
	220,
	221,
	222,
	229,
	230,
	231,
	232,
	233,
	234,
	235,
	236,
	237,
	238,
	239,
	240,
	241,
	242,
	243,
	244,
	245,
	246,
	247,
	248,
	249,
	250,
	251,
	252,
	253,
	254,
	255,
	258,
	259,
	260,
	261,
	262,
	263,
	264,
	265,
	266,
	282,
	283,
	284,
	285,
	290,
	291,
	292,
	293,
	294,
	295,
	296,
	297,
	298,
	299,
	300,
	301,
	307,
	308,
	309,
	310,
	311,
	312,
	313,
	314,
	315,
	316,
	317,
	318,
	321,
	322,
	323,
	324,
	325,
	332,
	333,
	334,
	335,
	336,
	342,
	343,
	405,
	406,
	407,
	408,
	414,
	415,
	416,
	417,
};

static short _decode_stk2[] = {
	0,
	28,
	29,
	30,
	130,
	131,
	203,
	204,
	205,
	214,
	215,
	216,
	223,
	224,
	225,
	226,
	227,
	228,
	256,
	257,
	267,
	268,
	269,
	270,
	271,
	272,
	273,
	274,
	275,
	276,
	277,
	278,
	279,
	280,
	281,
	286,
	287,
	288,
	289,
	302,
	303,
	304,
	305,
	306,
	319,
	320,
	326,
	327,
	328,
	329,
	330,
	331,
	337,
	338,
	339,
	340,
	341,
	409,
	410,
	411,
	418,
	419,
	420,
};

static short _decode_tuck1[] = {
	0,
	31,
	32,
	33,
	34,
	35,
	36,
	37,
	38,
};

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

static short _decode_tuck3[] = {
	0,
	47,
	48,
	49,
	50,
	51,
	52,
	53,
	54,
};

static short _decode_tuck4[] = {
	0,
	55,
	56,
	57,
	58,
	59,
	60,
	61,
	62,
};

static short _decode_var[] = {
	0,
	79,
	80,
	81,
	82,
};

static short _decode_cnst1[] = {
	0,
	83,
	84,
	85,
	86,
	87,
	88,
};

static short _decode_cnst2[] = {
	0,
	89,
	90,
	91,
	92,
	93,
	94,
};

static short _decode_cnst4[] = {
	0,
	95,
	96,
	97,
	98,
	99,
	100,
};

static short _decode_cnst32[] = {
	0,
	101,
};

static short _decode_con9[] = {
	0,
	102,
	103,
	104,
	105,
	106,
	107,
	108,
	109,
	110,
};

static short _decode_ucon9[] = {
	0,
	111,
	112,
	113,
	114,
	115,
	116,
	117,
	118,
};

static short _decode_cnst[] = {
	0,
	121,
	122,
	123,
	124,
	125,
	126,
	127,
	128,
};

static short _decode_glob[] = {
	0,
	134,
};

static short _decode_local[] = {
	0,
	135,
	136,
};

static short _decode_zero[] = {
	0,
	141,
	142,
	143,
	144,
	145,
	146,
	147,
};

static short _decode_cnst_m1[] = {
	0,
	148,
};

static short _decode_cpyst[] = {
	0,
	171,
	172,
	173,
};

static short _decode_cpystb[] = {
	0,
	174,
	175,
	176,
};

static short _decode_cpystw[] = {
	0,
	177,
	178,
	179,
};

static short _decode_tuckst[] = {
	0,
	188,
	189,
	190,
};

static short _decode_addr[] = {
	0,
	403,
	404,
};

static int _rule(void *state, int goalnt) {
	if (goalnt < 1 || goalnt > 27)
		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 _sread8_NT:	return _decode_sread8[((struct _state *)state)->rule._sread8];
	case _sread_NT:	return _decode_sread[((struct _state *)state)->rule._sread];
	case _drop_NT:	return _decode_drop[((struct _state *)state)->rule._drop];
	case _stk_NT:	return _decode_stk[((struct _state *)state)->rule._stk];
	case _stk2_NT:	return _decode_stk2[((struct _state *)state)->rule._stk2];
	case _tuck1_NT:	return _decode_tuck1[((struct _state *)state)->rule._tuck1];
	case _tuck2_NT:	return _decode_tuck2[((struct _state *)state)->rule._tuck2];
	case _tuck3_NT:	return _decode_tuck3[((struct _state *)state)->rule._tuck3];
	case _tuck4_NT:	return _decode_tuck4[((struct _state *)state)->rule._tuck4];
	case _var_NT:	return _decode_var[((struct _state *)state)->rule._var];
	case _cnst1_NT:	return _decode_cnst1[((struct _state *)state)->rule._cnst1];
	case _cnst2_NT:	return _decode_cnst2[((struct _state *)state)->rule._cnst2];
	case _cnst4_NT:	return _decode_cnst4[((struct _state *)state)->rule._cnst4];
	case _cnst32_NT:	return _decode_cnst32[((struct _state *)state)->rule._cnst32];
	case _con9_NT:	return _decode_con9[((struct _state *)state)->rule._con9];
	case _ucon9_NT:	return _decode_ucon9[((struct _state *)state)->rule._ucon9];
	case _cnst_NT:	return _decode_cnst[((struct _state *)state)->rule._cnst];
	case _glob_NT:	return _decode_glob[((struct _state *)state)->rule._glob];
	case _local_NT:	return _decode_local[((struct _state *)state)->rule._local];
	case _zero_NT:	return _decode_zero[((struct _state *)state)->rule._zero];
	case _cnst_m1_NT:	return _decode_cnst_m1[((struct _state *)state)->rule._cnst_m1];
	case _cpyst_NT:	return _decode_cpyst[((struct _state *)state)->rule._cpyst];
	case _cpystb_NT:	return _decode_cpystb[((struct _state *)state)->rule._cpystb];
	case _cpystw_NT:	return _decode_cpystw[((struct _state *)state)->rule._cpystw];
	case _tuckst_NT:	return _decode_tuckst[((struct _state *)state)->rule._tuckst];
	case _addr_NT:	return _decode_addr[((struct _state *)state)->rule._addr];
	default:
		fatal("_rule", "Bad goal nonterminal %d\n", goalnt);
		return 0;
	}
}

static void _closure_stk(NODEPTR_TYPE, int);
static void _closure_stk2(NODEPTR_TYPE, int);
static void _closure_tuck1(NODEPTR_TYPE, int);
static void _closure_tuck2(NODEPTR_TYPE, int);
static void _closure_tuck3(NODEPTR_TYPE, int);
static void _closure_tuck4(NODEPTR_TYPE, int);
static void _closure_cnst2(NODEPTR_TYPE, int);
static void _closure_cnst4(NODEPTR_TYPE, int);
static void _closure_cnst(NODEPTR_TYPE, int);
static void _closure_glob(NODEPTR_TYPE, int);

static void _closure_stk(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 1;
		p->rule._stmt = 21;
	}
}

static void _closure_stk2(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 2 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 2;
		p->rule._stmt = 22;
	}
}

static void _closure_tuck1(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 9;
	}
	if (c + 0 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 0;
		p->rule._stk = 9;
		_closure_stk(a, c + 0);
	}
}

static void _closure_tuck2(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 10;
	}
	if (c + 0 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 0;
		p->rule._stk = 10;
		_closure_stk(a, c + 0);
	}
}

static void _closure_tuck3(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 11;
	}
	if (c + 0 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 0;
		p->rule._stk = 11;
		_closure_stk(a, c + 0);
	}
}

static void _closure_tuck4(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 0 < p->cost[_stmt_NT]) {
		p->cost[_stmt_NT] = c + 0;
		p->rule._stmt = 12;
	}
	if (c + 0 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 0;
		p->rule._stk = 12;
		_closure_stk(a, c + 0);
	}
}

static void _closure_cnst2(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 1;
		p->rule._stk = 13;
		_closure_stk(a, c + 1);
	}
}

static void _closure_cnst4(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 1 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 1;
		p->rule._stk = 14;
		_closure_stk(a, c + 1);
	}
}

static void _closure_cnst(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 3 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 3;
		p->rule._stk = 15;
		_closure_stk(a, c + 3);
	}
}

static void _closure_glob(NODEPTR_TYPE a, int c) {
	struct _state *p = STATE_LABEL(a);
	if (c + 2 < p->cost[_stk_NT]) {
		p->cost[_stk_NT] = c + 2;
		p->rule._stk = 16;
		_closure_stk(a, c + 2);
	}
}

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

	if (!a)
		fatal("_label", "Null tree\n", 0);
	STATE_LABEL(a) = p = allocate(sizeof *p, FUNC);
	p->rule._stmt = 0;
	p->cost[1] =
	p->cost[2] =
	p->cost[3] =
	p->cost[4] =
	p->cost[5] =
	p->cost[6] =
	p->cost[7] =
	p->cost[8] =
	p->cost[9] =
	p->cost[10] =
	p->cost[11] =
	p->cost[12] =
	p->cost[13] =
	p->cost[14] =
	p->cost[15] =
	p->cost[16] =
	p->cost[17] =
	p->cost[18] =
	p->cost[19] =
	p->cost[20] =
	p->cost[21] =
	p->cost[22] =
	p->cost[23] =
	p->cost[24] =
	p->cost[25] =
	p->cost[26] =
	p->cost[27] =
		0x7fff;
	switch (OP_LABEL(a)) {
	case 41: /* ARGB */
		break;
	case 48: /* NOOP */
		/* stk: NOOP */
		if (0 + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = 0 + 0;
			p->rule._stk = 17;
			_closure_stk(a, 0 + 0);
		}
		break;
	case 57: /* ASGNB */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: ASGNB(INDIRB(stk),stk) */
			LEFT_CHILD(a)->op == 73 /* INDIRB */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 135;
			}
		}
		break;
	case 73: /* INDIRB */
		_label(LEFT_CHILD(a));
		break;
	case 216: /* CALLV */
		_label(LEFT_CHILD(a));
		/* stmt: CALLV(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 116;
		}
		/* stmt: CALLV(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 118;
		}
		break;
	case 217: /* CALLB */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: CALLB(addr,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 117;
		}
		/* stmt: CALLB(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 119;
		}
		break;
	case 248: /* RETV */
		/* stmt: RETV */
		if (1 + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = 1 + 0;
			p->rule._stmt = 127;
		}
		break;
	case 584: /* JUMPV */
		_label(LEFT_CHILD(a));
		/* stmt: JUMPV(glob) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_glob_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 58;
		}
		/* stmt: JUMPV(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 59;
		}
		break;
	case 600: /* LABELV */
		/* stmt: LABELV */
		if (0 + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = 0 + 0;
			p->rule._stmt = 57;
		}
		break;
	case 711: /* VREGP */
		/* sread: VREGP */
		if (0 + 0 < p->cost[_sread_NT]) {
			p->cost[_sread_NT] = 0 + 0;
			p->rule._sread = 7;
		}
		break;
	case 727: /* STACKP */
		/* sread8: STACKP */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_sread8_NT]) {
			p->cost[_sread8_NT] = c + 0;
			p->rule._sread8 = 1;
		}
		/* sread8: STACKP */
		c = (range(a, 2, 2));
		if (c + 0 < p->cost[_sread8_NT]) {
			p->cost[_sread8_NT] = c + 0;
			p->rule._sread8 = 2;
		}
		/* sread8: STACKP */
		c = (range(a, 3, 3));
		if (c + 0 < p->cost[_sread8_NT]) {
			p->cost[_sread8_NT] = c + 0;
			p->rule._sread8 = 3;
		}
		/* sread: STACKP */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_sread_NT]) {
			p->cost[_sread_NT] = c + 0;
			p->rule._sread = 1;
		}
		/* sread: STACKP */
		c = (range(a, 2, 2)+1);
		if (c + 0 < p->cost[_sread_NT]) {
			p->cost[_sread_NT] = c + 0;
			p->rule._sread = 2;
		}
		/* sread: STACKP */
		c = (range(a, 3, 3)+1);
		if (c + 0 < p->cost[_sread_NT]) {
			p->cost[_sread_NT] = c + 0;
			p->rule._sread = 3;
		}
		/* sread: STACKP */
		c = (range(a, 4, 4)+1);
		if (c + 0 < p->cost[_sread_NT]) {
			p->cost[_sread_NT] = c + 0;
			p->rule._sread = 4;
		}
		/* drop: STACKP */
		if (0 + 0 < p->cost[_drop_NT]) {
			p->cost[_drop_NT] = 0 + 0;
			p->rule._drop = 1;
		}
		/* var: STACKP */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_var_NT]) {
			p->cost[_var_NT] = c + 0;
			p->rule._var = 1;
		}
		/* var: STACKP */
		c = (range(a, 2, 2)+1);
		if (c + 0 < p->cost[_var_NT]) {
			p->cost[_var_NT] = c + 0;
			p->rule._var = 2;
		}
		/* var: STACKP */
		c = (range(a, 3, 3)+1);
		if (c + 0 < p->cost[_var_NT]) {
			p->cost[_var_NT] = c + 0;
			p->rule._var = 3;
		}
		/* var: STACKP */
		c = (range(a, 4, 4)+1);
		if (c + 0 < p->cost[_var_NT]) {
			p->cost[_var_NT] = c + 0;
			p->rule._var = 4;
		}
		break;
	case 759: /* COPYP */
		/* sread: COPYP */
		c = (range(a, 1, 4)+1);
		if (c + 0 < p->cost[_sread_NT]) {
			p->cost[_sread_NT] = c + 0;
			p->rule._sread = 5;
		}
		/* sread: COPYP */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_sread_NT]) {
			p->cost[_sread_NT] = c + 0;
			p->rule._sread = 6;
		}
		/* cpyst: COPYP */
		c = (range(a, 2, 2) + 3);
		if (c + 0 < p->cost[_cpyst_NT]) {
			p->cost[_cpyst_NT] = c + 0;
			p->rule._cpyst = 1;
		}
		/* cpyst: COPYP */
		c = (range(a, 3, 3) + 4);
		if (c + 0 < p->cost[_cpyst_NT]) {
			p->cost[_cpyst_NT] = c + 0;
			p->rule._cpyst = 2;
		}
		/* cpyst: COPYP */
		c = (range(a, 4, 4) + 4);
		if (c + 0 < p->cost[_cpyst_NT]) {
			p->cost[_cpyst_NT] = c + 0;
			p->rule._cpyst = 3;
		}
		/* cpystb: COPYP */
		c = (range(a, 2, 2) + 3);
		if (c + 0 < p->cost[_cpystb_NT]) {
			p->cost[_cpystb_NT] = c + 0;
			p->rule._cpystb = 1;
		}
		/* cpystb: COPYP */
		c = (range(a, 3, 3) + 4);
		if (c + 0 < p->cost[_cpystb_NT]) {
			p->cost[_cpystb_NT] = c + 0;
			p->rule._cpystb = 2;
		}
		/* cpystb: COPYP */
		c = (range(a, 4, 4) + 4);
		if (c + 0 < p->cost[_cpystb_NT]) {
			p->cost[_cpystb_NT] = c + 0;
			p->rule._cpystb = 3;
		}
		/* cpystw: COPYP */
		c = (range(a, 2, 2) + 3);
		if (c + 0 < p->cost[_cpystw_NT]) {
			p->cost[_cpystw_NT] = c + 0;
			p->rule._cpystw = 1;
		}
		/* cpystw: COPYP */
		c = (range(a, 3, 3) + 4);
		if (c + 0 < p->cost[_cpystw_NT]) {
			p->cost[_cpystw_NT] = c + 0;
			p->rule._cpystw = 2;
		}
		/* cpystw: COPYP */
		c = (range(a, 4, 4) + 4);
		if (c + 0 < p->cost[_cpystw_NT]) {
			p->cost[_cpystw_NT] = c + 0;
			p->rule._cpystw = 3;
		}
		break;
	case 1045: /* CNSTI1 */
		/* cnst1: CNSTI1 */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_cnst1_NT]) {
			p->cost[_cnst1_NT] = c + 0;
			p->rule._cnst1 = 1;
		}
		/* cnst2: CNSTI1 */
		c = (range(a, 2, 2));
		if (c + 0 < p->cost[_cnst2_NT]) {
			p->cost[_cnst2_NT] = c + 0;
			p->rule._cnst2 = 1;
			_closure_cnst2(a, c + 0);
		}
		/* cnst4: CNSTI1 */
		c = (range(a, 4, 4));
		if (c + 0 < p->cost[_cnst4_NT]) {
			p->cost[_cnst4_NT] = c + 0;
			p->rule._cnst4 = 1;
			_closure_cnst4(a, c + 0);
		}
		/* con9: CNSTI1 */
		if (0 + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = 0 + 0;
			p->rule._con9 = 1;
		}
		/* ucon9: CNSTI1 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = c + 0;
			p->rule._ucon9 = 1;
		}
		/* cnst: CNSTI1 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 1;
			_closure_cnst(a, 3 + 0);
		}
		/* zero: CNSTI1 */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 1;
		}
		break;
	case 1046: /* CNSTU1 */
		/* cnst1: CNSTU1 */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_cnst1_NT]) {
			p->cost[_cnst1_NT] = c + 0;
			p->rule._cnst1 = 2;
		}
		/* cnst2: CNSTU1 */
		c = (range(a, 2, 2));
		if (c + 0 < p->cost[_cnst2_NT]) {
			p->cost[_cnst2_NT] = c + 0;
			p->rule._cnst2 = 2;
			_closure_cnst2(a, c + 0);
		}
		/* cnst4: CNSTU1 */
		c = (range(a, 4, 4));
		if (c + 0 < p->cost[_cnst4_NT]) {
			p->cost[_cnst4_NT] = c + 0;
			p->rule._cnst4 = 2;
			_closure_cnst4(a, c + 0);
		}
		/* con9: CNSTU1 */
		if (0 + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = 0 + 0;
			p->rule._con9 = 2;
		}
		/* ucon9: CNSTU1 */
		if (0 + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = 0 + 0;
			p->rule._ucon9 = 2;
		}
		/* cnst: CNSTU1 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 5;
			_closure_cnst(a, 3 + 0);
		}
		/* zero: CNSTU1 */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 4;
		}
		break;
	case 1077: /* ASGNI1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNI1(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 13;
		}
		/* stmt: ASGNI1(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 23;
		}
		/* stmt: ASGNI1(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 34;
		}
		if (	/* stmt: ASGNI1(stk,INDIRP4(cpystb)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpystb_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 46;
			}
		}
		break;
	case 1078: /* ASGNU1 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNU1(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 14;
		}
		/* stmt: ASGNU1(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 24;
		}
		/* stmt: ASGNU1(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 35;
		}
		if (	/* stmt: ASGNU1(stk,INDIRP4(cpystb)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpystb_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 45;
			}
		}
		break;
	case 1093: /* INDIRI1 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRI1(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 1;
		}
		/* stk: INDIRI1(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 1;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRI1(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 20;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRI1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 28;
			_closure_stk(a, c + 0);
		}
		break;
	case 1094: /* INDIRU1 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRU1(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 2;
		}
		/* stk: INDIRU1(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 2;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRU1(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 21;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRU1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 29;
			_closure_stk(a, c + 0);
		}
		break;
	case 1157: /* CVII1 */
		_label(LEFT_CHILD(a));
		/* stk: CVII1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 94;
			_closure_stk(a, c + 0);
		}
		break;
	case 1158: /* CVIU1 */
		_label(LEFT_CHILD(a));
		/* stk: CVIU1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 98;
			_closure_stk(a, c + 0);
		}
		break;
	case 1205: /* CVUI1 */
		_label(LEFT_CHILD(a));
		/* stk: CVUI1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 102;
			_closure_stk(a, c + 0);
		}
		break;
	case 1206: /* CVUU1 */
		_label(LEFT_CHILD(a));
		/* stk: CVUU1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 107;
			_closure_stk(a, c + 0);
		}
		break;
	case 1765: /* TUCKI1 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKI1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 1;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKI1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 1;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKI1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 1;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKI1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 1;
			_closure_tuck4(a, c + 0);
		}
		break;
	case 1766: /* TUCKU1 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKU1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 2;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKU1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 2;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKU1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 2;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKU1(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 2;
			_closure_tuck4(a, c + 0);
		}
		break;
	case 2069: /* CNSTI2 */
		/* cnst1: CNSTI2 */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_cnst1_NT]) {
			p->cost[_cnst1_NT] = c + 0;
			p->rule._cnst1 = 3;
		}
		/* cnst2: CNSTI2 */
		c = (range(a, 2, 2));
		if (c + 0 < p->cost[_cnst2_NT]) {
			p->cost[_cnst2_NT] = c + 0;
			p->rule._cnst2 = 3;
			_closure_cnst2(a, c + 0);
		}
		/* cnst4: CNSTI2 */
		c = (range(a, 4, 4));
		if (c + 0 < p->cost[_cnst4_NT]) {
			p->cost[_cnst4_NT] = c + 0;
			p->rule._cnst4 = 3;
			_closure_cnst4(a, c + 0);
		}
		/* con9: CNSTI2 */
		c = (range(a, -(1<<8)+1, (1<<8)-1));
		if (c + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = c + 0;
			p->rule._con9 = 3;
		}
		/* ucon9: CNSTI2 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = c + 0;
			p->rule._ucon9 = 3;
		}
		/* cnst: CNSTI2 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 2;
			_closure_cnst(a, 3 + 0);
		}
		/* zero: CNSTI2 */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 2;
		}
		break;
	case 2070: /* CNSTU2 */
		/* cnst1: CNSTU2 */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_cnst1_NT]) {
			p->cost[_cnst1_NT] = c + 0;
			p->rule._cnst1 = 4;
		}
		/* cnst2: CNSTU2 */
		c = (range(a, 2, 2));
		if (c + 0 < p->cost[_cnst2_NT]) {
			p->cost[_cnst2_NT] = c + 0;
			p->rule._cnst2 = 4;
			_closure_cnst2(a, c + 0);
		}
		/* cnst4: CNSTU2 */
		c = (range(a, 4, 4));
		if (c + 0 < p->cost[_cnst4_NT]) {
			p->cost[_cnst4_NT] = c + 0;
			p->rule._cnst4 = 4;
			_closure_cnst4(a, c + 0);
		}
		/* con9: CNSTU2 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = c + 0;
			p->rule._con9 = 4;
		}
		/* con9: CNSTU2 */
		c = (range(a, 0xffffff01, 0xffffffff));
		if (c + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = c + 0;
			p->rule._con9 = 5;
		}
		/* ucon9: CNSTU2 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = c + 0;
			p->rule._ucon9 = 4;
		}
		/* ucon9: CNSTU2 */
		c = (range(a, 0, 0xffffffff));
		if (c + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = c + 0;
			p->rule._ucon9 = 5;
		}
		/* cnst: CNSTU2 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 6;
			_closure_cnst(a, 3 + 0);
		}
		/* zero: CNSTU2 */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 5;
		}
		break;
	case 2101: /* ASGNI2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNI2(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 15;
		}
		/* stmt: ASGNI2(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 25;
		}
		/* stmt: ASGNI2(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 36;
		}
		if (	/* stmt: ASGNI2(stk,INDIRP4(cpystw)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpystw_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 48;
			}
		}
		break;
	case 2102: /* ASGNU2 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNU2(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 16;
		}
		/* stmt: ASGNU2(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 26;
		}
		/* stmt: ASGNU2(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 37;
		}
		if (	/* stmt: ASGNU2(stk,INDIRP4(cpystw)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpystw_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 47;
			}
		}
		break;
	case 2117: /* INDIRI2 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRI2(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 3;
		}
		/* stk: INDIRI2(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 3;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRI2(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 22;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRI2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 30;
			_closure_stk(a, c + 0);
		}
		break;
	case 2118: /* INDIRU2 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRU2(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 4;
		}
		/* stk: INDIRU2(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 4;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRU2(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 23;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRU2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 31;
			_closure_stk(a, c + 0);
		}
		break;
	case 2181: /* CVII2 */
		_label(LEFT_CHILD(a));
		/* stk: CVII2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 95;
			_closure_stk(a, c + 0);
		}
		break;
	case 2182: /* CVIU2 */
		_label(LEFT_CHILD(a));
		/* stk: CVIU2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 99;
			_closure_stk(a, c + 0);
		}
		break;
	case 2229: /* CVUI2 */
		_label(LEFT_CHILD(a));
		/* stk: CVUI2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 103;
			_closure_stk(a, c + 0);
		}
		break;
	case 2230: /* CVUU2 */
		_label(LEFT_CHILD(a));
		/* stk: CVUU2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 108;
			_closure_stk(a, c + 0);
		}
		break;
	case 2789: /* TUCKI2 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKI2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 3;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKI2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 3;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKI2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 3;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKI2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 3;
			_closure_tuck4(a, c + 0);
		}
		break;
	case 2790: /* TUCKU2 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKU2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 4;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKU2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 4;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKU2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 4;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKU2(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 4;
			_closure_tuck4(a, c + 0);
		}
		break;
	case 4113: /* CNSTF4 */
		/* cnst: CNSTF4 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 4;
			_closure_cnst(a, 3 + 0);
		}
		break;
	case 4117: /* CNSTI4 */
		/* cnst1: CNSTI4 */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_cnst1_NT]) {
			p->cost[_cnst1_NT] = c + 0;
			p->rule._cnst1 = 5;
		}
		/* cnst2: CNSTI4 */
		c = (range(a, 2, 2));
		if (c + 0 < p->cost[_cnst2_NT]) {
			p->cost[_cnst2_NT] = c + 0;
			p->rule._cnst2 = 5;
			_closure_cnst2(a, c + 0);
		}
		/* cnst4: CNSTI4 */
		c = (range(a, 4, 4));
		if (c + 0 < p->cost[_cnst4_NT]) {
			p->cost[_cnst4_NT] = c + 0;
			p->rule._cnst4 = 5;
			_closure_cnst4(a, c + 0);
		}
		/* cnst32: CNSTI4 */
		c = (range(a, 32, 32));
		if (c + 0 < p->cost[_cnst32_NT]) {
			p->cost[_cnst32_NT] = c + 0;
			p->rule._cnst32 = 1;
		}
		/* con9: CNSTI4 */
		c = (range(a, -(1<<8)+1, (1<<8)-1));
		if (c + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = c + 0;
			p->rule._con9 = 6;
		}
		/* ucon9: CNSTI4 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = c + 0;
			p->rule._ucon9 = 6;
		}
		/* cnst: CNSTI4 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 3;
			_closure_cnst(a, 3 + 0);
		}
		/* stk2: CNSTI4 */
		if (0 + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = 0 + 0;
			p->rule._stk2 = 4;
			_closure_stk2(a, 0 + 0);
		}
		/* zero: CNSTI4 */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 3;
		}
		/* cnst_m1: CNSTI4 */
		c = (range(a, -1, -1));
		if (c + 0 < p->cost[_cnst_m1_NT]) {
			p->cost[_cnst_m1_NT] = c + 0;
			p->rule._cnst_m1 = 1;
		}
		break;
	case 4118: /* CNSTU4 */
		/* cnst1: CNSTU4 */
		c = (range(a, 1, 1));
		if (c + 0 < p->cost[_cnst1_NT]) {
			p->cost[_cnst1_NT] = c + 0;
			p->rule._cnst1 = 6;
		}
		/* cnst2: CNSTU4 */
		c = (range(a, 2, 2));
		if (c + 0 < p->cost[_cnst2_NT]) {
			p->cost[_cnst2_NT] = c + 0;
			p->rule._cnst2 = 6;
			_closure_cnst2(a, c + 0);
		}
		/* cnst4: CNSTU4 */
		c = (range(a, 4, 4));
		if (c + 0 < p->cost[_cnst4_NT]) {
			p->cost[_cnst4_NT] = c + 0;
			p->rule._cnst4 = 6;
			_closure_cnst4(a, c + 0);
		}
		/* con9: CNSTU4 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = c + 0;
			p->rule._con9 = 7;
		}
		/* con9: CNSTU4 */
		c = (range(a, 0xffffff01, 0xffffffff));
		if (c + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = c + 0;
			p->rule._con9 = 8;
		}
		/* ucon9: CNSTU4 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = c + 0;
			p->rule._ucon9 = 7;
		}
		/* cnst: CNSTU4 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 7;
			_closure_cnst(a, 3 + 0);
		}
		/* stk2: CNSTU4 */
		if (0 + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = 0 + 0;
			p->rule._stk2 = 5;
			_closure_stk2(a, 0 + 0);
		}
		/* zero: CNSTU4 */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 6;
		}
		break;
	case 4119: /* CNSTP4 */
		/* con9: CNSTP4 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_con9_NT]) {
			p->cost[_con9_NT] = c + 0;
			p->rule._con9 = 9;
		}
		/* ucon9: CNSTP4 */
		c = (range(a, 0, (1<<8)-1));
		if (c + 0 < p->cost[_ucon9_NT]) {
			p->cost[_ucon9_NT] = c + 0;
			p->rule._ucon9 = 8;
		}
		/* cnst: CNSTP4 */
		if (3 + 0 < p->cost[_cnst_NT]) {
			p->cost[_cnst_NT] = 3 + 0;
			p->rule._cnst = 8;
			_closure_cnst(a, 3 + 0);
		}
		/* zero: CNSTP4 */
		c = (range(a, 0, 0));
		if (c + 0 < p->cost[_zero_NT]) {
			p->cost[_zero_NT] = c + 0;
			p->rule._zero = 7;
		}
		/* addr: CNSTP4 */
		if (0 + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = 0 + 0;
			p->rule._addr = 2;
		}
		break;
	case 4129: /* ARGF4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 128;
		}
		break;
	case 4133: /* ARGI4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 129;
		}
		break;
	case 4134: /* ARGU4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 131;
		}
		break;
	case 4135: /* ARGP4 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 130;
		}
		break;
	case 4145: /* ASGNF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNF4(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 17;
		}
		/* stmt: ASGNF4(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 29;
		}
		/* stmt: ASGNF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 41;
		}
		if (	/* stmt: ASGNF4(stk,INDIRP4(cpyst)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpyst_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 51;
			}
		}
		/* stmt: ASGNF4(stk,tuckst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_tuckst_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 55;
		}
		break;
	case 4149: /* ASGNI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNI4(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 18;
		}
		/* stmt: ASGNI4(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 27;
		}
		/* stmt: ASGNI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 38;
		}
		if (	/* stmt: ASGNI4(stk,INDIRP4(cpyst)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpyst_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 49;
			}
		}
		/* stmt: ASGNI4(stk,tuckst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_tuckst_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 53;
		}
		break;
	case 4150: /* ASGNU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNU4(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 20;
		}
		/* stmt: ASGNU4(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 28;
		}
		/* stmt: ASGNU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 39;
		}
		if (	/* stmt: ASGNU4(stk,INDIRP4(cpyst)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpyst_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 50;
			}
		}
		/* stmt: ASGNU4(stk,tuckst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_tuckst_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 54;
		}
		break;
	case 4151: /* ASGNP4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNP4(stk,var) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_var_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 19;
		}
		/* stmt: ASGNP4(stk,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 30;
		}
		/* stmt: ASGNP4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 40;
		}
		if (	/* stmt: ASGNP4(stk,INDIRP4(cpyst)) */
			RIGHT_CHILD(a)->op == 4167 /* INDIRP4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_cpyst_NT] + 0;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 52;
			}
		}
		/* stmt: ASGNP4(stk,tuckst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_tuckst_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 56;
		}
		break;
	case 4161: /* INDIRF4 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRF4(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 5;
		}
		/* stk: INDIRF4(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 5;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRF4(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 27;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 35;
			_closure_stk(a, c + 0);
		}
		break;
	case 4165: /* INDIRI4 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRI4(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 6;
		}
		/* stk: INDIRI4(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 6;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRI4(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 25;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 32;
			_closure_stk(a, c + 0);
		}
		break;
	case 4166: /* INDIRU4 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRU4(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 8;
		}
		/* stk: INDIRU4(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 8;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRU4(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 26;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 33;
			_closure_stk(a, c + 0);
		}
		break;
	case 4167: /* INDIRP4 */
		_label(LEFT_CHILD(a));
		/* stmt: INDIRP4(drop) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_drop_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 7;
		}
		/* stk: INDIRP4(sread) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 7;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRP4(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 24;
			_closure_stk(a, c + 0);
		}
		/* stk: INDIRP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 34;
			_closure_stk(a, c + 0);
		}
		break;
	case 4209: /* CVFF4 */
		_label(LEFT_CHILD(a));
		/* stk: CVFF4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 6;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 111;
			_closure_stk(a, c + 0);
		}
		break;
	case 4213: /* CVFI4 */
		_label(LEFT_CHILD(a));
		/* stk: CVFI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 20;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 114;
			_closure_stk(a, c + 0);
		}
		/* stk: CVFI4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 20;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 115;
			_closure_stk(a, c + 0);
		}
		break;
	case 4225: /* CVIF4 */
		_label(LEFT_CHILD(a));
		/* stk: CVIF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 112;
			_closure_stk(a, c + 0);
		}
		/* stk: CVIF4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 10;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 113;
			_closure_stk(a, c + 0);
		}
		break;
	case 4229: /* CVII4 */
		_label(LEFT_CHILD(a));
		/* stk: CVII4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 96;
			_closure_stk(a, c + 0);
		}
		/* stk: CVII4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 97;
			_closure_stk(a, c + 0);
		}
		if (	/* stk: CVII4(RSHI8(stk2,cnst32)) */
			LEFT_CHILD(a)->op == 8565 /* RSHI8 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(LEFT_CHILD(a))->x.state))->cost[_cnst32_NT] + 1;
			if (c + 0 < p->cost[_stk_NT]) {
				p->cost[_stk_NT] = c + 0;
				p->rule._stk = 106;
				_closure_stk(a, c + 0);
			}
		}
		break;
	case 4230: /* CVIU4 */
		_label(LEFT_CHILD(a));
		/* stk: CVIU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 100;
			_closure_stk(a, c + 0);
		}
		/* stk: CVIU4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 101;
			_closure_stk(a, c + 0);
		}
		break;
	case 4246: /* CVPU4 */
		_label(LEFT_CHILD(a));
		/* stk: CVPU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 116;
			_closure_stk(a, c + 0);
		}
		break;
	case 4277: /* CVUI4 */
		_label(LEFT_CHILD(a));
		/* stk: CVUI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 104;
			_closure_stk(a, c + 0);
		}
		/* stk: CVUI4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 105;
			_closure_stk(a, c + 0);
		}
		break;
	case 4278: /* CVUU4 */
		_label(LEFT_CHILD(a));
		/* stk: CVUU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 109;
			_closure_stk(a, c + 0);
		}
		/* stk: CVUU4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 110;
			_closure_stk(a, c + 0);
		}
		break;
	case 4279: /* CVUP4 */
		_label(LEFT_CHILD(a));
		/* stk: CVUP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 117;
			_closure_stk(a, c + 0);
		}
		break;
	case 4289: /* NEGF4 */
		_label(LEFT_CHILD(a));
		/* stk: NEGF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 6;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 93;
			_closure_stk(a, c + 0);
		}
		break;
	case 4293: /* NEGI4 */
		_label(LEFT_CHILD(a));
		/* stk2: NEGI4(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 8;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 30;
			_closure_stk2(a, c + 0);
		}
		/* stk: NEGI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 88;
			_closure_stk(a, c + 0);
		}
		break;
	case 4305: /* CALLF4 */
		_label(LEFT_CHILD(a));
		/* stk: CALLF4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 118;
			_closure_stk(a, c + 0);
		}
		/* stk: CALLF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 122;
			_closure_stk(a, c + 0);
		}
		break;
	case 4309: /* CALLI4 */
		_label(LEFT_CHILD(a));
		/* stk: CALLI4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 119;
			_closure_stk(a, c + 0);
		}
		/* stk: CALLI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 123;
			_closure_stk(a, c + 0);
		}
		break;
	case 4310: /* CALLU4 */
		_label(LEFT_CHILD(a));
		/* stk: CALLU4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 121;
			_closure_stk(a, c + 0);
		}
		/* stk: CALLU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 125;
			_closure_stk(a, c + 0);
		}
		break;
	case 4311: /* CALLP4 */
		_label(LEFT_CHILD(a));
		/* stk: CALLP4(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 120;
			_closure_stk(a, c + 0);
		}
		/* stk: CALLP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 124;
			_closure_stk(a, c + 0);
		}
		break;
	case 4337: /* RETF4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 123;
		}
		break;
	case 4341: /* RETI4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 124;
		}
		break;
	case 4342: /* RETU4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 125;
		}
		break;
	case 4343: /* RETP4 */
		_label(LEFT_CHILD(a));
		/* stmt: RETP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 126;
		}
		break;
	case 4359: /* ADDRGP4 */
		/* glob: ADDRGP4 */
		if (0 + 0 < p->cost[_glob_NT]) {
			p->cost[_glob_NT] = 0 + 0;
			p->rule._glob = 1;
			_closure_glob(a, 0 + 0);
		}
		/* addr: ADDRGP4 */
		if (0 + 0 < p->cost[_addr_NT]) {
			p->cost[_addr_NT] = 0 + 0;
			p->rule._addr = 1;
		}
		break;
	case 4375: /* ADDRFP4 */
		/* local: ADDRFP4 */
		if (0 + 0 < p->cost[_local_NT]) {
			p->cost[_local_NT] = 0 + 0;
			p->rule._local = 2;
		}
		/* stk: ADDRFP4 */
		c = (LBURG_MAX);
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 18;
			_closure_stk(a, c + 0);
		}
		break;
	case 4391: /* ADDRLP4 */
		/* local: ADDRLP4 */
		if (0 + 0 < p->cost[_local_NT]) {
			p->cost[_local_NT] = 0 + 0;
			p->rule._local = 1;
		}
		/* stk: ADDRLP4 */
		if (3 + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = 3 + 0;
			p->rule._stk = 19;
			_closure_stk(a, 3 + 0);
		}
		break;
	case 4401: /* ADDF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: ADDF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 15;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 89;
			_closure_stk(a, c + 0);
		}
		break;
	case 4405: /* ADDI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: ADDI4(stk,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 42;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDI4(stk,cnst_m1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst_m1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 45;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDI4(stk,cnst2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst2_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 48;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDI4(stk,con9) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con9_NT] + 2;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 51;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDI4(stk,cnst4) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst4_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 54;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDI4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 57;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 66;
			_closure_stk(a, c + 0);
		}
		break;
	case 4406: /* ADDU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: ADDU4(stk,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 44;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDU4(stk,cnst_m1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst_m1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 47;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDU4(stk,cnst2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst2_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 50;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDU4(stk,con9) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con9_NT] + 2;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 53;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDU4(stk,cnst4) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst4_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 56;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDU4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 59;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 68;
			_closure_stk(a, c + 0);
		}
		break;
	case 4407: /* ADDP4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: ADDP4(stk,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 43;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDP4(stk,cnst_m1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst_m1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 46;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDP4(stk,cnst2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst2_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 49;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDP4(stk,con9) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_con9_NT] + 2;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 52;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDP4(stk,cnst4) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst4_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 55;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDP4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 0;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 58;
			_closure_stk(a, c + 0);
		}
		/* stk: ADDP4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 67;
			_closure_stk(a, c + 0);
		}
		break;
	case 4417: /* SUBF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: SUBF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 15;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 92;
			_closure_stk(a, c + 0);
		}
		break;
	case 4421: /* SUBI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: SUBI4(stk,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 60;
			_closure_stk(a, c + 0);
		}
		/* stk: SUBI4(stk,ucon9) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ucon9_NT] + 2;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 63;
			_closure_stk(a, c + 0);
		}
		/* stk: SUBI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 75;
			_closure_stk(a, c + 0);
		}
		break;
	case 4422: /* SUBU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: SUBU4(stk,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 62;
			_closure_stk(a, c + 0);
		}
		/* stk: SUBU4(stk,ucon9) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ucon9_NT] + 2;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 65;
			_closure_stk(a, c + 0);
		}
		/* stk: SUBU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 77;
			_closure_stk(a, c + 0);
		}
		break;
	case 4423: /* SUBP4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: SUBP4(stk,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 61;
			_closure_stk(a, c + 0);
		}
		/* stk: SUBP4(stk,ucon9) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_ucon9_NT] + 2;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 64;
			_closure_stk(a, c + 0);
		}
		/* stk: SUBP4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 76;
			_closure_stk(a, c + 0);
		}
		break;
	case 4437: /* LSHI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: LSHI4(stk,cnst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 78;
			_closure_stk(a, c + 0);
		}
		/* stk: LSHI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 82;
			_closure_stk(a, c + 0);
		}
		break;
	case 4438: /* LSHU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: LSHU4(stk,cnst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 79;
			_closure_stk(a, c + 0);
		}
		/* stk: LSHU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 83;
			_closure_stk(a, c + 0);
		}
		break;
	case 4453: /* MODI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: MODI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 20;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 36;
			_closure_stk(a, c + 0);
		}
		break;
	case 4454: /* MODU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: MODU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 8;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 37;
			_closure_stk(a, c + 0);
		}
		break;
	case 4469: /* RSHI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: RSHI4(stk,cnst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 80;
			_closure_stk(a, c + 0);
		}
		/* stk: RSHI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 84;
			_closure_stk(a, c + 0);
		}
		break;
	case 4470: /* RSHU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: RSHU4(stk,cnst) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 81;
			_closure_stk(a, c + 0);
		}
		/* stk: RSHU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 85;
			_closure_stk(a, c + 0);
		}
		break;
	case 4485: /* BANDI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: BANDI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 69;
			_closure_stk(a, c + 0);
		}
		break;
	case 4486: /* BANDU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: BANDU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 72;
			_closure_stk(a, c + 0);
		}
		break;
	case 4501: /* BCOMI4 */
		_label(LEFT_CHILD(a));
		/* stk: BCOMI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 86;
			_closure_stk(a, c + 0);
		}
		break;
	case 4502: /* BCOMU4 */
		_label(LEFT_CHILD(a));
		/* stk: BCOMU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 87;
			_closure_stk(a, c + 0);
		}
		break;
	case 4517: /* BORI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: BORI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 70;
			_closure_stk(a, c + 0);
		}
		break;
	case 4518: /* BORU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: BORU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 73;
			_closure_stk(a, c + 0);
		}
		break;
	case 4533: /* BXORI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: BXORI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 71;
			_closure_stk(a, c + 0);
		}
		break;
	case 4534: /* BXORU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: BXORU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 74;
			_closure_stk(a, c + 0);
		}
		break;
	case 4545: /* DIVF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: DIVF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 60;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 90;
			_closure_stk(a, c + 0);
		}
		break;
	case 4549: /* DIVI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: DIVI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 20;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 40;
			_closure_stk(a, c + 0);
		}
		break;
	case 4550: /* DIVU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: DIVU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 8;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 41;
			_closure_stk(a, c + 0);
		}
		break;
	case 4561: /* MULF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: MULF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 30;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 91;
			_closure_stk(a, c + 0);
		}
		break;
	case 4565: /* MULI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: MULI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 38;
			_closure_stk(a, c + 0);
		}
		break;
	case 4566: /* MULU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk: MULU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk_NT]) {
			p->cost[_stk_NT] = c + 0;
			p->rule._stk = 39;
			_closure_stk(a, c + 0);
		}
		break;
	case 4577: /* EQF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 104;
		}
		break;
	case 4581: /* EQI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 60;
		}
		/* stmt: EQI4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 96;
		}
		break;
	case 4582: /* EQU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 61;
		}
		/* stmt: EQU4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 97;
		}
		break;
	case 4593: /* GEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 107;
		}
		break;
	case 4597: /* GEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 64;
		}
		/* stmt: GEI4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 92;
		}
		break;
	case 4598: /* GEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: GEU4(CVPU4(stk),stk) */
			LEFT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 68;
			}
		}
		if (	/* stmt: GEU4(stk,CVPU4(stk)) */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 72;
			}
		}
		if (	/* stmt: GEU4(CVPU4(stk),CVPU4(stk)) */
			LEFT_CHILD(a)->op == 4246 && /* CVPU4 */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 76;
			}
		}
		/* stmt: GEU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 100;
		}
		break;
	case 4609: /* GTF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 108;
		}
		break;
	case 4613: /* GTI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 65;
		}
		/* stmt: GTI4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 93;
		}
		break;
	case 4614: /* GTU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: GTU4(CVPU4(stk),stk) */
			LEFT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 69;
			}
		}
		if (	/* stmt: GTU4(stk,CVPU4(stk)) */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 73;
			}
		}
		if (	/* stmt: GTU4(CVPU4(stk),CVPU4(stk)) */
			LEFT_CHILD(a)->op == 4246 && /* CVPU4 */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 77;
			}
		}
		/* stmt: GTU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 101;
		}
		break;
	case 4625: /* LEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 105;
		}
		break;
	case 4629: /* LEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 66;
		}
		/* stmt: LEI4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 94;
		}
		break;
	case 4630: /* LEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: LEU4(CVPU4(stk),stk) */
			LEFT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 70;
			}
		}
		if (	/* stmt: LEU4(stk,CVPU4(stk)) */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 74;
			}
		}
		if (	/* stmt: LEU4(CVPU4(stk),CVPU4(stk)) */
			LEFT_CHILD(a)->op == 4246 && /* CVPU4 */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 78;
			}
		}
		/* stmt: LEU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 102;
		}
		break;
	case 4641: /* LTF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 106;
		}
		break;
	case 4645: /* LTI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 67;
		}
		/* stmt: LTI4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 95;
		}
		break;
	case 4646: /* LTU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		if (	/* stmt: LTU4(CVPU4(stk),stk) */
			LEFT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 71;
			}
		}
		if (	/* stmt: LTU4(stk,CVPU4(stk)) */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 75;
			}
		}
		if (	/* stmt: LTU4(CVPU4(stk),CVPU4(stk)) */
			LEFT_CHILD(a)->op == 4246 && /* CVPU4 */
			RIGHT_CHILD(a)->op == 4246 /* CVPU4 */
		) {
			c = ((struct _state *)(LEFT_CHILD(LEFT_CHILD(a))->x.state))->cost[_stk_NT] + ((struct _state *)(LEFT_CHILD(RIGHT_CHILD(a))->x.state))->cost[_stk_NT] + 2;
			if (c + 0 < p->cost[_stmt_NT]) {
				p->cost[_stmt_NT] = c + 0;
				p->rule._stmt = 79;
			}
		}
		/* stmt: LTU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 8;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 103;
		}
		break;
	case 4657: /* NEF4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEF4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 109;
		}
		break;
	case 4661: /* NEI4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEI4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 62;
		}
		/* stmt: NEI4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 98;
		}
		break;
	case 4662: /* NEU4 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEU4(stk,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 63;
		}
		/* stmt: NEU4(stk,zero) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_zero_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 99;
		}
		break;
	case 4833: /* TUCKF4 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 7;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 7;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 7;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKF4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 7;
			_closure_tuck4(a, c + 0);
		}
		break;
	case 4837: /* TUCKI4 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 5;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 5;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 5;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKI4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 5;
			_closure_tuck4(a, c + 0);
		}
		break;
	case 4838: /* TUCKU4 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 6;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 6;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 6;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKU4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 6;
			_closure_tuck4(a, c + 0);
		}
		break;
	case 4839: /* TUCKP4 */
		_label(LEFT_CHILD(a));
		/* tuck1: TUCKP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 1, 1));
		if (c + 0 < p->cost[_tuck1_NT]) {
			p->cost[_tuck1_NT] = c + 0;
			p->rule._tuck1 = 8;
			_closure_tuck1(a, c + 0);
		}
		/* tuck2: TUCKP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2));
		if (c + 0 < p->cost[_tuck2_NT]) {
			p->cost[_tuck2_NT] = c + 0;
			p->rule._tuck2 = 8;
			_closure_tuck2(a, c + 0);
		}
		/* tuck3: TUCKP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3));
		if (c + 0 < p->cost[_tuck3_NT]) {
			p->cost[_tuck3_NT] = c + 0;
			p->rule._tuck3 = 8;
			_closure_tuck3(a, c + 0);
		}
		/* tuck4: TUCKP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4));
		if (c + 0 < p->cost[_tuck4_NT]) {
			p->cost[_tuck4_NT] = c + 0;
			p->rule._tuck4 = 8;
			_closure_tuck4(a, c + 0);
		}
		/* tuckst: TUCKP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 2, 2) + 3);
		if (c + 0 < p->cost[_tuckst_NT]) {
			p->cost[_tuckst_NT] = c + 0;
			p->rule._tuckst = 1;
		}
		/* tuckst: TUCKP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 3, 3) + 4);
		if (c + 0 < p->cost[_tuckst_NT]) {
			p->cost[_tuckst_NT] = c + 0;
			p->rule._tuckst = 2;
		}
		/* tuckst: TUCKP4(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + (range(a, 4, 4) + 4);
		if (c + 0 < p->cost[_tuckst_NT]) {
			p->cost[_tuckst_NT] = c + 0;
			p->rule._tuckst = 3;
		}
		break;
	case 8209: /* CNSTF8 */
		break;
	case 8213: /* CNSTI8 */
		break;
	case 8214: /* CNSTU8 */
		break;
	case 8225: /* ARGF8 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGF8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 132;
		}
		break;
	case 8229: /* ARGI8 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGI8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 133;
		}
		break;
	case 8230: /* ARGU8 */
		_label(LEFT_CHILD(a));
		/* stmt: ARGU8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 0;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 134;
		}
		break;
	case 8241: /* ASGNF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNF8(stk2,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 33;
		}
		/* stmt: ASGNF8(stk2,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 44;
		}
		break;
	case 8245: /* ASGNI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNI8(stk2,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 31;
		}
		/* stmt: ASGNI8(stk2,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 42;
		}
		break;
	case 8246: /* ASGNU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: ASGNU8(stk2,local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_local_NT] + 3;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 32;
		}
		/* stmt: ASGNU8(stk2,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 43;
		}
		break;
	case 8257: /* INDIRF8 */
		_label(LEFT_CHILD(a));
		/* stk2: INDIRF8(sread8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread8_NT] + 0;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 2;
			_closure_stk2(a, c + 0);
		}
		/* stk2: INDIRF8(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 5;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 8;
			_closure_stk2(a, c + 0);
		}
		/* stk2: INDIRF8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 7;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 11;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8261: /* INDIRI8 */
		_label(LEFT_CHILD(a));
		/* stk2: INDIRI8(sread8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread8_NT] + 0;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 1;
			_closure_stk2(a, c + 0);
		}
		/* stk2: INDIRI8(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 5;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 6;
			_closure_stk2(a, c + 0);
		}
		/* stk2: INDIRI8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 7;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 9;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8262: /* INDIRU8 */
		_label(LEFT_CHILD(a));
		/* stk2: INDIRU8(sread8) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_sread8_NT] + 0;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 3;
			_closure_stk2(a, c + 0);
		}
		/* stk2: INDIRU8(local) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_local_NT] + 5;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 7;
			_closure_stk2(a, c + 0);
		}
		/* stk2: INDIRU8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 7;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 10;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8305: /* CVFF8 */
		_label(LEFT_CHILD(a));
		/* stk2: CVFF8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 6;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 52;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8309: /* CVFI8 */
		_label(LEFT_CHILD(a));
		/* stk2: CVFI8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 20;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 55;
			_closure_stk2(a, c + 0);
		}
		/* stk2: CVFI8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 20;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 56;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8321: /* CVIF8 */
		_label(LEFT_CHILD(a));
		/* stk2: CVIF8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 53;
			_closure_stk2(a, c + 0);
		}
		/* stk2: CVIF8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 54;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8325: /* CVII8 */
		_label(LEFT_CHILD(a));
		/* stk2: CVII8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 4;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 50;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8326: /* CVIU8 */
		_label(LEFT_CHILD(a));
		/* stk2: CVIU8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 46;
			_closure_stk2(a, c + 0);
		}
		/* stk2: CVIU8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 0;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 47;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8373: /* CVUI8 */
		_label(LEFT_CHILD(a));
		/* stk2: CVUI8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 48;
			_closure_stk2(a, c + 0);
		}
		/* stk2: CVUI8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 0;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 49;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8374: /* CVUU8 */
		_label(LEFT_CHILD(a));
		/* stk2: CVUU8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 1;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 51;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8385: /* NEGF8 */
		_label(LEFT_CHILD(a));
		/* stk2: NEGF8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 6;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 43;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8389: /* NEGI8 */
		break;
	case 8401: /* CALLF8 */
		_label(LEFT_CHILD(a));
		/* stk2: CALLF8(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 57;
			_closure_stk2(a, c + 0);
		}
		/* stk2: CALLF8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 60;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8405: /* CALLI8 */
		_label(LEFT_CHILD(a));
		/* stk2: CALLI8(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 58;
			_closure_stk2(a, c + 0);
		}
		/* stk2: CALLI8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 61;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8406: /* CALLU8 */
		_label(LEFT_CHILD(a));
		/* stk2: CALLU8(addr) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_addr_NT] + 4;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 59;
			_closure_stk2(a, c + 0);
		}
		/* stk2: CALLU8(stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk_NT] + 3;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 62;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8433: /* RETF8 */
		_label(LEFT_CHILD(a));
		/* stmt: RETF8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 120;
		}
		break;
	case 8437: /* RETI8 */
		_label(LEFT_CHILD(a));
		/* stmt: RETI8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 121;
		}
		break;
	case 8438: /* RETU8 */
		_label(LEFT_CHILD(a));
		/* stmt: RETU8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 1;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 122;
		}
		break;
	case 8497: /* ADDF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: ADDF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 15;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 39;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8501: /* ADDI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: ADDI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5   /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 18;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8502: /* ADDU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: ADDU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5      /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 19;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8513: /* SUBF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: SUBF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 15;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 42;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8517: /* SUBI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: SUBI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5      /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 26;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8518: /* SUBU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: SUBU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5     /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 27;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8533: /* LSHI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: LSHI8(stk2,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 6;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 31;
			_closure_stk2(a, c + 0);
		}
		/* stk2: LSHI8(stk2,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 35;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8534: /* LSHU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: LSHU8(stk2,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 6;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 32;
			_closure_stk2(a, c + 0);
		}
		/* stk2: LSHU8(stk2,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 36;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8549: /* MODI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: MODI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 20;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 12;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8550: /* MODU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: MODU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 13;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8565: /* RSHI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: RSHI8(stk2,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 6;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 33;
			_closure_stk2(a, c + 0);
		}
		/* stk2: RSHI8(stk2,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 37;
			_closure_stk2(a, c + 0);
		}
		/* stk2: RSHI8(stk2,cnst32) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst32_NT] + 5;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 44;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8566: /* RSHU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: RSHU8(stk2,cnst1) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst1_NT] + 6;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 34;
			_closure_stk2(a, c + 0);
		}
		/* stk2: RSHU8(stk2,stk) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 38;
			_closure_stk2(a, c + 0);
		}
		/* stk2: RSHU8(stk2,cnst32) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_cnst32_NT] + 3;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 45;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8581: /* BANDI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: BANDI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5      /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 20;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8582: /* BANDU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: BANDU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5     /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 21;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8597: /* BCOMI8 */
		_label(LEFT_CHILD(a));
		/* stk2: BCOMI8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 4;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 28;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8598: /* BCOMU8 */
		_label(LEFT_CHILD(a));
		/* stk2: BCOMU8(stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + 4;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 29;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8613: /* BORI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: BORI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5      /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 22;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8614: /* BORU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: BORU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5     /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 23;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8629: /* BXORI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: BXORI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5      /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 24;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8630: /* BXORU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: BXORU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + (5     /* msw goes tos */);
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 25;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8641: /* DIVF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: DIVF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 60;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 40;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8645: /* DIVI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: DIVI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 20;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 16;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8646: /* DIVU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: DIVU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 20;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 17;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8657: /* MULF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: MULF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 30;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 41;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8661: /* MULI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: MULI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 8;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 14;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8662: /* MULU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stk2: MULU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 10;
		if (c + 0 < p->cost[_stk2_NT]) {
			p->cost[_stk2_NT] = c + 0;
			p->rule._stk2 = 15;
			_closure_stk2(a, c + 0);
		}
		break;
	case 8673: /* EQF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 110;
		}
		break;
	case 8677: /* EQI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 80;
		}
		break;
	case 8678: /* EQU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: EQU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 81;
		}
		break;
	case 8689: /* GEF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 113;
		}
		break;
	case 8693: /* GEI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 84;
		}
		break;
	case 8694: /* GEU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GEU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 88;
		}
		break;
	case 8705: /* GTF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 114;
		}
		break;
	case 8709: /* GTI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 85;
		}
		break;
	case 8710: /* GTU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: GTU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 89;
		}
		break;
	case 8721: /* LEF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 111;
		}
		break;
	case 8725: /* LEI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 86;
		}
		break;
	case 8726: /* LEU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LEU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 90;
		}
		break;
	case 8737: /* LTF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 112;
		}
		break;
	case 8741: /* LTI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 87;
		}
		break;
	case 8742: /* LTU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: LTU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 91;
		}
		break;
	case 8753: /* NEF8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEF8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 2;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 115;
		}
		break;
	case 8757: /* NEI8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEI8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 82;
		}
		break;
	case 8758: /* NEU8 */
		_label(LEFT_CHILD(a));
		_label(RIGHT_CHILD(a));
		/* stmt: NEU8(stk2,stk2) */
		c = ((struct _state *)(LEFT_CHILD(a)->x.state))->cost[_stk2_NT] + ((struct _state *)(RIGHT_CHILD(a)->x.state))->cost[_stk2_NT] + 6;
		if (c + 0 < p->cost[_stmt_NT]) {
			p->cost[_stmt_NT] = c + 0;
			p->rule._stmt = 83;
		}
		break;
	case 8929: /* TUCKF8 */
		break;
	case 8933: /* TUCKI8 */
		break;
	case 8934: /* TUCKU8 */
		break;
	default:
		fatal("_label", "Bad terminal %d\n", OP_LABEL(a));
	}
}

static void _kids(NODEPTR_TYPE p, int eruleno, NODEPTR_TYPE kids[]) {
	if (!p)
		fatal("_kids", "Null tree\n", 0);
	if (!kids)
		fatal("_kids", "Null kids\n", 0);
	switch (eruleno) {
	case 430: /* stmt: RETV */
	case 404: /* addr: CNSTP4 */
	case 403: /* addr: ADDRGP4 */
	case 344: /* stmt: LABELV */
	case 179: /* cpystw: COPYP */
	case 178: /* cpystw: COPYP */
	case 177: /* cpystw: COPYP */
	case 176: /* cpystb: COPYP */
	case 175: /* cpystb: COPYP */
	case 174: /* cpystb: COPYP */
	case 173: /* cpyst: COPYP */
	case 172: /* cpyst: COPYP */
	case 171: /* cpyst: COPYP */
	case 148: /* cnst_m1: CNSTI4 */
	case 147: /* zero: CNSTP4 */
	case 146: /* zero: CNSTU4 */
	case 145: /* zero: CNSTU2 */
	case 144: /* zero: CNSTU1 */
	case 143: /* zero: CNSTI4 */
	case 142: /* zero: CNSTI2 */
	case 141: /* zero: CNSTI1 */
	case 140: /* stk: ADDRLP4 */
	case 139: /* stk: ADDRFP4 */
	case 138: /* stk: NOOP */
	case 136: /* local: ADDRFP4 */
	case 135: /* local: ADDRLP4 */
	case 134: /* glob: ADDRGP4 */
	case 131: /* stk2: CNSTU4 */
	case 130: /* stk2: CNSTI4 */
	case 128: /* cnst: CNSTP4 */
	case 127: /* cnst: CNSTU4 */
	case 126: /* cnst: CNSTU2 */
	case 125: /* cnst: CNSTU1 */
	case 124: /* cnst: CNSTF4 */
	case 123: /* cnst: CNSTI4 */
	case 122: /* cnst: CNSTI2 */
	case 121: /* cnst: CNSTI1 */
	case 118: /* ucon9: CNSTP4 */
	case 117: /* ucon9: CNSTU4 */
	case 116: /* ucon9: CNSTI4 */
	case 115: /* ucon9: CNSTU2 */
	case 114: /* ucon9: CNSTU2 */
	case 113: /* ucon9: CNSTI2 */
	case 112: /* ucon9: CNSTU1 */
	case 111: /* ucon9: CNSTI1 */
	case 110: /* con9: CNSTP4 */
	case 109: /* con9: CNSTU4 */
	case 108: /* con9: CNSTU4 */
	case 107: /* con9: CNSTI4 */
	case 106: /* con9: CNSTU2 */
	case 105: /* con9: CNSTU2 */
	case 104: /* con9: CNSTI2 */
	case 103: /* con9: CNSTU1 */
	case 102: /* con9: CNSTI1 */
	case 101: /* cnst32: CNSTI4 */
	case 100: /* cnst4: CNSTU4 */
	case 99: /* cnst4: CNSTI4 */
	case 98: /* cnst4: CNSTU2 */
	case 97: /* cnst4: CNSTI2 */
	case 96: /* cnst4: CNSTU1 */
	case 95: /* cnst4: CNSTI1 */
	case 94: /* cnst2: CNSTU4 */
	case 93: /* cnst2: CNSTI4 */
	case 92: /* cnst2: CNSTU2 */
	case 91: /* cnst2: CNSTI2 */
	case 90: /* cnst2: CNSTU1 */
	case 89: /* cnst2: CNSTI1 */
	case 88: /* cnst1: CNSTU4 */
	case 87: /* cnst1: CNSTI4 */
	case 86: /* cnst1: CNSTU2 */
	case 85: /* cnst1: CNSTI2 */
	case 84: /* cnst1: CNSTU1 */
	case 83: /* cnst1: CNSTI1 */
	case 82: /* var: STACKP */
	case 81: /* var: STACKP */
	case 80: /* var: STACKP */
	case 79: /* var: STACKP */
	case 11: /* sread: VREGP */
	case 10: /* drop: STACKP */
	case 9: /* sread: COPYP */
	case 8: /* sread: COPYP */
	case 7: /* sread: STACKP */
	case 6: /* sread: STACKP */
	case 5: /* sread: STACKP */
	case 4: /* sread: STACKP */
	case 3: /* sread8: STACKP */
	case 2: /* sread8: STACKP */
	case 1: /* sread8: STACKP */
		break;
	case 437: /* stmt: ARGU8(stk2) */
	case 436: /* stmt: ARGI8(stk2) */
	case 435: /* stmt: ARGF8(stk2) */
	case 434: /* stmt: ARGU4(stk) */
	case 433: /* stmt: ARGP4(stk) */
	case 432: /* stmt: ARGI4(stk) */
	case 431: /* stmt: ARGF4(stk) */
	case 429: /* stmt: RETP4(stk) */
	case 428: /* stmt: RETU4(stk) */
	case 427: /* stmt: RETI4(stk) */
	case 426: /* stmt: RETF4(stk) */
	case 425: /* stmt: RETU8(stk2) */
	case 424: /* stmt: RETI8(stk2) */
	case 423: /* stmt: RETF8(stk2) */
	case 421: /* stmt: CALLV(stk) */
	case 420: /* stk2: CALLU8(stk) */
	case 419: /* stk2: CALLI8(stk) */
	case 418: /* stk2: CALLF8(stk) */
	case 417: /* stk: CALLU4(stk) */
	case 416: /* stk: CALLP4(stk) */
	case 415: /* stk: CALLI4(stk) */
	case 414: /* stk: CALLF4(stk) */
	case 412: /* stmt: CALLV(addr) */
	case 411: /* stk2: CALLU8(addr) */
	case 410: /* stk2: CALLI8(addr) */
	case 409: /* stk2: CALLF8(addr) */
	case 408: /* stk: CALLU4(addr) */
	case 407: /* stk: CALLP4(addr) */
	case 406: /* stk: CALLI4(addr) */
	case 405: /* stk: CALLF4(addr) */
	case 346: /* stmt: JUMPV(stk) */
	case 345: /* stmt: JUMPV(glob) */
	case 343: /* stk: CVUP4(stk) */
	case 342: /* stk: CVPU4(stk) */
	case 341: /* stk2: CVFI8(stk2) */
	case 340: /* stk2: CVFI8(stk) */
	case 339: /* stk2: CVIF8(stk2) */
	case 338: /* stk2: CVIF8(stk) */
	case 337: /* stk2: CVFF8(stk) */
	case 336: /* stk: CVFI4(stk2) */
	case 335: /* stk: CVFI4(stk) */
	case 334: /* stk: CVIF4(stk2) */
	case 333: /* stk: CVIF4(stk) */
	case 332: /* stk: CVFF4(stk2) */
	case 331: /* stk2: CVUU8(stk) */
	case 330: /* stk2: CVII8(stk) */
	case 329: /* stk2: CVUI8(stk2) */
	case 328: /* stk2: CVUI8(stk) */
	case 327: /* stk2: CVIU8(stk2) */
	case 326: /* stk2: CVIU8(stk) */
	case 325: /* stk: CVUU4(stk2) */
	case 324: /* stk: CVUU4(stk) */
	case 323: /* stk: CVUU2(stk) */
	case 322: /* stk: CVUU1(stk) */
	case 318: /* stk: CVUI4(stk2) */
	case 317: /* stk: CVUI4(stk) */
	case 316: /* stk: CVUI2(stk) */
	case 315: /* stk: CVUI1(stk) */
	case 314: /* stk: CVIU4(stk2) */
	case 313: /* stk: CVIU4(stk) */
	case 312: /* stk: CVIU2(stk) */
	case 311: /* stk: CVIU1(stk) */
	case 310: /* stk: CVII4(stk2) */
	case 309: /* stk: CVII4(stk) */
	case 308: /* stk: CVII2(stk) */
	case 307: /* stk: CVII1(stk) */
	case 306: /* stk2: NEGF8(stk2) */
	case 301: /* stk: NEGF4(stk) */
	case 296: /* stk: NEGI4(stk) */
	case 295: /* stk: BCOMU4(stk) */
	case 294: /* stk: BCOMI4(stk) */
	case 277: /* stk2: NEGI4(stk2) */
	case 276: /* stk2: BCOMU8(stk2) */
	case 275: /* stk2: BCOMI8(stk2) */
	case 216: /* stk2: INDIRF8(stk) */
	case 215: /* stk2: INDIRU8(stk) */
	case 214: /* stk2: INDIRI8(stk) */
	case 213: /* stk: INDIRF4(stk) */
	case 212: /* stk: INDIRP4(stk) */
	case 211: /* stk: INDIRU4(stk) */
	case 210: /* stk: INDIRI4(stk) */
	case 209: /* stk: INDIRU2(stk) */
	case 208: /* stk: INDIRI2(stk) */
	case 207: /* stk: INDIRU1(stk) */
	case 206: /* stk: INDIRI1(stk) */
	case 205: /* stk2: INDIRF8(local) */
	case 204: /* stk2: INDIRU8(local) */
	case 203: /* stk2: INDIRI8(local) */
	case 202: /* stk: INDIRF4(local) */
	case 201: /* stk: INDIRU4(local) */
	case 200: /* stk: INDIRI4(local) */
	case 199: /* stk: INDIRP4(local) */
	case 198: /* stk: INDIRU2(local) */
	case 197: /* stk: INDIRI2(local) */
	case 196: /* stk: INDIRU1(local) */
	case 195: /* stk: INDIRI1(local) */
	case 190: /* tuckst: TUCKP4(stk) */
	case 189: /* tuckst: TUCKP4(stk) */
	case 188: /* tuckst: TUCKP4(stk) */
	case 62: /* tuck4: TUCKP4(stk) */
	case 61: /* tuck4: TUCKF4(stk) */
	case 60: /* tuck4: TUCKU4(stk) */
	case 59: /* tuck4: TUCKI4(stk) */
	case 58: /* tuck4: TUCKU2(stk) */
	case 57: /* tuck4: TUCKI2(stk) */
	case 56: /* tuck4: TUCKU1(stk) */
	case 55: /* tuck4: TUCKI1(stk) */
	case 54: /* tuck3: TUCKP4(stk) */
	case 53: /* tuck3: TUCKF4(stk) */
	case 52: /* tuck3: TUCKU4(stk) */
	case 51: /* tuck3: TUCKI4(stk) */
	case 50: /* tuck3: TUCKU2(stk) */
	case 49: /* tuck3: TUCKI2(stk) */
	case 48: /* tuck3: TUCKU1(stk) */
	case 47: /* tuck3: TUCKI1(stk) */
	case 46: /* tuck2: TUCKP4(stk) */
	case 45: /* tuck2: TUCKF4(stk) */
	case 44: /* tuck2: TUCKU4(stk) */
	case 43: /* tuck2: TUCKI4(stk) */
	case 42: /* tuck2: TUCKU2(stk) */
	case 41: /* tuck2: TUCKI2(stk) */
	case 40: /* tuck2: TUCKU1(stk) */
	case 39: /* tuck2: TUCKI1(stk) */
	case 38: /* tuck1: TUCKP4(stk) */
	case 37: /* tuck1: TUCKF4(stk) */
	case 36: /* tuck1: TUCKU4(stk) */
	case 35: /* tuck1: TUCKI4(stk) */
	case 34: /* tuck1: TUCKU2(stk) */
	case 33: /* tuck1: TUCKI2(stk) */
	case 32: /* tuck1: TUCKU1(stk) */
	case 31: /* tuck1: TUCKI1(stk) */
	case 30: /* stk2: INDIRU8(sread8) */
	case 29: /* stk2: INDIRF8(sread8) */
	case 28: /* stk2: INDIRI8(sread8) */
	case 27: /* stk: INDIRU4(sread) */
	case 26: /* stk: INDIRP4(sread) */
	case 25: /* stk: INDIRI4(sread) */
	case 24: /* stk: INDIRF4(sread) */
	case 23: /* stk: INDIRU2(sread) */
	case 22: /* stk: INDIRI2(sread) */
	case 21: /* stk: INDIRU1(sread) */
	case 20: /* stk: INDIRI1(sread) */
	case 19: /* stmt: INDIRU4(drop) */
	case 18: /* stmt: INDIRP4(drop) */
	case 17: /* stmt: INDIRI4(drop) */
	case 16: /* stmt: INDIRF4(drop) */
	case 15: /* stmt: INDIRU2(drop) */
	case 14: /* stmt: INDIRI2(drop) */
	case 13: /* stmt: INDIRU1(drop) */
	case 12: /* stmt: INDIRI1(drop) */
		kids[0] = LEFT_CHILD(p);
		break;
	case 137: /* stk: glob */
	case 133: /* stmt: stk2 */
	case 132: /* stmt: stk */
	case 129: /* stk: cnst */
	case 120: /* stk: cnst4 */
	case 119: /* stk: cnst2 */
	case 70: /* stmt: tuck4 */
	case 69: /* stmt: tuck3 */
	case 68: /* stmt: tuck2 */
	case 67: /* stmt: tuck1 */
	case 66: /* stk: tuck4 */
	case 65: /* stk: tuck3 */
	case 64: /* stk: tuck2 */
	case 63: /* stk: tuck1 */
		kids[0] = p;
		break;
	case 422: /* stmt: CALLB(stk,stk) */
	case 413: /* stmt: CALLB(addr,stk) */
	case 402: /* stmt: NEF8(stk2,stk2) */
	case 401: /* stmt: GTF8(stk2,stk2) */
	case 400: /* stmt: GEF8(stk2,stk2) */
	case 399: /* stmt: LTF8(stk2,stk2) */
	case 398: /* stmt: LEF8(stk2,stk2) */
	case 397: /* stmt: EQF8(stk2,stk2) */
	case 396: /* stmt: NEF4(stk,stk) */
	case 395: /* stmt: GTF4(stk,stk) */
	case 394: /* stmt: GEF4(stk,stk) */
	case 393: /* stmt: LTF4(stk,stk) */
	case 392: /* stmt: LEF4(stk,stk) */
	case 391: /* stmt: EQF4(stk,stk) */
	case 390: /* stmt: LTU4(stk,stk) */
	case 389: /* stmt: LEU4(stk,stk) */
	case 388: /* stmt: GTU4(stk,stk) */
	case 387: /* stmt: GEU4(stk,stk) */
	case 386: /* stmt: NEU4(stk,zero) */
	case 385: /* stmt: NEI4(stk,zero) */
	case 384: /* stmt: EQU4(stk,zero) */
	case 383: /* stmt: EQI4(stk,zero) */
	case 382: /* stmt: LTI4(stk,zero) */
	case 381: /* stmt: LEI4(stk,zero) */
	case 380: /* stmt: GTI4(stk,zero) */
	case 379: /* stmt: GEI4(stk,zero) */
	case 378: /* stmt: LTU8(stk2,stk2) */
	case 377: /* stmt: LEU8(stk2,stk2) */
	case 376: /* stmt: GTU8(stk2,stk2) */
	case 375: /* stmt: GEU8(stk2,stk2) */
	case 374: /* stmt: LTI8(stk2,stk2) */
	case 373: /* stmt: LEI8(stk2,stk2) */
	case 372: /* stmt: GTI8(stk2,stk2) */
	case 371: /* stmt: GEI8(stk2,stk2) */
	case 370: /* stmt: NEU8(stk2,stk2) */
	case 369: /* stmt: NEI8(stk2,stk2) */
	case 368: /* stmt: EQU8(stk2,stk2) */
	case 367: /* stmt: EQI8(stk2,stk2) */
	case 354: /* stmt: LTI4(stk,stk) */
	case 353: /* stmt: LEI4(stk,stk) */
	case 352: /* stmt: GTI4(stk,stk) */
	case 351: /* stmt: GEI4(stk,stk) */
	case 350: /* stmt: NEU4(stk,stk) */
	case 349: /* stmt: NEI4(stk,stk) */
	case 348: /* stmt: EQU4(stk,stk) */
	case 347: /* stmt: EQI4(stk,stk) */
	case 320: /* stk2: RSHU8(stk2,cnst32) */
	case 319: /* stk2: RSHI8(stk2,cnst32) */
	case 305: /* stk2: SUBF8(stk2,stk2) */
	case 304: /* stk2: MULF8(stk2,stk2) */
	case 303: /* stk2: DIVF8(stk2,stk2) */
	case 302: /* stk2: ADDF8(stk2,stk2) */
	case 300: /* stk: SUBF4(stk,stk) */
	case 299: /* stk: MULF4(stk,stk) */
	case 298: /* stk: DIVF4(stk,stk) */
	case 297: /* stk: ADDF4(stk,stk) */
	case 293: /* stk: RSHU4(stk,stk) */
	case 292: /* stk: RSHI4(stk,stk) */
	case 291: /* stk: LSHU4(stk,stk) */
	case 290: /* stk: LSHI4(stk,stk) */
	case 289: /* stk2: RSHU8(stk2,stk) */
	case 288: /* stk2: RSHI8(stk2,stk) */
	case 287: /* stk2: LSHU8(stk2,stk) */
	case 286: /* stk2: LSHI8(stk2,stk) */
	case 285: /* stk: RSHU4(stk,cnst) */
	case 284: /* stk: RSHI4(stk,cnst) */
	case 283: /* stk: LSHU4(stk,cnst) */
	case 282: /* stk: LSHI4(stk,cnst) */
	case 281: /* stk2: RSHU8(stk2,cnst1) */
	case 280: /* stk2: RSHI8(stk2,cnst1) */
	case 279: /* stk2: LSHU8(stk2,cnst1) */
	case 278: /* stk2: LSHI8(stk2,cnst1) */
	case 274: /* stk2: SUBU8(stk2,stk2) */
	case 273: /* stk2: SUBI8(stk2,stk2) */
	case 272: /* stk2: BXORU8(stk2,stk2) */
	case 271: /* stk2: BXORI8(stk2,stk2) */
	case 270: /* stk2: BORU8(stk2,stk2) */
	case 269: /* stk2: BORI8(stk2,stk2) */
	case 268: /* stk2: BANDU8(stk2,stk2) */
	case 267: /* stk2: BANDI8(stk2,stk2) */
	case 266: /* stk: SUBU4(stk,stk) */
	case 265: /* stk: SUBP4(stk,stk) */
	case 264: /* stk: SUBI4(stk,stk) */
	case 263: /* stk: BXORU4(stk,stk) */
	case 262: /* stk: BORU4(stk,stk) */
	case 261: /* stk: BANDU4(stk,stk) */
	case 260: /* stk: BXORI4(stk,stk) */
	case 259: /* stk: BORI4(stk,stk) */
	case 258: /* stk: BANDI4(stk,stk) */
	case 257: /* stk2: ADDU8(stk2,stk2) */
	case 256: /* stk2: ADDI8(stk2,stk2) */
	case 255: /* stk: ADDU4(stk,stk) */
	case 254: /* stk: ADDP4(stk,stk) */
	case 253: /* stk: ADDI4(stk,stk) */
	case 252: /* stk: SUBU4(stk,ucon9) */
	case 251: /* stk: SUBP4(stk,ucon9) */
	case 250: /* stk: SUBI4(stk,ucon9) */
	case 249: /* stk: SUBU4(stk,cnst1) */
	case 248: /* stk: SUBP4(stk,cnst1) */
	case 247: /* stk: SUBI4(stk,cnst1) */
	case 246: /* stk: ADDU4(stk,zero) */
	case 245: /* stk: ADDP4(stk,zero) */
	case 244: /* stk: ADDI4(stk,zero) */
	case 243: /* stk: ADDU4(stk,cnst4) */
	case 242: /* stk: ADDP4(stk,cnst4) */
	case 241: /* stk: ADDI4(stk,cnst4) */
	case 240: /* stk: ADDU4(stk,con9) */
	case 239: /* stk: ADDP4(stk,con9) */
	case 238: /* stk: ADDI4(stk,con9) */
	case 237: /* stk: ADDU4(stk,cnst2) */
	case 236: /* stk: ADDP4(stk,cnst2) */
	case 235: /* stk: ADDI4(stk,cnst2) */
	case 234: /* stk: ADDU4(stk,cnst_m1) */
	case 233: /* stk: ADDP4(stk,cnst_m1) */
	case 232: /* stk: ADDI4(stk,cnst_m1) */
	case 231: /* stk: ADDU4(stk,cnst1) */
	case 230: /* stk: ADDP4(stk,cnst1) */
	case 229: /* stk: ADDI4(stk,cnst1) */
	case 228: /* stk2: DIVU8(stk2,stk2) */
	case 227: /* stk2: DIVI8(stk2,stk2) */
	case 226: /* stk2: MULU8(stk2,stk2) */
	case 225: /* stk2: MULI8(stk2,stk2) */
	case 224: /* stk2: MODU8(stk2,stk2) */
	case 223: /* stk2: MODI8(stk2,stk2) */
	case 222: /* stk: DIVU4(stk,stk) */
	case 221: /* stk: DIVI4(stk,stk) */
	case 220: /* stk: MULU4(stk,stk) */
	case 219: /* stk: MULI4(stk,stk) */
	case 218: /* stk: MODU4(stk,stk) */
	case 217: /* stk: MODI4(stk,stk) */
	case 194: /* stmt: ASGNP4(stk,tuckst) */
	case 193: /* stmt: ASGNF4(stk,tuckst) */
	case 192: /* stmt: ASGNU4(stk,tuckst) */
	case 191: /* stmt: ASGNI4(stk,tuckst) */
	case 170: /* stmt: ASGNF8(stk2,stk) */
	case 169: /* stmt: ASGNU8(stk2,stk) */
	case 168: /* stmt: ASGNI8(stk2,stk) */
	case 167: /* stmt: ASGNF4(stk,stk) */
	case 166: /* stmt: ASGNP4(stk,stk) */
	case 165: /* stmt: ASGNU4(stk,stk) */
	case 164: /* stmt: ASGNI4(stk,stk) */
	case 163: /* stmt: ASGNU2(stk,stk) */
	case 162: /* stmt: ASGNI2(stk,stk) */
	case 161: /* stmt: ASGNU1(stk,stk) */
	case 160: /* stmt: ASGNI1(stk,stk) */
	case 159: /* stmt: ASGNF8(stk2,local) */
	case 158: /* stmt: ASGNU8(stk2,local) */
	case 157: /* stmt: ASGNI8(stk2,local) */
	case 156: /* stmt: ASGNP4(stk,local) */
	case 155: /* stmt: ASGNF4(stk,local) */
	case 154: /* stmt: ASGNU4(stk,local) */
	case 153: /* stmt: ASGNI4(stk,local) */
	case 152: /* stmt: ASGNU2(stk,local) */
	case 151: /* stmt: ASGNI2(stk,local) */
	case 150: /* stmt: ASGNU1(stk,local) */
	case 149: /* stmt: ASGNI1(stk,local) */
	case 78: /* stmt: ASGNU4(stk,var) */
	case 77: /* stmt: ASGNP4(stk,var) */
	case 76: /* stmt: ASGNI4(stk,var) */
	case 75: /* stmt: ASGNF4(stk,var) */
	case 74: /* stmt: ASGNU2(stk,var) */
	case 73: /* stmt: ASGNI2(stk,var) */
	case 72: /* stmt: ASGNU1(stk,var) */
	case 71: /* stmt: ASGNI1(stk,var) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = RIGHT_CHILD(p);
		break;
	case 362: /* stmt: LTU4(stk,CVPU4(stk)) */
	case 361: /* stmt: LEU4(stk,CVPU4(stk)) */
	case 360: /* stmt: GTU4(stk,CVPU4(stk)) */
	case 359: /* stmt: GEU4(stk,CVPU4(stk)) */
	case 187: /* stmt: ASGNP4(stk,INDIRP4(cpyst)) */
	case 186: /* stmt: ASGNF4(stk,INDIRP4(cpyst)) */
	case 185: /* stmt: ASGNU4(stk,INDIRP4(cpyst)) */
	case 184: /* stmt: ASGNI4(stk,INDIRP4(cpyst)) */
	case 183: /* stmt: ASGNI2(stk,INDIRP4(cpystw)) */
	case 182: /* stmt: ASGNU2(stk,INDIRP4(cpystw)) */
	case 181: /* stmt: ASGNI1(stk,INDIRP4(cpystb)) */
	case 180: /* stmt: ASGNU1(stk,INDIRP4(cpystb)) */
		kids[0] = LEFT_CHILD(p);
		kids[1] = LEFT_CHILD(RIGHT_CHILD(p));
		break;
	case 321: /* stk: CVII4(RSHI8(stk2,cnst32)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		kids[1] = RIGHT_CHILD(LEFT_CHILD(p));
		break;
	case 438: /* stmt: ASGNB(INDIRB(stk),stk) */
	case 358: /* stmt: LTU4(CVPU4(stk),stk) */
	case 357: /* stmt: LEU4(CVPU4(stk),stk) */
	case 356: /* stmt: GTU4(CVPU4(stk),stk) */
	case 355: /* stmt: GEU4(CVPU4(stk),stk) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		kids[1] = RIGHT_CHILD(p);
		break;
	case 366: /* stmt: LTU4(CVPU4(stk),CVPU4(stk)) */
	case 365: /* stmt: LEU4(CVPU4(stk),CVPU4(stk)) */
	case 364: /* stmt: GTU4(CVPU4(stk),CVPU4(stk)) */
	case 363: /* stmt: GEU4(CVPU4(stk),CVPU4(stk)) */
		kids[0] = LEFT_CHILD(LEFT_CHILD(p));
		kids[1] = LEFT_CHILD(RIGHT_CHILD(p));
		break;
	default:
		fatal("_kids", "Bad rule number %d\n", eruleno);
	}
}

 
/** When ldt and sdt are sorted, will want to use this

stmt: ASGNI4(stk, ADDP4(stk, con9)) "swap\nstt +%2\ndrop1\n" 4  
stmt: ASGNU4(stk, ADDP4(stk, con9)) "swap\nstt +%2\ndrop1\n" 4
stmt: ASGNP4(stk, ADDP4(stk, con9)) "swap\nstt +%2\ndrop1\n" 4
stmt: ASGNF4(stk, ADDP4(stk, con9)) "swap\nstt +%2\ndrop1\n" 4

stk: INDIRI4(ADDP4(stk, con9)) "swap\nldt +%1\ndrop1\n" 4
stk: INDIRU4(ADDP4(stk,con9)) "swap\nldt +%1\ndrop1\n" 4
stk: INDIRP4(ADDP4(stk, con9)) "swap\nldt +%1\ndrop1\n" 4
stk: INDIRF4(ADDP4(stk, con9)) "swap\nldt +%1\ndrop1\n" 4
*/


static void preamble(Symbol f, Symbol caller[], Symbol callee[], int ncalls);

static void postamble(Symbol f, Symbol caller[], Symbol callee[], int ncalls);

static int makeTemp(Symbol p)
{
  	if (!isscalar(p->type) || p->type->size == 8) {
		p->sclass = AUTO;
		return 0;
	} else if (p->sclass == AUTO) {
		if (p->addressed) {
			return 0;
		} else {
            makeTemporary(p);
			return 1;
		}
	} else if (p->sclass == REGISTER) {
        makeTemporary(p);
		return 1;
	} else {
		return 0;	
	}  
}

static void local(Symbol p) {     
	if (!makeTemp(p)) {
		mkauto(p);  
	} 
}

static char* declare_type(Symbol p) {
    char arg_letter, ret_letter;
	Type rType;
    if (isfunc(p->type)) {
        if (variadic(p->type)) {
            arg_letter = 'V';
        } else {        
            if (p->type->u.f.oldstyle) {
                 arg_letter = 'U';
            } else {
                int arg_size = 0;
                Type* proto = p->type->u.f.proto;
                while (*proto) {
                    if (*proto != voidtype) {
                        arg_size += (*proto)->size > 4 ? 2 : 1;
                    }
                    proto++;
                }
                if (arg_size < 10) {
                    arg_letter = '0' + arg_size;
                } else if (arg_size < 16) {
                    arg_letter = 'A' - 10 + arg_size;
                } else {
                    arg_letter = 'X';
                }
            }
        }
        rType = freturn(p->type);
        if (rType == voidtype) {
            ret_letter = '0';
        } else if (rType->size > 4) {
            ret_letter = '2';
        } else {
            ret_letter = '1';
        }
        print(".type %s F%c%c\n", p->x.name, arg_letter, ret_letter);
    } else {
        int tsize = isscalar(p->type) ? (p->type->size > 4 ? 2 : 1) : 1;
        print(".type %s _%d\n", p->x.name, tsize);
    }
}

static void function(Symbol f, Symbol caller[], Symbol callee[], int ncalls) {
	int i, size, varargs;
	Node params;
    write_log("Function %s\n", f->x.name);
	offset = local_variable_count = 0;
	varargs = variadic(f->type);
	params = stackParameters(caller, callee);
	gencode(caller, callee);
	optimise();
	framesize = roundup(offset, 4);
	preamble(f, caller, callee, ncalls);
	stackemit(params);
	emitcode();
	postamble(f, caller, callee, ncalls);
}

static Node recalcNode(Node temp, Node calc) {
	int op = specific(calc->op);
	if (op == CNST + I || op == CNST + U || op == CNST + P) {
		int lit = calc->syms[0]->u.c.v.i;
		if (lit >= -(1<<10)	&& lit < (1<<10)) {
			return calc;
		} else { 
			return temp;
		}
	} else {
        int gop = generic(calc->op);
        if (gop == CVP) {
               if (generic(calc->kids[0]->op) == INDIR && calc->kids[0]->kids[0]->op == VREG + P)
                   return calc;
        } else if (gop == INDIR && calc->kids[0]->op == VREG + P)
            return calc;
        return temp;
	}
}
 
static int arguments = 0;

static void preamble(Symbol f, Symbol caller[], Symbol callee[], int ncalls)
{
    if (strcmp(f->x.name, "main") == 0) {
       print(".entry main\n");
    }
	print("%s:\n", f->x.name);
	if (variadic(f->type)) {
			print("call _variadic_\n");
	}
	if (framesize) {
        assert(framesize > 0);
        if (framesize < 256) {
            print("addl fp -%d\n", framesize);
        } else {
            print("lit -%d\nldfp\nadd\nstfp\n", framesize);
        }
	}
}

static void postamble(Symbol f, Symbol caller[], Symbol callee[], int ncalls)
{ 
	if (variadic(f->type)) {
		print("trs\nstfp\n");
	} else {
		if (framesize) {
            assert(framesize > 0);
            if (framesize < 256) {
                print("addl fp %d\n", framesize);
            } else {
                print("lit %d\nldfp\nadd\nstfp\n", framesize);
            }
        }
    } 
	print("exit\n\n");
}

static void localAddress(int local) {
	int offset = framesize + local; 
	if (offset) {
		if (offset < 256)
			print("ldfp\naddl tos %d\n", offset);
		else
			print("ldfp\nlit %d\nadd\n", offset);
	} else {
		print("ldfp\n");	
	}
}

static void accessLocal(int store, int size, int local, int sign) {
	char mem;
	int offset = framesize + local; 
	if (size == 4 && offset < 16) {
        print("%sloc%d\n", store ? "st" : "ld", offset/4);
        return;
	}
	if (size == 8) {
		if (store) {
			accessLocal(1, 4, local, 0);
			accessLocal(1, 4, local + 4, 0);
		} else {
			accessLocal(0, 4, local + 4, 0);
			accessLocal(0, 4, local, 0);
		}
		return;
	}
	mem = size < 4 ? (size == 1 ? 'b' : 'w') : 'l' ;
	if (offset/size < 64) {
		print("%s%c fp+%d\n", store ? "st" : "ld", mem, offset);
    } else {
        if (offset < 256)
            print("ldfp\naddl tos %d\n", offset);
        else 
            print("ldfp\nlit %d\nadd\n", offset);
        if (store)
            print("st%c\ndrop1\n", mem);
        else
            print("ld%c\n", mem);
    }
    if (size < 4 && sign && (!store)) {
        if (size == 1)
            print("sxb\n");
        else 
            print("sxw\n");
    }
}

static int fixedParameters(Type ty) {
	int i, count = 0;
	for (i = 0; ty->u.f.proto[i+1]; i++)
		count += ty->u.f.proto[i]->size == 8 ? 2 : 1;
	return count;
}

static void emit2(Node p) {
	int op = generic(p->op);
	if (op == ADDRL) {
		/* Address of local */
		localAddress(p->syms[0]->x.offset);
	} else if (op == INDIR) {
		assert(p->kids[0]->op != VREG + P);
		accessLocal(0, opsize(p->op), p->kids[0]->syms[0]->x.offset, optype(p->op) == I);
	} else if (op == ASGN) {
		if (p->op == ASGN + B) {
            int size = p->syms[0]->u.c.v.i;
            if (size == 4)
                print("\nswap\nldl\nswap\nstl\ndrop1\n");
            else if (size == 8)
                print("swap\nldli\nrrot\nldl\nrrot\nstli\nstl\ndrop1\n");
            else if (size % 4)
                print("lit %d\ncall __copy__\n", size);
            else
			    print("lit %d\ncall __copyw__\n", size >> 2);
		} else {
			accessLocal(1, opsize(p->op), p->kids[1]->syms[0]->x.offset, 
				    optype(p->op) == I);
		}
	} else if (op == CALL) {
		if (variadic(p->syms[0]->type)) {
			print("lit %d\nstxp\n", arguments - fixedParameters(p->syms[0]->type));
		}
		arguments = 0;
		if (generic(p->kids[0]->op) == ADDRG) {
			print("call %s\n", p->kids[0]->syms[0]->x.name);
		} else {
			print("icall\n");
		}
	} else if (op == ARG) {
		if (opsize(p->op) == 8)
			arguments += 2;
		else
			arguments++;
    } else if (op == LSH) {
        int shift = p->kids[1]->syms[0]->u.c.v.i & 31;
        if (shift >= 11) {
             print("elit 0\n");
             shift -= 11;
        }
        if (shift >= 11) {
             print("elit 0\n");
             shift -= 11;
        }
        while (shift) {
            print("shl\n");
            --shift;   
        }
    } else if (op == RSH) {
        int shift = p->kids[1]->syms[0]->u.c.v.i & 31;
        if (specific(p->op) == I) {
            if (shift == 31) {
                print("tlz\ninv\nadd1\n");
            } else if (shift == 24) {
                int i;
                for (i = 0; i < 8; i++)
                    print("rol\n");
                print("sxb\n");
            } else {
                while(shift) {
                    print("asr\n");
                    --shift;
                }
            }
        } else {
            if (shift == 31) {
                print("tlz\n");
            } else if (shift > 18) {
                int mask = (1 << (32 - shift)) - 1;
                while(shift) {
                    print("rol\n");
                    --shift;   
                }
                print("lit %d\nand\n", mask);
            } else {
                while(shift) {
                    print("shr\n");
                    --shift;
                }
            }
        }
	} else {
		assert(0);
	}
}	

static void defconst(int suffix, int size, Value v) {
    if (suffix == F && size == 4) {
        float f = v.d;
        print(".word #%x\n", *(unsigned *)&f);
    } else if (suffix == F && size == 8) {
        double d = v.d; 
        print("", d);
        // Need to refernce d here other wise we get junk in ((unsigned *)&d)[1]
        // Either a bug in GCC or a bug in the hardware...
        print(".word #%x\n", ((unsigned *)&d)[1]);
        print(".word #%x\n", *(unsigned *)&d);
    } else if (suffix == P) {
        print(".word #%x\n", (unsigned)v.p);
    } else if (size == 1) {
        print(".byte #%x\n", (unsigned)((unsigned char)(suffix == I ? v.i : v.u)));
    } else if (size == 2) {
        unsigned int value = (unsigned short)(suffix == I ? v.i : v.u);
        print(".byte #%x\n", (value >> 8));
        print(".byte #%x\n", (value & 0xff));
    } else if (size == 4) {
        print(".word #%x\n", (unsigned)(suffix == I ? v.i : v.u));   
    } else {
        print(".word #%x\n", (unsigned)(suffix == I ? v.i : v.u)); 
        print(".word #%x\n", (unsigned)(suffix == I ? (&(v.i))[1] : (&(v.u))[1])); 
    }
}

static void defaddress(Symbol p) {
       print(".addr %s\n", p->x.name);
       /* print(".addr %s\n", p->x.name);  */
}

static void defstring(int n, char *str) {
        int i;
        for (i = 0; i < n; i++)
             print(".byte %d\n", str[i]);
}

static void export(Symbol p) {
    print(".export %s\n", p->x.name);
    declare_type(p);
}

static void import(Symbol p) {
    declare_type(p);
  //      if (!isfunc(p->type))
    //            print(".extern %s %d\n", p->name, p->type->size);
}

static void defsymbol(Symbol p) {
	if (p->scope == LABELS) {
		p->x.name = stringf("l(%s)", p->name);
	} else if (p->generated) {
		p->x.name = stringf("$%s", p->name);
	} else if (p->scope >= LOCAL && p->sclass == STATIC) {
		p->x.name = stringf("$%d", genlabel(1));
	} else if (p->name[0] == '0' && p->name[1] == 'x') {
		p->x.name = stringf("#%s", p->name + 2);
    } else {
       p->x.name = p->name;  
    }
}

static void address(Symbol q, Symbol p, long n) {
	if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) {
        // Assembler cannot handle arbitary arithmetic, so have to check for offset.
        int i;
        char c;
        for (i = 0; c = p->x.name[i]; i++) {
            if (c == '+' || c == '-') {
                int offset = atoi(p->x.name + i + 1);
                if (c == '+')
                    offset = -offset;
                p->x.name[i] = '\0';
                n += offset;
                q->x.name = stringf("%s%s%D", p->x.name, n >= 0 ? "+" : "", n);
                p->x.name[i] = c;
                return;
            }
        }
        q->x.name = stringf("%s%s%D", p->x.name, n >= 0 ? "+" : "", n);
    }
	else {
		assert(n <= INT_MAX && n >= INT_MIN);
		q->x.offset = p->x.offset + n;
		q->x.name = stringd(q->x.offset);
	}
}

static void global(Symbol p) {
	if (p->type->align != 1) {
		print(".align %d\n", p->type->align);
	}
	print("%s:\n", p->x.name);
}

static void segment(int n) {
        switch (n) {
        case CODE: print(".text\n");  break;
        case LIT:  print(".data\n"); break;
        case DATA: print(".data\n");  break;
        case BSS:  print(".bss\n"); break;
        }
}

static void space(int n) {
	print(".skip %d\n", n);
}


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

static char *currentfile;

/* stabinit - initialize stab output */
static void stabinit(char *file, int argc, char *argv[]) {
        if (file) {
                print(".file \"%s\"\n", file);
                currentfile = file;
        }
}

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

/* stabsym - output a stab entry for symbol p */
static void stabsym(Symbol p) {
//        if (p == cfunc && IR->stabline)
//                (*IR->stabline)(&p->src);
}

 
static void progbeg(int argc, char *argv[]) {
	backendflags(argc, argv);
	print(".text\n");
}

static void blockbeg(Env* env) {
}

static void blockend(Env* env) {
}

static void progend(void){
    if (logfile)
        fclose(logfile);
}

Interface ufoIR = {
        { 1, 1, 0 },  /*  char_metrics */
        { 2, 2, 0 },  /*  short_metrics */
        { 4, 4, 0 },  /*  int_metrics */
        { 4, 4, 0 },  /*  long_metrics */
        { 8, 4, 1 },  /*  long_long_metrics */
        { 4, 4, 1 },  /*  float_metrics */
        { 8, 4, 1 },  /*  double_metrics */
        { 8, 4, 1 },  /*  long_double_metrics */
        { 4, 4, 0 },  /*  word_metrics */
        { 0, 4, 0 },  /*  struct_metrics */
        0,  /* little_endian */
        0,  /* mulops_calls */
        0,  /* wants_callb */
        0,  /* wants_argb */
        1,  /* left_to_right */
        0,  /* wants_dag */
        1,  /* unsigned_char */
        address,
        blockbeg,
        blockend,
        defaddress,
        defconst,
        defstring,
        defsymbol,
        stackemit,
        export,
        function,
        stackgen,
        global,
        import,
        local,
        progbeg,
        progend,
        segment,
        space,
        0, 0, 0, stabinit, stabline, stabsym, 0,
        swtch,
        {
                1,   /* max_unaligned_load */
				3,   /* depth */
				recalcNode,
                makeTemp,
				NULL,
                _label,
                _rule,
                _nts,
                _kids,
                _string,
                _templates,
                _isinstruction,
                _ntname,
                emit2,
                {
                   0, // sub
                   0, // lsh
                   0, // rsh
                   0, // mod
                   0, // div
                   0, // lt
                   0, // le
                   0, // gt
                   0  // ge
				}

        }
};