inferno-os tree was separated from the inferno-os-android (separated from the Android driver)

8 files changed, 3852 insertions, 0 deletions

diff --git a/utils/8a/a.h b/utils/8a/a.h
new file mode 100644
index 0000000..46de8b7
--- /dev/null
+++ b/utils/8a/a.h
@@ -0,0 +1,194 @@
+#include <lib9.h>
+#include <bio.h>
+#include "../8c/8.out.h"
+
+#ifndef	EXTERN
+#define	EXTERN	extern
+#endif
+
+typedef	struct	Sym	Sym;
+typedef	struct	Ref	Ref;
+typedef	struct	Gen	Gen;
+typedef	struct	Io	Io;
+typedef	struct	Hist	Hist;
+typedef	struct	Gen2 	Gen2;
+
+#define	MAXALIGN	7
+#define	FPCHIP		1
+#define	NSYMB		500
+#define	BUFSIZ		8192
+#define	HISTSZ		20
+#define	NINCLUDE	10
+#define	NHUNK		10000
+#define	EOF		(-1)
+#define	IGN		(-2)
+#define	GETC()		((--fi.c < 0)? filbuf(): *fi.p++ & 0xff)
+#define	NHASH		503
+#define	STRINGSZ	200
+#define	NMACRO		10
+
+struct	Sym
+{
+	Sym*	link;
+	Ref*	ref;
+	char*	macro;
+	long	value;
+	ushort	type;
+	char	*name;
+	char	sym;
+};
+#define	S	((Sym*)0)
+
+struct	Ref
+{
+	int	class;
+};
+
+EXTERN struct
+{
+	char*	p;
+	int	c;
+} fi;
+
+struct	Io
+{
+	Io*	link;
+	char	b[BUFSIZ];
+	char*	p;
+	short	c;
+	short	f;
+};
+#define	I	((Io*)0)
+
+EXTERN struct
+{
+	Sym*	sym;
+	short	type;
+} h[NSYM];
+
+struct	Gen
+{
+	double	dval;
+	char	sval[8];
+	long	offset;
+	long	offset2;
+	Sym*	sym;
+	short	type;
+	short	index;
+	short	scale;
+};
+struct	Gen2
+{
+	Gen	from;
+	Gen	to;
+};
+
+struct	Hist
+{
+	Hist*	link;
+	char*	name;
+	long	line;
+	long	offset;
+};
+#define	H	((Hist*)0)
+
+enum
+{
+	CLAST,
+	CMACARG,
+	CMACRO,
+	CPREPROC,
+};
+
+
+EXTERN	char	debug[256];
+EXTERN	Sym*	hash[NHASH];
+EXTERN	char*	Dlist[30];
+EXTERN	int	nDlist;
+EXTERN	Hist*	ehist;
+EXTERN	int	newflag;
+EXTERN	Hist*	hist;
+EXTERN	char*	hunk;
+EXTERN	char*	include[NINCLUDE];
+EXTERN	Io*	iofree;
+EXTERN	Io*	ionext;
+EXTERN	Io*	iostack;
+EXTERN	long	lineno;
+EXTERN	int	nerrors;
+EXTERN	long	nhunk;
+EXTERN	int	ninclude;
+EXTERN	Gen	nullgen;
+EXTERN	char*	outfile;
+EXTERN	int	pass;
+EXTERN	char*	pathname;
+EXTERN	long	pc;
+EXTERN	int	peekc;
+EXTERN	int	sym;
+EXTERN	char	symb[NSYMB];
+EXTERN	int	thechar;
+EXTERN	char*	thestring;
+EXTERN	long	thunk;
+EXTERN	Biobuf	obuf;
+
+void*	allocn(void*, long, long);
+void	errorexit(void);
+void	pushio(void);
+void	newio(void);
+void	newfile(char*, int);
+Sym*	slookup(char*);
+Sym*	lookup(void);
+void	syminit(Sym*);
+long	yylex(void);
+int	getc(void);
+int	getnsc(void);
+void	unget(int);
+int	escchar(int);
+void	cinit(void);
+void	checkscale(int);
+void	pinit(char*);
+void	cclean(void);
+int	isreg(Gen*);
+void	outcode(int, Gen2*);
+void	outhist(void);
+void	zaddr(Gen*, int);
+void	zname(char*, int, int);
+void	ieeedtod(Ieee*, double);
+int	filbuf(void);
+Sym*	getsym(void);
+void	domacro(void);
+void	macund(void);
+void	macdef(void);
+void	macexpand(Sym*, char*);
+void	macinc(void);
+void	macprag(void);
+void	maclin(void);
+void	macif(int);
+void	macend(void);
+void	dodefine(char*);
+void	prfile(long);
+void	linehist(char*, int);
+void	gethunk(void);
+void	yyerror(char*, ...);
+int	yyparse(void);
+void	setinclude(char*);
+int	assemble(char*);
+
+/*
+ *	system-dependent stuff from ../cc/compat.c
+ */
+enum	/* keep in synch with ../cc/cc.h */
+{
+	Plan9	= 1<<0,
+	Unix	= 1<<1,
+	Windows	= 1<<2
+};
+int	mywait(int*);
+int	mycreat(char*, int);
+int	systemtype(int);
+int	pathchar(void);
+char*	mygetwd(char*, int);
+int	myexec(char*, char*[]);
+int	mydup(int, int);
+int	myfork(void);
+int	mypipe(int*);
+void*	mysbrk(ulong);
diff --git a/utils/8a/a.y b/utils/8a/a.y
new file mode 100644
index 0000000..7c9487f
--- /dev/null
+++ b/utils/8a/a.y
@@ -0,0 +1,577 @@
+%{
+#include "a.h"
+%}
+%union	{
+	Sym	*sym;
+	long	lval;
+	struct {
+		long v1;
+		long v2;
+	} con2;
+	double	dval;
+	char	sval[8];
+	Gen	gen;
+	Gen2	gen2;
+}
+%left	'|'
+%left	'^'
+%left	'&'
+%left	'<' '>'
+%left	'+' '-'
+%left	'*' '/' '%'
+%token	<lval>	LTYPE0 LTYPE1 LTYPE2 LTYPE3 LTYPE4
+%token	<lval>	LTYPEC LTYPED LTYPEN LTYPER LTYPET LTYPES LTYPEM LTYPEI LTYPEG
+%token	<lval>	LCONST LFP LPC LSB
+%token	<lval>	LBREG LLREG LSREG LFREG
+%token	<dval>	LFCONST
+%token	<sval>	LSCONST LSP
+%token	<sym>	LNAME LLAB LVAR
+%type	<lval>	con expr pointer offset
+%type	<con2>	con2
+%type	<gen>	mem imm imm2 reg nam rel rem rim rom omem nmem
+%type	<gen2>	nonnon nonrel nonrem rimnon rimrem remrim
+%type	<gen2>	spec1 spec2 spec3 spec4 spec5 spec6 spec7 spec8
+%%
+prog:
+|	prog line
+
+line:
+	LLAB ':'
+	{
+		if($1->value != pc)
+			yyerror("redeclaration of %s", $1->name);
+		$1->value = pc;
+	}
+	line
+|	LNAME ':'
+	{
+		$1->type = LLAB;
+		$1->value = pc;
+	}
+	line
+|	';'
+|	inst ';'
+|	error ';'
+
+inst:
+	LNAME '=' expr
+	{
+		$1->type = LVAR;
+		$1->value = $3;
+	}
+|	LVAR '=' expr
+	{
+		if($1->value != $3)
+			yyerror("redeclaration of %s", $1->name);
+		$1->value = $3;
+	}
+|	LTYPE0 nonnon	{ outcode($1, &$2); }
+|	LTYPE1 nonrem	{ outcode($1, &$2); }
+|	LTYPE2 rimnon	{ outcode($1, &$2); }
+|	LTYPE3 rimrem	{ outcode($1, &$2); }
+|	LTYPE4 remrim	{ outcode($1, &$2); }
+|	LTYPER nonrel	{ outcode($1, &$2); }
+|	LTYPED spec1	{ outcode($1, &$2); }
+|	LTYPET spec2	{ outcode($1, &$2); }
+|	LTYPEC spec3	{ outcode($1, &$2); }
+|	LTYPEN spec4	{ outcode($1, &$2); }
+|	LTYPES spec5	{ outcode($1, &$2); }
+|	LTYPEM spec6	{ outcode($1, &$2); }
+|	LTYPEI spec7	{ outcode($1, &$2); }
+|	LTYPEG spec8	{ outcode($1, &$2); }
+
+nonnon:
+	{
+		$$.from = nullgen;
+		$$.to = nullgen;
+	}
+|	','
+	{
+		$$.from = nullgen;
+		$$.to = nullgen;
+	}
+
+rimrem:
+	rim ',' rem
+	{
+		$$.from = $1;
+		$$.to = $3;
+	}
+
+remrim:
+	rem ',' rim
+	{
+		$$.from = $1;
+		$$.to = $3;
+	}
+
+rimnon:
+	rim ','
+	{
+		$$.from = $1;
+		$$.to = nullgen;
+	}
+|	rim
+	{
+		$$.from = $1;
+		$$.to = nullgen;
+	}
+
+nonrem:
+	',' rem
+	{
+		$$.from = nullgen;
+		$$.to = $2;
+	}
+|	rem
+	{
+		$$.from = nullgen;
+		$$.to = $1;
+	}
+
+nonrel:
+	',' rel
+	{
+		$$.from = nullgen;
+		$$.to = $2;
+	}
+|	rel
+	{
+		$$.from = nullgen;
+		$$.to = $1;
+	}
+
+spec1:	/* DATA */
+	nam '/' con ',' imm
+	{
+		$$.from = $1;
+		$$.from.scale = $3;
+		$$.to = $5;
+	}
+
+spec2:	/* TEXT */
+	mem ',' imm
+	{
+		$$.from = $1;
+		$$.to = $3;
+	}
+|	mem ',' con ',' imm
+	{
+		$$.from = $1;
+		$$.from.scale = $3;
+		$$.to = $5;
+	}
+
+spec3:	/* JMP/CALL */
+	',' rom
+	{
+		$$.from = nullgen;
+		$$.to = $2;
+	}
+|	rom
+	{
+		$$.from = nullgen;
+		$$.to = $1;
+	}
+
+spec4:	/* NOP */
+	nonnon
+|	nonrem
+
+spec5:	/* SHL/SHR */
+	rim ',' rem
+	{
+		$$.from = $1;
+		$$.to = $3;
+	}
+|	rim ',' rem ':' LLREG
+	{
+		$$.from = $1;
+		$$.to = $3;
+		if($$.from.index != D_NONE)
+			yyerror("dp shift with lhs index");
+		$$.from.index = $5;
+	}
+
+spec6:	/* MOVW/MOVL */
+	rim ',' rem
+	{
+		$$.from = $1;
+		$$.to = $3;
+	}
+|	rim ',' rem ':' LSREG
+	{
+		$$.from = $1;
+		$$.to = $3;
+		if($$.to.index != D_NONE)
+			yyerror("dp move with lhs index");
+		$$.to.index = $5;
+	}
+
+spec7:
+	rim ','
+	{
+		$$.from = $1;
+		$$.to = nullgen;
+	}
+|	rim
+	{
+		$$.from = $1;
+		$$.to = nullgen;
+	}
+|	rim ',' rem
+	{
+		$$.from = $1;
+		$$.to = $3;
+	}
+
+spec8:	/* GLOBL */
+	mem ',' imm
+	{
+		$$.from = $1;
+		$$.to = $3;
+	}
+|	mem ',' con ',' imm
+	{
+		$$.from = $1;
+		$$.from.scale = $3;
+		$$.to = $5;
+	}
+
+rem:
+	reg
+|	mem
+
+rom:
+	rel
+|	nmem
+|	'*' reg
+	{
+		$$ = $2;
+	}
+|	'*' omem
+	{
+		$$ = $2;
+	}
+|	reg
+|	omem
+|	imm
+
+rim:
+	rem
+|	imm
+
+rel:
+	con '(' LPC ')'
+	{
+		$$ = nullgen;
+		$$.type = D_BRANCH;
+		$$.offset = $1 + pc;
+	}
+|	LNAME offset
+	{
+		$$ = nullgen;
+		if(pass == 2)
+			yyerror("undefined label: %s", $1->name);
+		$$.type = D_BRANCH;
+		$$.sym = $1;
+		$$.offset = $2;
+	}
+|	LLAB offset
+	{
+		$$ = nullgen;
+		$$.type = D_BRANCH;
+		$$.sym = $1;
+		$$.offset = $1->value + $2;
+	}
+
+reg:
+	LBREG
+	{
+		$$ = nullgen;
+		$$.type = $1;
+	}
+|	LFREG
+	{
+		$$ = nullgen;
+		$$.type = $1;
+	}
+|	LLREG
+	{
+		$$ = nullgen;
+		$$.type = $1;
+	}
+|	LSP
+	{
+		$$ = nullgen;
+		$$.type = D_SP;
+	}
+|	LSREG
+	{
+		$$ = nullgen;
+		$$.type = $1;
+	}
+
+imm:
+	'$' con
+	{
+		$$ = nullgen;
+		$$.type = D_CONST;
+		$$.offset = $2;
+	}
+|	'$' nam
+	{
+		$$ = $2;
+		$$.index = $2.type;
+		$$.type = D_ADDR;
+		/*
+		if($2.type == D_AUTO || $2.type == D_PARAM)
+			yyerror("constant cannot be automatic: %s",
+				$2.sym->name);
+		 */
+	}
+|	'$' LSCONST
+	{
+		$$ = nullgen;
+		$$.type = D_SCONST;
+		memcpy($$.sval, $2, sizeof($$.sval));
+	}
+|	'$' LFCONST
+	{
+		$$ = nullgen;
+		$$.type = D_FCONST;
+		$$.dval = $2;
+	}
+|	'$' '(' LFCONST ')'
+	{
+		$$ = nullgen;
+		$$.type = D_FCONST;
+		$$.dval = $3;
+	}
+|	'$' '-' LFCONST
+	{
+		$$ = nullgen;
+		$$.type = D_FCONST;
+		$$.dval = -$3;
+	}
+
+imm2:
+	'$' con2
+	{
+		$$ = nullgen;
+		$$.type = D_CONST2;
+		$$.offset = $2.v1;
+		$$.offset2 = $2.v2;
+	}
+
+con2:
+	LCONST
+	{
+		$$.v1 = $1;
+		$$.v2 = 0;
+	}
+|	'-' LCONST
+	{
+		$$.v1 = -$2;
+		$$.v2 = 0;
+	}
+|	LCONST '-' LCONST
+	{
+		$$.v1 = $1;
+		$$.v2 = $3;
+	}
+|	'-' LCONST '-' LCONST
+	{
+		$$.v1 = -$2;
+		$$.v2 = $4;
+	}
+
+mem:
+	omem
+|	nmem
+
+omem:
+	con
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+D_NONE;
+		$$.offset = $1;
+	}
+|	con '(' LLREG ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+$3;
+		$$.offset = $1;
+	}
+|	con '(' LSP ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+D_SP;
+		$$.offset = $1;
+	}
+|	con '(' LLREG '*' con ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+D_NONE;
+		$$.offset = $1;
+		$$.index = $3;
+		$$.scale = $5;
+		checkscale($$.scale);
+	}
+|	con '(' LLREG ')' '(' LLREG '*' con ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+$3;
+		$$.offset = $1;
+		$$.index = $6;
+		$$.scale = $8;
+		checkscale($$.scale);
+	}
+|	'(' LLREG ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+$2;
+	}
+|	'(' LSP ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+D_SP;
+	}
+|	con '(' LSREG ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+$3;
+		$$.offset = $1;
+	}
+|	'(' LLREG '*' con ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+D_NONE;
+		$$.index = $2;
+		$$.scale = $4;
+		checkscale($$.scale);
+	}
+|	'(' LLREG ')' '(' LLREG '*' con ')'
+	{
+		$$ = nullgen;
+		$$.type = D_INDIR+$2;
+		$$.index = $5;
+		$$.scale = $7;
+		checkscale($$.scale);
+	}
+
+nmem:
+	nam
+	{
+		$$ = $1;
+	}
+|	nam '(' LLREG '*' con ')'
+	{
+		$$ = $1;
+		$$.index = $3;
+		$$.scale = $5;
+		checkscale($$.scale);
+	}
+
+nam:
+	LNAME offset '(' pointer ')'
+	{
+		$$ = nullgen;
+		$$.type = $4;
+		$$.sym = $1;
+		$$.offset = $2;
+	}
+|	LNAME '<' '>' offset '(' LSB ')'
+	{
+		$$ = nullgen;
+		$$.type = D_STATIC;
+		$$.sym = $1;
+		$$.offset = $4;
+	}
+
+offset:
+	{
+		$$ = 0;
+	}
+|	'+' con
+	{
+		$$ = $2;
+	}
+|	'-' con
+	{
+		$$ = -$2;
+	}
+
+pointer:
+	LSB
+|	LSP
+	{
+		$$ = D_AUTO;
+	}
+|	LFP
+
+con:
+	LCONST
+|	LVAR
+	{
+		$$ = $1->value;
+	}
+|	'-' con
+	{
+		$$ = -$2;
+	}
+|	'+' con
+	{
+		$$ = $2;
+	}
+|	'~' con
+	{
+		$$ = ~$2;
+	}
+|	'(' expr ')'
+	{
+		$$ = $2;
+	}
+
+expr:
+	con
+|	expr '+' expr
+	{
+		$$ = $1 + $3;
+	}
+|	expr '-' expr
+	{
+		$$ = $1 - $3;
+	}
+|	expr '*' expr
+	{
+		$$ = $1 * $3;
+	}
+|	expr '/' expr
+	{
+		$$ = $1 / $3;
+	}
+|	expr '%' expr
+	{
+		$$ = $1 % $3;
+	}
+|	expr '<' '<' expr
+	{
+		$$ = $1 << $4;
+	}
+|	expr '>' '>' expr
+	{
+		$$ = $1 >> $4;
+	}
+|	expr '&' expr
+	{
+		$$ = $1 & $3;
+	}
+|	expr '^' expr
+	{
+		$$ = $1 ^ $3;
+	}
+|	expr '|' expr
+	{
+		$$ = $1 | $3;
+	}
diff --git a/utils/8a/l.s b/utils/8a/l.s
new file mode 100644
index 0000000..4bb92ef
--- /dev/null
+++ b/utils/8a/l.s
@@ -0,0 +1,704 @@
+/*
+ * Memory and machine-specific definitions.  Used in C and assembler.
+ */
+
+/*
+ * Sizes
+ */
+#define	BI2BY		8			/* bits per byte */
+#define BI2WD		32			/* bits per word */
+#define	BY2WD		4			/* bytes per word */
+#define	BY2PG		4096			/* bytes per page */
+#define	WD2PG		(BY2PG/BY2WD)		/* words per page */
+#define	PGSHIFT		12			/* log(BY2PG) */
+#define PGROUND(s)	(((s)+(BY2PG-1))&~(BY2PG-1))
+
+#define	MAXMACH		1			/* max # cpus system can run */
+
+/*
+ * Time
+ */
+#define	HZ		(20)			/* clock frequency */
+#define	MS2HZ		(1000/HZ)		/* millisec per clock tick */
+#define	TK2SEC(t)	((t)/HZ)		/* ticks to seconds */
+#define	TK2MS(t)	((((ulong)(t))*1000)/HZ)	/* ticks to milliseconds */
+#define	MS2TK(t)	((((ulong)(t))*HZ)/1000)	/* milliseconds to ticks */
+
+/*
+ * Fundamental addresses
+ */
+
+/*
+ *  Address spaces
+ *
+ *  User is at 0-2GB
+ *  Kernel is at 2GB-4GB
+ *
+ *  To avoid an extra page map, both the user stack (USTKTOP) and
+ *  the temporary user stack (TSTKTOP) should be in the the same
+ *  4 meg.
+ */
+#define	UZERO		0			/* base of user address space */
+#define	UTZERO		(UZERO+BY2PG)		/* first address in user text */
+#define	KZERO		0x80000000		/* base of kernel address space */
+#define	KTZERO		KZERO			/* first address in kernel text */
+#define	USERADDR	0xC0000000		/* struct User */
+#define	UREGADDR	(USERADDR+BY2PG-4*19)	
+#define	TSTKTOP		USERADDR		/* end of new stack in sysexec */
+#define TSTKSIZ 10
+#define	USTKTOP		(TSTKTOP-TSTKSIZ*BY2PG)	/* byte just beyond user stack */
+#define	USTKSIZE	(16*1024*1024 - TSTKSIZ*BY2PG)	/* size of user stack */
+#define ROMBIOS		(KZERO|0xF0000)
+
+#define	MACHSIZE	4096
+
+#define isphys(x) (((ulong)x)&KZERO)
+
+/*
+ *  known 80386 segments (in GDT) and their selectors
+ */
+#define	NULLSEG	0	/* null segment */
+#define	KDSEG	1	/* kernel data/stack */
+#define	KESEG	2	/* kernel executable */	
+#define	UDSEG	3	/* user data/stack */
+#define	UESEG	4	/* user executable */
+#define TSSSEG	5	/* task segment */
+
+#define SELGDT	(0<<3)	/* selector is in gdt */
+#define	SELLDT	(1<<3)	/* selector is in ldt */
+
+#define SELECTOR(i, t, p)	(((i)<<3) | (t) | (p))
+
+#define NULLSEL	SELECTOR(NULLSEG, SELGDT, 0)
+#define KESEL	SELECTOR(KESEG, SELGDT, 0)
+#define KDSEL	SELECTOR(KDSEG, SELGDT, 0)
+#define UESEL	SELECTOR(UESEG, SELGDT, 3)
+#define UDSEL	SELECTOR(UDSEG, SELGDT, 3)
+#define TSSSEL	SELECTOR(TSSSEG, SELGDT, 0)
+
+/*
+ *  fields in segment descriptors
+ */
+#define SEGDATA	(0x10<<8)	/* data/stack segment */
+#define SEGEXEC	(0x18<<8)	/* executable segment */
+#define	SEGTSS	(0x9<<8)	/* TSS segment */
+#define SEGCG	(0x0C<<8)	/* call gate */
+#define	SEGIG	(0x0E<<8)	/* interrupt gate */
+#define SEGTG	(0x0F<<8)	/* task gate */
+#define SEGTYPE	(0x1F<<8)
+
+#define SEGP	(1<<15)		/* segment present */
+#define SEGPL(x) ((x)<<13)	/* priority level */
+#define SEGB	(1<<22)		/* granularity 1==4k (for expand-down) */
+#define SEGG	(1<<23)		/* granularity 1==4k (for other) */
+#define SEGE	(1<<10)		/* expand down */
+#define SEGW	(1<<9)		/* writable (for data/stack) */
+#define	SEGR	(1<<9)		/* readable (for code) */
+#define SEGD	(1<<22)		/* default 1==32bit (for code) */
+
+/*
+ *  virtual MMU
+ */
+#define PTEMAPMEM	(1024*1024)	/* ??? */	
+#define SEGMAPSIZE	16		/* ??? */
+#define	PTEPERTAB	(PTEMAPMEM/BY2PG)	/* ??? */
+#define PPN(x)		((x)&~(BY2PG-1))
+
+/*
+ *  physical MMU
+ */
+#define	PTEVALID	(1<<0)
+#define	PTEUNCACHED	0		/* everything is uncached */
+#define PTEWRITE	(1<<1)
+#define	PTERONLY	(0<<1)
+#define	PTEKERNEL	(0<<2)
+#define	PTEUSER		(1<<2)
+
+/*
+ *  flag register bits that we care about
+ */
+#define IFLAG	0x200
+
+#define OP16	BYTE	$0x66
+
+/*
+ *	about to walk all over ms/dos - turn off interrupts
+ */
+TEXT	origin(SB),$0
+
+	CLI
+
+#ifdef BOOT
+/*
+ *	This part of l.s is used only in the boot kernel.
+ *	It assumes that we are in real address mode, i.e.,
+ *	that we look like an 8086.
+ */
+/*
+ *	relocate everything to a half meg and jump there
+ *	- looks wierd because it is being assembled by a 32 bit
+ *	  assembler for a 16 bit world
+ */
+	MOVL	$0,BX
+	INCL	BX
+	SHLL	$15,BX
+	MOVL	BX,CX
+	MOVW	BX,ES
+	MOVL	$0,SI
+	MOVL	SI,DI
+	CLD; REP; MOVSL
+/*	JMPFAR	0X8000:$lowcore(SB) /**/
+	 BYTE	$0xEA
+	 WORD	$lowcore(SB)
+	 WORD	$0X8000
+
+TEXT	lowcore(SB),$0
+
+/*
+ *	now that we're in low core, update the DS
+ */
+
+	MOVW	BX,DS
+
+/*
+ * 	goto protected mode
+ */
+/*	MOVL	tgdtptr(SB),GDTR /**/
+	 BYTE	$0x0f
+	 BYTE	$0x01
+	 BYTE	$0x16
+	 WORD	$tgdtptr(SB)
+	MOVL	CR0,AX
+	ORL	$1,AX
+	MOVL	AX,CR0
+
+/*
+ *	clear prefetch queue (wierd code to avoid optimizations)
+ */
+	CLC
+	JCC	flush
+	MOVL	AX,AX
+flush:
+
+/*
+ *	set all segs
+ */
+/*	MOVW	$SELECTOR(1, SELGDT, 0),AX	/**/
+	 BYTE	$0xc7
+	 BYTE	$0xc0
+	 WORD	$SELECTOR(1, SELGDT, 0)
+	MOVW	AX,DS
+	MOVW	AX,SS
+	MOVW	AX,ES
+	MOVW	AX,FS
+	MOVW	AX,GS
+
+/*	JMPFAR	SELECTOR(2, SELGDT, 0):$mode32bit(SB) /**/
+	 BYTE	$0x66
+	 BYTE	$0xEA
+	 LONG	$mode32bit-KZERO(SB)
+	 WORD	$SELECTOR(2, SELGDT, 0)
+
+TEXT	mode32bit(SB),$0
+
+#endif BOOT
+
+	/*
+	 * Clear BSS
+	 */
+	LEAL	edata-KZERO(SB),SI
+	MOVL	SI,DI
+	ADDL	$4,DI
+	MOVL	$0,AX
+	MOVL	AX,(SI)
+	LEAL	end-KZERO(SB),CX
+	SUBL	DI,CX
+	SHRL	$2,CX
+	CLD; REP; MOVSL
+
+	/*
+	 *  make a bottom level page table page that maps the first
+	 *  16 meg of physical memory
+	 */
+	LEAL	tpt-KZERO(SB),AX	/* get phys addr of temporary page table */
+	ADDL	$(BY2PG-1),AX		/* must be page aligned */
+	ANDL	$(~(BY2PG-1)),AX	/* ... */
+	MOVL	$(4*1024),CX		/* pte's per page */
+	MOVL	$((((4*1024)-1)<<PGSHIFT)|PTEVALID|PTEKERNEL|PTEWRITE),BX
+setpte:
+	MOVL	BX,-4(AX)(CX*4)
+	SUBL	$(1<<PGSHIFT),BX
+	LOOP	setpte
+
+	/*
+	 *  make a top level page table page that maps the first
+	 *  16 meg of memory to 0 thru 16meg and to KZERO thru KZERO+16meg
+	 */
+	MOVL	AX,BX
+	ADDL	$(4*BY2PG),AX
+	ADDL	$(PTEVALID|PTEKERNEL|PTEWRITE),BX
+	MOVL	BX,0(AX)
+	MOVL	BX,((((KZERO>>1)&0x7FFFFFFF)>>(2*PGSHIFT-1-4))+0)(AX)
+	ADDL	$BY2PG,BX
+	MOVL	BX,4(AX)
+	MOVL	BX,((((KZERO>>1)&0x7FFFFFFF)>>(2*PGSHIFT-1-4))+4)(AX)
+	ADDL	$BY2PG,BX
+	MOVL	BX,8(AX)
+	MOVL	BX,((((KZERO>>1)&0x7FFFFFFF)>>(2*PGSHIFT-1-4))+8)(AX)
+	ADDL	$BY2PG,BX
+	MOVL	BX,12(AX)
+	MOVL	BX,((((KZERO>>1)&0x7FFFFFFF)>>(2*PGSHIFT-1-4))+12)(AX)
+
+	/*
+	 *  point processor to top level page & turn on paging
+	 */
+	MOVL	AX,CR3
+	MOVL	CR0,AX
+	ORL	$0X80000000,AX
+	ANDL	$~(0x8|0x2),AX	/* TS=0, MP=0 */
+	MOVL	AX,CR0
+
+	/*
+	 *  use a jump to an absolute location to get the PC into
+	 *  KZERO.
+	 */
+	LEAL	tokzero(SB),AX
+	JMP*	AX
+
+TEXT	tokzero(SB),$0
+
+	/*
+	 *  stack and mach
+	 */
+	MOVL	$mach0(SB),SP
+	MOVL	SP,m(SB)
+	MOVL	$0,0(SP)
+	ADDL	$(MACHSIZE-4),SP	/* start stack under machine struct */
+	MOVL	$0, u(SB)
+
+	/*
+	 *  clear flags
+	 */
+	MOVL	$0,AX
+	PUSHL	AX
+	POPFL
+
+	CALL	main(SB)
+
+loop:
+	JMP	loop
+
+GLOBL	mach0+0(SB), $MACHSIZE
+GLOBL	u(SB), $4
+GLOBL	m(SB), $4
+GLOBL	tpt(SB), $(BY2PG*6)
+
+/*
+ *  gdt to get us to 32-bit/segmented/unpaged mode
+ */
+TEXT	tgdt(SB),$0
+
+	/* null descriptor */
+	LONG	$0
+	LONG	$0
+
+	/* data segment descriptor for 4 gigabytes (PL 0) */
+	LONG	$(0xFFFF)
+	LONG	$(SEGG|SEGB|(0xF<<16)|SEGP|SEGPL(0)|SEGDATA|SEGW)
+
+	/* exec segment descriptor for 4 gigabytes (PL 0) */
+	LONG	$(0xFFFF)
+	LONG	$(SEGG|SEGD|(0xF<<16)|SEGP|SEGPL(0)|SEGEXEC|SEGR)
+
+/*
+ *  pointer to initial gdt
+ */
+TEXT	tgdtptr(SB),$0
+
+	WORD	$(3*8)
+	LONG	$tgdt-KZERO(SB)
+
+/*
+ *  input a byte
+ */
+TEXT	inb(SB),$0
+
+	MOVL	p+0(FP),DX
+	XORL	AX,AX
+	INB
+	RET
+
+/*
+ *  output a byte
+ */
+TEXT	outb(SB),$0
+
+	MOVL	p+0(FP),DX
+	MOVL	b+4(FP),AX
+	OUTB
+	RET
+
+/*
+ *  input a string of shorts from a port
+ */
+TEXT	inss(SB),$0
+	MOVL	p+0(FP),DX
+	MOVL	a+4(FP),DI
+	MOVL	c+8(FP),CX
+	CLD; REP; OP16; INSL
+	RET
+
+/*
+ *  output a string of shorts to a port
+ */
+TEXT	outss(SB),$0
+	MOVL	p+0(FP),DX
+	MOVL	a+4(FP),SI
+	MOVL	c+8(FP),CX
+	CLD; REP; OP16; OUTSL
+	RET
+
+/*
+ *  test and set
+ */
+TEXT	tas(SB),$0
+	MOVL	$0xdeadead,AX
+	MOVL	l+0(FP),BX
+	XCHGL	AX,(BX)
+	RET
+
+/*
+ *  routines to load/read various system registers
+ */
+GLOBL	idtptr(SB),$6
+TEXT	putidt(SB),$0		/* interrupt descriptor table */
+	MOVL	t+0(FP),AX
+	MOVL	AX,idtptr+2(SB)
+	MOVL	l+4(FP),AX
+	MOVW	AX,idtptr(SB)
+	MOVL	idtptr(SB),IDTR
+	RET
+
+GLOBL	gdtptr(SB),$6
+TEXT	putgdt(SB),$0		/* global descriptor table */
+	MOVL	t+0(FP),AX
+	MOVL	AX,gdtptr+2(SB)
+	MOVL	l+4(FP),AX
+	MOVW	AX,gdtptr(SB)
+	MOVL	gdtptr(SB),GDTR
+	RET
+
+TEXT	putcr3(SB),$0		/* top level page table pointer */
+	MOVL	t+0(FP),AX
+	MOVL	AX,CR3
+	RET
+
+TEXT	puttr(SB),$0		/* task register */
+	MOVL	t+0(FP),AX
+	MOVW	AX,TASK
+	RET
+
+TEXT	getcr0(SB),$0		/* coprocessor bits */
+	MOVL	CR0,AX
+	RET
+
+TEXT	getcr2(SB),$0		/* fault address */
+	MOVL	CR2,AX
+	RET
+
+#define	FPOFF\
+	WAIT;\
+	MOVL	CR0,AX;\
+	ORL	$0x4,AX		/* EM=1 */;\
+	MOVL	AX,CR0
+
+#define	FPON\
+	MOVL	CR0,AX;\
+	ANDL	$~0x4,AX	/* EM=0 */;\
+	MOVL	AX,CR0
+	
+TEXT	fpoff(SB),$0		/* turn off floating point */
+	FPOFF
+	RET
+
+TEXT	fpinit(SB),$0		/* turn on & init the floating point */
+	FPON
+	FINIT
+	WAIT
+	PUSHW	$0x0330
+	FLDCW	0(SP)		/* ignore underflow/precision, signal others */
+	POPW	AX
+	WAIT
+	RET
+
+TEXT	fpsave(SB),$0		/* save floating point state and turn off */
+	MOVL	p+0(FP),AX
+	WAIT
+	FSAVE	0(AX)
+	FPOFF
+	RET
+
+TEXT	fprestore(SB),$0	/* turn on floating point and restore regs */
+	FPON
+	MOVL	p+0(FP),AX
+	FRSTOR	0(AX)
+	WAIT
+	RET
+
+TEXT	fpstatus(SB),$0		/* get floating point status */
+	FSTSW	AX
+	RET
+
+/*
+ *  special traps
+ */
+TEXT	intr0(SB),$0
+	PUSHL	$0
+	PUSHL	$0
+	JMP	intrcommon
+TEXT	intr1(SB),$0
+	PUSHL	$0
+	PUSHL	$1
+	JMP	intrcommon
+TEXT	intr2(SB),$0
+	PUSHL	$0
+	PUSHL	$2
+	JMP	intrcommon
+TEXT	intr3(SB),$0
+	PUSHL	$0
+	PUSHL	$3
+	JMP	intrcommon
+TEXT	intr4(SB),$0
+	PUSHL	$0
+	PUSHL	$4
+	JMP	intrcommon
+TEXT	intr5(SB),$0
+	PUSHL	$0
+	PUSHL	$5
+	JMP	intrcommon
+TEXT	intr6(SB),$0
+	PUSHL	$0
+	PUSHL	$6
+	JMP	intrcommon
+TEXT	intr7(SB),$0
+	PUSHL	$0
+	PUSHL	$7
+	JMP	intrcommon
+TEXT	intr8(SB),$0
+	PUSHL	$8
+	JMP	intrscommon
+TEXT	intr9(SB),$0
+	PUSHL	$0
+	PUSHL	$9
+	JMP	intrcommon
+TEXT	intr10(SB),$0
+	PUSHL	$10
+	JMP	intrscommon
+TEXT	intr11(SB),$0
+	PUSHL	$11
+	JMP	intrscommon
+TEXT	intr12(SB),$0
+	PUSHL	$12
+	JMP	intrscommon
+TEXT	intr13(SB),$0
+	PUSHL	$13
+	JMP	intrscommon
+TEXT	intr14(SB),$0
+	PUSHL	$14
+	JMP	intrscommon
+TEXT	intr15(SB),$0
+	PUSHL	$0
+	PUSHL	$15
+	JMP	intrcommon
+TEXT	intr16(SB),$0
+	PUSHL	$0
+	PUSHL	$16
+	JMP	intrcommon
+TEXT	intr24(SB),$0
+	PUSHL	$0
+	PUSHL	$24
+	JMP	intrcommon
+TEXT	intr25(SB),$0
+	PUSHL	$0
+	PUSHL	$25
+	JMP	intrcommon
+TEXT	intr26(SB),$0
+	PUSHL	$0
+	PUSHL	$26
+	JMP	intrcommon
+TEXT	intr27(SB),$0
+	PUSHL	$0
+	PUSHL	$27
+	JMP	intrcommon
+TEXT	intr28(SB),$0
+	PUSHL	$0
+	PUSHL	$28
+	JMP	intrcommon
+TEXT	intr29(SB),$0
+	PUSHL	$0
+	PUSHL	$29
+	JMP	intrcommon
+TEXT	intr30(SB),$0
+	PUSHL	$0
+	PUSHL	$30
+	JMP	intrcommon
+TEXT	intr31(SB),$0
+	PUSHL	$0
+	PUSHL	$31
+	JMP	intrcommon
+TEXT	intr32(SB),$0
+	PUSHL	$0
+	PUSHL	$16
+	JMP	intrcommon
+TEXT	intr33(SB),$0
+	PUSHL	$0
+	PUSHL	$33
+	JMP	intrcommon
+TEXT	intr34(SB),$0
+	PUSHL	$0
+	PUSHL	$34
+	JMP	intrcommon
+TEXT	intr35(SB),$0
+	PUSHL	$0
+	PUSHL	$35
+	JMP	intrcommon
+TEXT	intr36(SB),$0
+	PUSHL	$0
+	PUSHL	$36
+	JMP	intrcommon
+TEXT	intr37(SB),$0
+	PUSHL	$0
+	PUSHL	$37
+	JMP	intrcommon
+TEXT	intr38(SB),$0
+	PUSHL	$0
+	PUSHL	$38
+	JMP	intrcommon
+TEXT	intr39(SB),$0
+	PUSHL	$0
+	PUSHL	$39
+	JMP	intrcommon
+TEXT	intr64(SB),$0
+	PUSHL	$0
+	PUSHL	$64
+	JMP	intrcommon
+TEXT	intrbad(SB),$0
+	PUSHL	$0
+	PUSHL	$0x1ff
+	JMP	intrcommon
+
+intrcommon:
+	PUSHL	DS
+	PUSHL	ES
+	PUSHL	FS
+	PUSHL	GS
+	PUSHAL
+	MOVL	$(KDSEL),AX
+	MOVW	AX,DS
+	MOVW	AX,ES
+	LEAL	0(SP),AX
+	PUSHL	AX
+	CALL	trap(SB)
+	POPL	AX
+	POPAL
+	POPL	GS
+	POPL	FS
+	POPL	ES
+	POPL	DS
+	ADDL	$8,SP	/* error code and trap type */
+	IRETL
+
+intrscommon:
+	PUSHL	DS
+	PUSHL	ES
+	PUSHL	FS
+	PUSHL	GS
+	PUSHAL
+	MOVL	$(KDSEL),AX
+	MOVW	AX,DS
+	MOVW	AX,ES
+	LEAL	0(SP),AX
+	PUSHL	AX
+	CALL	trap(SB)
+	POPL	AX
+	POPAL
+	POPL	GS
+	POPL	FS
+	POPL	ES
+	POPL	DS
+	ADDL	$8,SP	/* error code and trap type */
+	IRETL
+
+/*
+ *  interrupt level is interrupts on or off
+ */
+TEXT	spllo(SB),$0
+	PUSHFL
+	POPL	AX
+	STI
+	RET
+
+TEXT	splhi(SB),$0
+	PUSHFL
+	POPL	AX
+	CLI
+	RET
+
+TEXT	splx(SB),$0
+	MOVL	s+0(FP),AX
+	PUSHL	AX
+	POPFL
+	RET
+
+/*
+ *  do nothing whatsoever till interrupt happens
+ */
+TEXT	idle(SB),$0
+	HLT
+	RET
+
+/*
+ *  label consists of a stack pointer and a PC
+ */
+TEXT	gotolabel(SB),$0
+	MOVL	l+0(FP),AX
+	MOVL	0(AX),SP	/* restore sp */
+	MOVL	4(AX),AX	/* put return pc on the stack */
+	MOVL	AX,0(SP)
+	MOVL	$1,AX		/* return 1 */
+	RET
+
+TEXT	setlabel(SB),$0
+	MOVL	l+0(FP),AX
+	MOVL	SP,0(AX)	/* store sp */
+	MOVL	0(SP),BX	/* store return pc */
+	MOVL	BX,4(AX)
+	MOVL	$0,AX		/* return 0 */
+	RET
+
+/*
+ *  Used to get to the first process.
+ *  Set up an interrupt return frame and IRET to user level.
+ */
+TEXT	touser(SB),$0
+	PUSHL	$(UDSEL)		/* old ss */
+	PUSHL	$(USTKTOP)		/* old sp */
+	PUSHFL				/* old flags */
+	PUSHL	$(UESEL)		/* old cs */
+	PUSHL	$(UTZERO+32)		/* old pc */
+	MOVL	$(UDSEL),AX
+	MOVW	AX,DS
+	MOVW	AX,ES
+	MOVW	AX,GS
+	MOVW	AX,FS
+	IRETL
+
+/*
+ *  set configuration register
+ */
+TEXT	config(SB),$0
+	MOVL	l+0(FP),AX
+	MOVL	$0x3F3,DX
+	OUTB
+	OUTB
+	RET
diff --git a/utils/8a/lex.c b/utils/8a/lex.c
new file mode 100644
index 0000000..3c7d085
--- /dev/null
+++ b/utils/8a/lex.c
@@ -0,0 +1,953 @@
+#include <ctype.h>
+#define	EXTERN
+#include "a.h"
+#include "y.tab.h"
+
+void
+main(int argc, char *argv[])
+{
+	char *p;
+	int nout, nproc, status, i, c;
+
+	thechar = '8';
+	thestring = "386";
+	memset(debug, 0, sizeof(debug));
+	cinit();
+	outfile = 0;
+	include[ninclude++] = ".";
+	ARGBEGIN {
+	default:
+		c = ARGC();
+		if(c >= 0 || c < sizeof(debug))
+			debug[c] = 1;
+		break;
+
+	case 'o':
+		outfile = ARGF();
+		break;
+
+	case 'D':
+		p = ARGF();
+		if(p)
+			Dlist[nDlist++] = p;
+		break;
+
+	case 'I':
+		p = ARGF();
+		setinclude(p);
+		break;
+	} ARGEND
+	if(*argv == 0) {
+		print("usage: %ca [-options] file.s\n", thechar);
+		errorexit();
+	}
+	if(argc > 1 && systemtype(Windows)){
+		print("can't assemble multiple files on windows\n");
+		errorexit();
+	}
+	if(argc > 1 && !systemtype(Windows)) {
+		nproc = 1;
+		if(p = getenv("NPROC"))
+			nproc = atol(p);	/* */
+		c = 0;
+		nout = 0;
+		for(;;) {
+			while(nout < nproc && argc > 0) {
+				i = myfork();
+				if(i < 0) {
+					i = mywait(&status);
+					if(i < 0)
+						errorexit();
+					if(status)
+						c++;
+					nout--;
+					continue;
+				}
+				if(i == 0) {
+					print("%s:\n", *argv);
+					if(assemble(*argv))
+						errorexit();
+					exits(0);
+				}
+				nout++;
+				argc--;
+				argv++;
+			}
+			i = mywait(&status);
+			if(i < 0) {
+				if(c)
+					errorexit();
+				exits(0);
+			}
+			if(status)
+				c++;
+			nout--;
+		}
+	}
+	if(assemble(argv[0]))
+		errorexit();
+	exits(0);
+}
+
+int
+assemble(char *file)
+{
+	char ofile[100], incfile[20], *p;
+	int i, of;
+
+	strcpy(ofile, file);
+	p = utfrrune(ofile, pathchar());
+	if(p) {
+		include[0] = ofile;
+		*p++ = 0;
+	} else
+		p = ofile;
+	if(outfile == 0) {
+		outfile = p;
+		if(outfile){
+			p = utfrrune(outfile, '.');
+			if(p)
+				if(p[1] == 's' && p[2] == 0)
+					p[0] = 0;
+			p = utfrune(outfile, 0);
+			p[0] = '.';
+			p[1] = thechar;
+			p[2] = 0;
+		} else
+			outfile = "/dev/null";
+	}
+	p = getenv("INCLUDE");
+	if(p) {
+		setinclude(p);
+	} else {
+		if(systemtype(Plan9)) {
+			sprint(incfile,"/%s/include", thestring);
+			setinclude(strdup(incfile));
+		}
+	}
+
+	of = mycreat(outfile, 0664);
+	if(of < 0) {
+		yyerror("%ca: cannot create %s", thechar, outfile);
+		errorexit();
+	}
+	Binit(&obuf, of, OWRITE);
+
+	pass = 1;
+	pinit(file);
+	for(i=0; i<nDlist; i++)
+		dodefine(Dlist[i]);
+	yyparse();
+	if(nerrors) {
+		cclean();
+		return nerrors;
+	}
+
+	pass = 2;
+	outhist();
+	pinit(file);
+	for(i=0; i<nDlist; i++)
+		dodefine(Dlist[i]);
+	yyparse();
+	cclean();
+	return nerrors;
+}
+
+struct
+{
+	char	*name;
+	ushort	type;
+	ushort	value;
+} itab[] =
+{
+	"SP",		LSP,	D_AUTO,
+	"SB",		LSB,	D_EXTERN,
+	"FP",		LFP,	D_PARAM,
+	"PC",		LPC,	D_BRANCH,
+
+	"AL",		LBREG,	D_AL,
+	"CL",		LBREG,	D_CL,
+	"DL",		LBREG,	D_DL,
+	"BL",		LBREG,	D_BL,
+	"AH",		LBREG,	D_AH,
+	"CH",		LBREG,	D_CH,
+	"DH",		LBREG,	D_DH,
+	"BH",		LBREG,	D_BH,
+
+	"AX",		LLREG,	D_AX,
+	"CX",		LLREG,	D_CX,
+	"DX",		LLREG,	D_DX,
+	"BX",		LLREG,	D_BX,
+/*	"SP",		LLREG,	D_SP,	*/
+	"BP",		LLREG,	D_BP,
+	"SI",		LLREG,	D_SI,
+	"DI",		LLREG,	D_DI,
+
+	"F0",		LFREG,	D_F0+0,
+	"F1",		LFREG,	D_F0+1,
+	"F2",		LFREG,	D_F0+2,
+	"F3",		LFREG,	D_F0+3,
+	"F4",		LFREG,	D_F0+4,
+	"F5",		LFREG,	D_F0+5,
+	"F6",		LFREG,	D_F0+6,
+	"F7",		LFREG,	D_F0+7,
+
+	"CS",		LSREG,	D_CS,
+	"SS",		LSREG,	D_SS,
+	"DS",		LSREG,	D_DS,
+	"ES",		LSREG,	D_ES,
+	"FS",		LSREG,	D_FS,
+	"GS",		LSREG,	D_GS,
+
+	"GDTR",		LBREG,	D_GDTR,
+	"IDTR",		LBREG,	D_IDTR,
+	"LDTR",		LBREG,	D_LDTR,
+	"MSW",		LBREG,	D_MSW,
+	"TASK",		LBREG,	D_TASK,
+
+	"CR0",		LBREG,	D_CR+0,
+	"CR1",		LBREG,	D_CR+1,
+	"CR2",		LBREG,	D_CR+2,
+	"CR3",		LBREG,	D_CR+3,
+	"CR4",		LBREG,	D_CR+4,
+	"CR5",		LBREG,	D_CR+5,
+	"CR6",		LBREG,	D_CR+6,
+	"CR7",		LBREG,	D_CR+7,
+
+	"DR0",		LBREG,	D_DR+0,
+	"DR1",		LBREG,	D_DR+1,
+	"DR2",		LBREG,	D_DR+2,
+	"DR3",		LBREG,	D_DR+3,
+	"DR4",		LBREG,	D_DR+4,
+	"DR5",		LBREG,	D_DR+5,
+	"DR6",		LBREG,	D_DR+6,
+	"DR7",		LBREG,	D_DR+7,
+
+	"TR0",		LBREG,	D_TR+0,
+	"TR1",		LBREG,	D_TR+1,
+	"TR2",		LBREG,	D_TR+2,
+	"TR3",		LBREG,	D_TR+3,
+	"TR4",		LBREG,	D_TR+4,
+	"TR5",		LBREG,	D_TR+5,
+	"TR6",		LBREG,	D_TR+6,
+	"TR7",		LBREG,	D_TR+7,
+
+	"AAA",		LTYPE0,	AAAA,
+	"AAD",		LTYPE0,	AAAD,
+	"AAM",		LTYPE0,	AAAM,
+	"AAS",		LTYPE0,	AAAS,
+	"ADCB",		LTYPE3,	AADCB,
+	"ADCL",		LTYPE3,	AADCL,
+	"ADCW",		LTYPE3,	AADCW,
+	"ADDB",		LTYPE3,	AADDB,
+	"ADDL",		LTYPE3,	AADDL,
+	"ADDW",		LTYPE3,	AADDW,
+	"ADJSP",	LTYPE2,	AADJSP,
+	"ANDB",		LTYPE3,	AANDB,
+	"ANDL",		LTYPE3,	AANDL,
+	"ANDW",		LTYPE3,	AANDW,
+	"ARPL",		LTYPE3,	AARPL,
+	"BOUNDL",	LTYPE3,	ABOUNDL,
+	"BOUNDW",	LTYPE3,	ABOUNDW,
+	"BSFL",		LTYPE3,	ABSFL,
+	"BSFW",		LTYPE3,	ABSFW,
+	"BSRL",		LTYPE3,	ABSRL,
+	"BSRW",		LTYPE3,	ABSRW,
+	"BTCL",		LTYPE3,	ABTCL,
+	"BTCW",		LTYPE3,	ABTCW,
+	"BTL",		LTYPE3,	ABTL,
+	"BTRL",		LTYPE3,	ABTRL,
+	"BTRW",		LTYPE3,	ABTRW,
+	"BTSL",		LTYPE3,	ABTSL,
+	"BTSW",		LTYPE3,	ABTSW,
+	"BTW",		LTYPE3,	ABTW,
+	"BYTE",		LTYPE2,	ABYTE,
+	"CALL",		LTYPEC,	ACALL,
+	"CLC",		LTYPE0,	ACLC,
+	"CLD",		LTYPE0,	ACLD,
+	"CLI",		LTYPE0,	ACLI,
+	"CLTS",		LTYPE0,	ACLTS,
+	"CMC",		LTYPE0,	ACMC,
+	"CMPB",		LTYPE4,	ACMPB,
+	"CMPL",		LTYPE4,	ACMPL,
+	"CMPW",		LTYPE4,	ACMPW,
+	"CMPSB",	LTYPE0,	ACMPSB,
+	"CMPSL",	LTYPE0,	ACMPSL,
+	"CMPSW",	LTYPE0,	ACMPSW,
+	"CMPXCHGB",	LTYPE3,	ACMPXCHGB,
+	"CMPXCHGL",	LTYPE3,	ACMPXCHGL,
+	"CMPXCHGW",	LTYPE3,	ACMPXCHGW,
+	"DAA",		LTYPE0,	ADAA,
+	"DAS",		LTYPE0,	ADAS,
+	"DATA",		LTYPED,	ADATA,
+	"DECB",		LTYPE1,	ADECB,
+	"DECL",		LTYPE1,	ADECL,
+	"DECW",		LTYPE1,	ADECW,
+	"DIVB",		LTYPE2,	ADIVB,
+	"DIVL",		LTYPE2,	ADIVL,
+	"DIVW",		LTYPE2,	ADIVW,
+	"END",		LTYPE0,	AEND,
+	"ENTER",	LTYPE2,	AENTER,
+	"GLOBL",	LTYPEG,	AGLOBL,
+	"HLT",		LTYPE0,	AHLT,
+	"IDIVB",	LTYPE2,	AIDIVB,
+	"IDIVL",	LTYPE2,	AIDIVL,
+	"IDIVW",	LTYPE2,	AIDIVW,
+	"IMULB",	LTYPEI,	AIMULB,
+	"IMULL",	LTYPEI,	AIMULL,
+	"IMULW",	LTYPEI,	AIMULW,
+	"INB",		LTYPE0,	AINB,
+	"INL",		LTYPE0,	AINL,
+	"INW",		LTYPE0,	AINW,
+	"INCB",		LTYPE1,	AINCB,
+	"INCL",		LTYPE1,	AINCL,
+	"INCW",		LTYPE1,	AINCW,
+	"INSB",		LTYPE0,	AINSB,
+	"INSL",		LTYPE0,	AINSL,
+	"INSW",		LTYPE0,	AINSW,
+	"INT",		LTYPE2,	AINT,
+	"INTO",		LTYPE0,	AINTO,
+	"IRETL",	LTYPE0,	AIRETL,
+	"IRETW",	LTYPE0,	AIRETW,
+
+	"JOS",		LTYPER,	AJOS,
+	"JO",		LTYPER,	AJOS,	/* alternate */
+	"JOC",		LTYPER,	AJOC,
+	"JNO",		LTYPER,	AJOC,	/* alternate */
+	"JCS",		LTYPER,	AJCS,
+	"JB",		LTYPER,	AJCS,	/* alternate */
+	"JC",		LTYPER,	AJCS,	/* alternate */
+	"JNAE",		LTYPER,	AJCS,	/* alternate */
+	"JLO",		LTYPER,	AJCS,	/* alternate */
+	"JCC",		LTYPER,	AJCC,
+	"JAE",		LTYPER,	AJCC,	/* alternate */
+	"JNB",		LTYPER,	AJCC,	/* alternate */
+	"JNC",		LTYPER,	AJCC,	/* alternate */
+	"JHS",		LTYPER,	AJCC,	/* alternate */
+	"JEQ",		LTYPER,	AJEQ,
+	"JE",		LTYPER,	AJEQ,	/* alternate */
+	"JZ",		LTYPER,	AJEQ,	/* alternate */
+	"JNE",		LTYPER,	AJNE,
+	"JNZ",		LTYPER,	AJNE,	/* alternate */
+	"JLS",		LTYPER,	AJLS,
+	"JBE",		LTYPER,	AJLS,	/* alternate */
+	"JNA",		LTYPER,	AJLS,	/* alternate */
+	"JHI",		LTYPER,	AJHI,
+	"JA",		LTYPER,	AJHI,	/* alternate */
+	"JNBE",		LTYPER,	AJHI,	/* alternate */
+	"JMI",		LTYPER,	AJMI,
+	"JS",		LTYPER,	AJMI,	/* alternate */
+	"JPL",		LTYPER,	AJPL,
+	"JNS",		LTYPER,	AJPL,	/* alternate */
+	"JPS",		LTYPER,	AJPS,
+	"JP",		LTYPER,	AJPS,	/* alternate */
+	"JPE",		LTYPER,	AJPS,	/* alternate */
+	"JPC",		LTYPER,	AJPC,
+	"JNP",		LTYPER,	AJPC,	/* alternate */
+	"JPO",		LTYPER,	AJPC,	/* alternate */
+	"JLT",		LTYPER,	AJLT,
+	"JL",		LTYPER,	AJLT,	/* alternate */
+	"JNGE",		LTYPER,	AJLT,	/* alternate */
+	"JGE",		LTYPER,	AJGE,
+	"JNL",		LTYPER,	AJGE,	/* alternate */
+	"JLE",		LTYPER,	AJLE,
+	"JNG",		LTYPER,	AJLE,	/* alternate */
+	"JGT",		LTYPER,	AJGT,
+	"JG",		LTYPER,	AJGT,	/* alternate */
+	"JNLE",		LTYPER,	AJGT,	/* alternate */
+
+	"JCXZ",		LTYPER,	AJCXZ,
+	"JMP",		LTYPEC,	AJMP,
+	"LAHF",		LTYPE0,	ALAHF,
+	"LARL",		LTYPE3,	ALARL,
+	"LARW",		LTYPE3,	ALARW,
+	"LEAL",		LTYPE3,	ALEAL,
+	"LEAW",		LTYPE3,	ALEAW,
+	"LEAVEL",	LTYPE0,	ALEAVEL,
+	"LEAVEW",	LTYPE0,	ALEAVEW,
+	"LOCK",		LTYPE0,	ALOCK,
+	"LODSB",	LTYPE0,	ALODSB,
+	"LODSL",	LTYPE0,	ALODSL,
+	"LODSW",	LTYPE0,	ALODSW,
+	"LONG",		LTYPE2,	ALONG,
+	"LOOP",		LTYPER,	ALOOP,
+	"LOOPEQ",	LTYPER,	ALOOPEQ,
+	"LOOPNE",	LTYPER,	ALOOPNE,
+	"LSLL",		LTYPE3,	ALSLL,
+	"LSLW",		LTYPE3,	ALSLW,
+	"MOVB",		LTYPE3,	AMOVB,
+	"MOVL",		LTYPEM,	AMOVL,
+	"MOVW",		LTYPEM,	AMOVW,
+	"MOVBLSX",	LTYPE3, AMOVBLSX,
+	"MOVBLZX",	LTYPE3, AMOVBLZX,
+	"MOVBWSX",	LTYPE3, AMOVBWSX,
+	"MOVBWZX",	LTYPE3, AMOVBWZX,
+	"MOVWLSX",	LTYPE3, AMOVWLSX,
+	"MOVWLZX",	LTYPE3, AMOVWLZX,
+	"MOVSB",	LTYPE0,	AMOVSB,
+	"MOVSL",	LTYPE0,	AMOVSL,
+	"MOVSW",	LTYPE0,	AMOVSW,
+	"MULB",		LTYPE2,	AMULB,
+	"MULL",		LTYPE2,	AMULL,
+	"MULW",		LTYPE2,	AMULW,
+	"NEGB",		LTYPE1,	ANEGB,
+	"NEGL",		LTYPE1,	ANEGL,
+	"NEGW",		LTYPE1,	ANEGW,
+	"NOP",		LTYPEN,	ANOP,
+	"NOTB",		LTYPE1,	ANOTB,
+	"NOTL",		LTYPE1,	ANOTL,
+	"NOTW",		LTYPE1,	ANOTW,
+	"ORB",		LTYPE3,	AORB,
+	"ORL",		LTYPE3,	AORL,
+	"ORW",		LTYPE3,	AORW,
+	"OUTB",		LTYPE0,	AOUTB,
+	"OUTL",		LTYPE0,	AOUTL,
+	"OUTW",		LTYPE0,	AOUTW,
+	"OUTSB",	LTYPE0,	AOUTSB,
+	"OUTSL",	LTYPE0,	AOUTSL,
+	"OUTSW",	LTYPE0,	AOUTSW,
+	"POPAL",	LTYPE0,	APOPAL,
+	"POPAW",	LTYPE0,	APOPAW,
+	"POPFL",	LTYPE0,	APOPFL,
+	"POPFW",	LTYPE0,	APOPFW,
+	"POPL",		LTYPE1,	APOPL,
+	"POPW",		LTYPE1,	APOPW,
+	"PUSHAL",	LTYPE0,	APUSHAL,
+	"PUSHAW",	LTYPE0,	APUSHAW,
+	"PUSHFL",	LTYPE0,	APUSHFL,
+	"PUSHFW",	LTYPE0,	APUSHFW,
+	"PUSHL",	LTYPE2,	APUSHL,
+	"PUSHW",	LTYPE2,	APUSHW,
+	"RCLB",		LTYPE3,	ARCLB,
+	"RCLL",		LTYPE3,	ARCLL,
+	"RCLW",		LTYPE3,	ARCLW,
+	"RCRB",		LTYPE3,	ARCRB,
+	"RCRL",		LTYPE3,	ARCRL,
+	"RCRW",		LTYPE3,	ARCRW,
+	"REP",		LTYPE0,	AREP,
+	"REPN",		LTYPE0,	AREPN,
+	"RET",		LTYPE0,	ARET,
+	"ROLB",		LTYPE3,	AROLB,
+	"ROLL",		LTYPE3,	AROLL,
+	"ROLW",		LTYPE3,	AROLW,
+	"RORB",		LTYPE3,	ARORB,
+	"RORL",		LTYPE3,	ARORL,
+	"RORW",		LTYPE3,	ARORW,
+	"SAHF",		LTYPE0,	ASAHF,
+	"SALB",		LTYPE3,	ASALB,
+	"SALL",		LTYPE3,	ASALL,
+	"SALW",		LTYPE3,	ASALW,
+	"SARB",		LTYPE3,	ASARB,
+	"SARL",		LTYPE3,	ASARL,
+	"SARW",		LTYPE3,	ASARW,
+	"SBBB",		LTYPE3,	ASBBB,
+	"SBBL",		LTYPE3,	ASBBL,
+	"SBBW",		LTYPE3,	ASBBW,
+	"SCASB",	LTYPE0,	ASCASB,
+	"SCASL",	LTYPE0,	ASCASL,
+	"SCASW",	LTYPE0,	ASCASW,
+	"SETCC",	LTYPE1,	ASETCC,
+	"SETCS",	LTYPE1,	ASETCS,
+	"SETEQ",	LTYPE1,	ASETEQ,
+	"SETGE",	LTYPE1,	ASETGE,
+	"SETGT",	LTYPE1,	ASETGT,
+	"SETHI",	LTYPE1,	ASETHI,
+	"SETLE",	LTYPE1,	ASETLE,
+	"SETLS",	LTYPE1,	ASETLS,
+	"SETLT",	LTYPE1,	ASETLT,
+	"SETMI",	LTYPE1,	ASETMI,
+	"SETNE",	LTYPE1,	ASETNE,
+	"SETOC",	LTYPE1,	ASETOC,
+	"SETOS",	LTYPE1,	ASETOS,
+	"SETPC",	LTYPE1,	ASETPC,
+	"SETPL",	LTYPE1,	ASETPL,
+	"SETPS",	LTYPE1,	ASETPS,
+	"CDQ",		LTYPE0,	ACDQ,
+	"CWD",		LTYPE0,	ACWD,
+	"SHLB",		LTYPE3,	ASHLB,
+	"SHLL",		LTYPES,	ASHLL,
+	"SHLW",		LTYPES,	ASHLW,
+	"SHRB",		LTYPE3,	ASHRB,
+	"SHRL",		LTYPES,	ASHRL,
+	"SHRW",		LTYPES,	ASHRW,
+	"STC",		LTYPE0,	ASTC,
+	"STD",		LTYPE0,	ASTD,
+	"STI",		LTYPE0,	ASTI,
+	"STOSB",	LTYPE0,	ASTOSB,
+	"STOSL",	LTYPE0,	ASTOSL,
+	"STOSW",	LTYPE0,	ASTOSW,
+	"SUBB",		LTYPE3,	ASUBB,
+	"SUBL",		LTYPE3,	ASUBL,
+	"SUBW",		LTYPE3,	ASUBW,
+	"SYSCALL",	LTYPE0,	ASYSCALL,
+	"TESTB",	LTYPE3,	ATESTB,
+	"TESTL",	LTYPE3,	ATESTL,
+	"TESTW",	LTYPE3,	ATESTW,
+	"TEXT",		LTYPET,	ATEXT,
+	"VERR",		LTYPE2,	AVERR,
+	"VERW",		LTYPE2,	AVERW,
+	"WAIT",		LTYPE0,	AWAIT,
+	"WORD",		LTYPE2,	AWORD,
+	"XCHGB",	LTYPE3,	AXCHGB,
+	"XCHGL",	LTYPE3,	AXCHGL,
+	"XCHGW",	LTYPE3,	AXCHGW,
+	"XLAT",		LTYPE2,	AXLAT,
+	"XORB",		LTYPE3,	AXORB,
+	"XORL",		LTYPE3,	AXORL,
+	"XORW",		LTYPE3,	AXORW,
+
+	"CMOVLCC",	LTYPE3,	ACMOVLCC,
+	"CMOVLCS",	LTYPE3,	ACMOVLCS,
+	"CMOVLEQ",	LTYPE3,	ACMOVLEQ,
+	"CMOVLGE",	LTYPE3,	ACMOVLGE,
+	"CMOVLGT",	LTYPE3,	ACMOVLGT,
+	"CMOVLHI",	LTYPE3,	ACMOVLHI,
+	"CMOVLLE",	LTYPE3,	ACMOVLLE,
+	"CMOVLLS",	LTYPE3,	ACMOVLLS,
+	"CMOVLLT",	LTYPE3,	ACMOVLLT,
+	"CMOVLMI",	LTYPE3,	ACMOVLMI,
+	"CMOVLNE",	LTYPE3,	ACMOVLNE,
+	"CMOVLOC",	LTYPE3,	ACMOVLOC,
+	"CMOVLOS",	LTYPE3,	ACMOVLOS,
+	"CMOVLPC",	LTYPE3,	ACMOVLPC,
+	"CMOVLPL",	LTYPE3,	ACMOVLPL,
+	"CMOVLPS",	LTYPE3,	ACMOVLPS,
+	"CMOVWCC",	LTYPE3,	ACMOVWCC,
+	"CMOVWCS",	LTYPE3,	ACMOVWCS,
+	"CMOVWEQ",	LTYPE3,	ACMOVWEQ,
+	"CMOVWGE",	LTYPE3,	ACMOVWGE,
+	"CMOVWGT",	LTYPE3,	ACMOVWGT,
+	"CMOVWHI",	LTYPE3,	ACMOVWHI,
+	"CMOVWLE",	LTYPE3,	ACMOVWLE,
+	"CMOVWLS",	LTYPE3,	ACMOVWLS,
+	"CMOVWLT",	LTYPE3,	ACMOVWLT,
+	"CMOVWMI",	LTYPE3,	ACMOVWMI,
+	"CMOVWNE",	LTYPE3,	ACMOVWNE,
+	"CMOVWOC",	LTYPE3,	ACMOVWOC,
+	"CMOVWOS",	LTYPE3,	ACMOVWOS,
+	"CMOVWPC",	LTYPE3,	ACMOVWPC,
+	"CMOVWPL",	LTYPE3,	ACMOVWPL,
+	"CMOVWPS",	LTYPE3,	ACMOVWPS,
+
+	"FMOVB",	LTYPE3, AFMOVB,
+	"FMOVBP",	LTYPE3, AFMOVBP,
+	"FMOVD",	LTYPE3, AFMOVD,
+	"FMOVDP",	LTYPE3, AFMOVDP,
+	"FMOVF",	LTYPE3, AFMOVF,
+	"FMOVFP",	LTYPE3, AFMOVFP,
+	"FMOVL",	LTYPE3, AFMOVL,
+	"FMOVLP",	LTYPE3, AFMOVLP,
+	"FMOVV",	LTYPE3, AFMOVV,
+	"FMOVVP",	LTYPE3, AFMOVVP,
+	"FMOVW",	LTYPE3, AFMOVW,
+	"FMOVWP",	LTYPE3, AFMOVWP,
+	"FMOVX",	LTYPE3, AFMOVX,
+	"FMOVXP",	LTYPE3, AFMOVXP,
+	"FCMOVCC",	LTYPE3, AFCMOVCC,
+	"FCMOVCS",	LTYPE3, AFCMOVCS,
+	"FCMOVEQ",	LTYPE3, AFCMOVEQ,
+	"FCMOVHI",	LTYPE3, AFCMOVHI,
+	"FCMOVLS",	LTYPE3, AFCMOVLS,
+	"FCMOVNE",	LTYPE3, AFCMOVNE,
+	"FCMOVNU",	LTYPE3, AFCMOVNU,
+	"FCMOVUN",	LTYPE3, AFCMOVUN,
+	"FCOMB",	LTYPE3, AFCOMB,
+	"FCOMBP",	LTYPE3, AFCOMBP,
+	"FCOMD",	LTYPE3, AFCOMD,
+	"FCOMDP",	LTYPE3, AFCOMDP,
+	"FCOMDPP",	LTYPE3, AFCOMDPP,
+	"FCOMF",	LTYPE3, AFCOMF,
+	"FCOMFP",	LTYPE3, AFCOMFP,
+	"FCOMI",	LTYPE3, AFCOMI,
+	"FCOMIP",	LTYPE3, AFCOMIP,
+	"FCOML",	LTYPE3, AFCOML,
+	"FCOMLP",	LTYPE3, AFCOMLP,
+	"FCOMW",	LTYPE3, AFCOMW,
+	"FCOMWP",	LTYPE3, AFCOMWP,
+	"FUCOM",	LTYPE3, AFUCOM,
+	"FUCOMI",	LTYPE3, AFUCOMI,
+	"FUCOMIP",	LTYPE3, AFUCOMIP,
+	"FUCOMP",	LTYPE3, AFUCOMP,
+	"FUCOMPP",	LTYPE3, AFUCOMPP,
+	"FADDW",	LTYPE3, AFADDW,
+	"FADDL",	LTYPE3, AFADDL,
+	"FADDF",	LTYPE3, AFADDF,
+	"FADDD",	LTYPE3, AFADDD,
+	"FADDDP",	LTYPE3, AFADDDP,
+	"FSUBDP",	LTYPE3, AFSUBDP,
+	"FSUBW",	LTYPE3, AFSUBW,
+	"FSUBL",	LTYPE3, AFSUBL,
+	"FSUBF",	LTYPE3, AFSUBF,
+	"FSUBD",	LTYPE3, AFSUBD,
+	"FSUBRDP",	LTYPE3, AFSUBRDP,
+	"FSUBRW",	LTYPE3, AFSUBRW,
+	"FSUBRL",	LTYPE3, AFSUBRL,
+	"FSUBRF",	LTYPE3, AFSUBRF,
+	"FSUBRD",	LTYPE3, AFSUBRD,
+	"FMULDP",	LTYPE3, AFMULDP,
+	"FMULW",	LTYPE3, AFMULW,
+	"FMULL",	LTYPE3, AFMULL,
+	"FMULF",	LTYPE3, AFMULF,
+	"FMULD",	LTYPE3, AFMULD,
+	"FDIVDP",	LTYPE3, AFDIVDP,
+	"FDIVW",	LTYPE3, AFDIVW,
+	"FDIVL",	LTYPE3, AFDIVL,
+	"FDIVF",	LTYPE3, AFDIVF,
+	"FDIVD",	LTYPE3, AFDIVD,
+	"FDIVRDP",	LTYPE3, AFDIVRDP,
+	"FDIVRW",	LTYPE3, AFDIVRW,
+	"FDIVRL",	LTYPE3, AFDIVRL,
+	"FDIVRF",	LTYPE3, AFDIVRF,
+	"FDIVRD",	LTYPE3, AFDIVRD,
+	"FXCHD",	LTYPE3, AFXCHD,
+	"FFREE",	LTYPE1, AFFREE,
+	"FLDCW",	LTYPE2, AFLDCW,
+	"FLDENV",	LTYPE1, AFLDENV,
+	"FRSTOR",	LTYPE2, AFRSTOR,
+	"FSAVE",	LTYPE1, AFSAVE,
+	"FSTCW",	LTYPE1, AFSTCW,
+	"FSTENV",	LTYPE1, AFSTENV,
+	"FSTSW",	LTYPE1, AFSTSW,
+	"F2XM1",	LTYPE0, AF2XM1,
+	"FABS",		LTYPE0, AFABS,
+	"FCHS",		LTYPE0, AFCHS,
+	"FCLEX",	LTYPE0, AFCLEX,
+	"FCOS",		LTYPE0, AFCOS,
+	"FDECSTP",	LTYPE0, AFDECSTP,
+	"FINCSTP",	LTYPE0, AFINCSTP,
+	"FINIT",	LTYPE0, AFINIT,
+	"FLD1",		LTYPE0, AFLD1,
+	"FLDL2E",	LTYPE0, AFLDL2E,
+	"FLDL2T",	LTYPE0, AFLDL2T,
+	"FLDLG2",	LTYPE0, AFLDLG2,
+	"FLDLN2",	LTYPE0, AFLDLN2,
+	"FLDPI",	LTYPE0, AFLDPI,
+	"FLDZ",		LTYPE0, AFLDZ,
+	"FNOP",		LTYPE0, AFNOP,
+	"FPATAN",	LTYPE0, AFPATAN,
+	"FPREM",	LTYPE0, AFPREM,
+	"FPREM1",	LTYPE0, AFPREM1,
+	"FPTAN",	LTYPE0, AFPTAN,
+	"FRNDINT",	LTYPE0, AFRNDINT,
+	"FSCALE",	LTYPE0, AFSCALE,
+	"FSIN",		LTYPE0, AFSIN,
+	"FSINCOS",	LTYPE0, AFSINCOS,
+	"FSQRT",	LTYPE0, AFSQRT,
+	"FTST",		LTYPE0, AFTST,
+	"FXAM",		LTYPE0, AFXAM,
+	"FXTRACT",	LTYPE0, AFXTRACT,
+	"FYL2X",	LTYPE0, AFYL2X,
+	"FYL2XP1",	LTYPE0, AFYL2XP1,
+
+	0
+};
+
+void
+cinit(void)
+{
+	Sym *s;
+	int i;
+
+	nullgen.sym = S;
+	nullgen.offset = 0;
+	if(FPCHIP)
+		nullgen.dval = 0;
+	for(i=0; i<sizeof(nullgen.sval); i++)
+		nullgen.sval[i] = 0;
+	nullgen.type = D_NONE;
+	nullgen.index = D_NONE;
+	nullgen.scale = 0;
+
+	nerrors = 0;
+	iostack = I;
+	iofree = I;
+	peekc = IGN;
+	nhunk = 0;
+	for(i=0; i<NHASH; i++)
+		hash[i] = S;
+	for(i=0; itab[i].name; i++) {
+		s = slookup(itab[i].name);
+		if(s->type != LNAME)
+			yyerror("double initialization %s", itab[i].name);
+		s->type = itab[i].type;
+		s->value = itab[i].value;
+	}
+
+	pathname = allocn(pathname, 0, 100);
+	if(mygetwd(pathname, 99) == 0) {
+		pathname = allocn(pathname, 100, 900);
+		if(mygetwd(pathname, 999) == 0)
+			strcpy(pathname, "/?");
+	}
+}
+
+void
+checkscale(int scale)
+{
+
+	switch(scale) {
+	case 1:
+	case 2:
+	case 4:
+	case 8:
+		return;
+	}
+	yyerror("scale must be 1248: %d", scale);
+}
+
+void
+syminit(Sym *s)
+{
+
+	s->type = LNAME;
+	s->value = 0;
+}
+
+void
+cclean(void)
+{
+	Gen2 g2;
+
+	g2.from = nullgen;
+	g2.to = nullgen;
+	outcode(AEND, &g2);
+	Bflush(&obuf);
+}
+
+void
+zname(char *n, int t, int s)
+{
+
+	Bputc(&obuf, ANAME);		/* as(2) */
+	Bputc(&obuf, ANAME>>8);
+	Bputc(&obuf, t);		/* type */
+	Bputc(&obuf, s);		/* sym */
+	while(*n) {
+		Bputc(&obuf, *n);
+		n++;
+	}
+	Bputc(&obuf, 0);
+}
+
+void
+zaddr(Gen *a, int s)
+{
+	long l;
+	int i, t;
+	char *n;
+	Ieee e;
+
+	t = 0;
+	if(a->index != D_NONE || a->scale != 0)
+		t |= T_INDEX;
+	if(a->offset != 0)
+		t |= T_OFFSET;
+	if(s != 0)
+		t |= T_SYM;
+
+	switch(a->type) {
+	default:
+		t |= T_TYPE;
+		break;
+	case D_FCONST:
+		t |= T_FCONST;
+		break;
+	case D_CONST2:
+		t |= T_OFFSET|T_OFFSET2;
+		break;
+	case D_SCONST:
+		t |= T_SCONST;
+		break;
+	case D_NONE:
+		break;
+	}
+	Bputc(&obuf, t);
+
+	if(t & T_INDEX) {	/* implies index, scale */
+		Bputc(&obuf, a->index);
+		Bputc(&obuf, a->scale);
+	}
+	if(t & T_OFFSET) {	/* implies offset */
+		l = a->offset;
+		Bputc(&obuf, l);
+		Bputc(&obuf, l>>8);
+		Bputc(&obuf, l>>16);
+		Bputc(&obuf, l>>24);
+	}
+	if(t & T_OFFSET2) {
+		l = a->offset2;
+		Bputc(&obuf, l);
+		Bputc(&obuf, l>>8);
+		Bputc(&obuf, l>>16);
+		Bputc(&obuf, l>>24);
+	}
+	if(t & T_SYM)		/* implies sym */
+		Bputc(&obuf, s);
+	if(t & T_FCONST) {
+		ieeedtod(&e, a->dval);
+		l = e.l;
+		Bputc(&obuf, l);
+		Bputc(&obuf, l>>8);
+		Bputc(&obuf, l>>16);
+		Bputc(&obuf, l>>24);
+		l = e.h;
+		Bputc(&obuf, l);
+		Bputc(&obuf, l>>8);
+		Bputc(&obuf, l>>16);
+		Bputc(&obuf, l>>24);
+		return;
+	}
+	if(t & T_SCONST) {
+		n = a->sval;
+		for(i=0; i<NSNAME; i++) {
+			Bputc(&obuf, *n);
+			n++;
+		}
+		return;
+	}
+	if(t & T_TYPE)
+		Bputc(&obuf, a->type);
+}
+
+void
+outcode(int a, Gen2 *g2)
+{
+	int sf, st, t;
+	Sym *s;
+
+	if(pass == 1)
+		goto out;
+
+jackpot:
+	sf = 0;
+	s = g2->from.sym;
+	while(s != S) {
+		sf = s->sym;
+		if(sf < 0 || sf >= NSYM)
+			sf = 0;
+		t = g2->from.type;
+		if(t == D_ADDR)
+			t = g2->from.index;
+		if(h[sf].type == t)
+		if(h[sf].sym == s)
+			break;
+		zname(s->name, t, sym);
+		s->sym = sym;
+		h[sym].sym = s;
+		h[sym].type = t;
+		sf = sym;
+		sym++;
+		if(sym >= NSYM)
+			sym = 1;
+		break;
+	}
+	st = 0;
+	s = g2->to.sym;
+	while(s != S) {
+		st = s->sym;
+		if(st < 0 || st >= NSYM)
+			st = 0;
+		t = g2->to.type;
+		if(t == D_ADDR)
+			t = g2->to.index;
+		if(h[st].type == t)
+		if(h[st].sym == s)
+			break;
+		zname(s->name, t, sym);
+		s->sym = sym;
+		h[sym].sym = s;
+		h[sym].type = t;
+		st = sym;
+		sym++;
+		if(sym >= NSYM)
+			sym = 1;
+		if(st == sf)
+			goto jackpot;
+		break;
+	}
+	Bputc(&obuf, a);
+	Bputc(&obuf, a>>8);
+	Bputc(&obuf, lineno);
+	Bputc(&obuf, lineno>>8);
+	Bputc(&obuf, lineno>>16);
+	Bputc(&obuf, lineno>>24);
+	zaddr(&g2->from, sf);
+	zaddr(&g2->to, st);
+
+out:
+	if(a != AGLOBL && a != ADATA)
+		pc++;
+}
+
+void
+outhist(void)
+{
+	Gen g;
+	Hist *h;
+	char *p, *q, *op, c;
+	int n;
+
+	g = nullgen;
+	c = pathchar();
+	for(h = hist; h != H; h = h->link) {
+		p = h->name;
+		op = 0;
+		/* on windows skip drive specifier in pathname */
+		if(systemtype(Windows) && p && p[1] == ':'){
+			p += 2;
+			c = *p;
+		}
+		if(p && p[0] != c && h->offset == 0 && pathname){
+			/* on windows skip drive specifier in pathname */
+			if(systemtype(Windows) && pathname[1] == ':') {
+				op = p;
+				p = pathname+2;
+				c = *p;
+			} else if(pathname[0] == c){
+				op = p;
+				p = pathname;
+			}
+		}
+		while(p) {
+			q = strchr(p, c);
+			if(q) {
+				n = q-p;
+				if(n == 0){
+					n = 1;	/* leading "/" */
+					*p = '/';	/* don't emit "\" on windows */
+				}
+				q++;
+			} else {
+				n = strlen(p);
+				q = 0;
+			}
+			if(n) {
+				Bputc(&obuf, ANAME);
+				Bputc(&obuf, ANAME>>8);
+				Bputc(&obuf, D_FILE);	/* type */
+				Bputc(&obuf, 1);	/* sym */
+				Bputc(&obuf, '<');
+				Bwrite(&obuf, p, n);
+				Bputc(&obuf, 0);
+			}
+			p = q;
+			if(p == 0 && op) {
+				p = op;
+				op = 0;
+			}
+		}
+		g.offset = h->offset;
+
+		Bputc(&obuf, AHISTORY);
+		Bputc(&obuf, AHISTORY>>8);
+		Bputc(&obuf, h->line);
+		Bputc(&obuf, h->line>>8);
+		Bputc(&obuf, h->line>>16);
+		Bputc(&obuf, h->line>>24);
+		zaddr(&nullgen, 0);
+		zaddr(&g, 0);
+	}
+}
+
+#include "../cc/lexbody"
+#include "../cc/macbody"
diff --git a/utils/8a/mkfile b/utils/8a/mkfile
new file mode 100644
index 0000000..b021d34
--- /dev/null
+++ b/utils/8a/mkfile
@@ -0,0 +1,30 @@
+<../../mkconfig
+
+TARG=8a
+
+OFILES=\
+	y.tab.$O\
+	lex.$O\
+
+HFILES=\
+	../8c/8.out.h\
+	y.tab.h\
+	a.h\
+
+YFILES=a.y\
+
+LIBS=cc bio 9		# order is important
+
+BIN=$ROOT/$OBJDIR/bin
+
+<$ROOT/mkfiles/mkone-$SHELLTYPE
+
+YFLAGS=-D1 -d
+CFLAGS=	$CFLAGS -I../include
+
+lex.$O:	../cc/macbody ../cc/lexbody
+
+$ROOT/$OBJDIR/lib/libcc.a:
+	cd ../cc
+	mk $MKFLAGS install
+	mk $MKFLAGS clean
diff --git a/utils/8a/y.debug b/utils/8a/y.debug
new file mode 100644
index 0000000..68fcafe
--- /dev/null
+++ b/utils/8a/y.debug
@@ -0,0 +1,283 @@
+char*	yytoknames[] =
+{
+	"$end",
+	"error",
+	"$unk",
+	" |",
+	" ^",
+	" &",
+	" <",
+	" >",
+	" +",
+	" -",
+	" *",
+	" /",
+	" %",
+	"LTYPE0",
+	"LTYPE1",
+	"LTYPE2",
+	"LTYPE3",
+	"LTYPE4",
+	"LTYPEC",
+	"LTYPED",
+	"LTYPEN",
+	"LTYPER",
+	"LTYPET",
+	"LTYPES",
+	"LTYPEM",
+	"LTYPEI",
+	"LTYPEG",
+	"LCONST",
+	"LFP",
+	"LPC",
+	"LSB",
+	"LBREG",
+	"LLREG",
+	"LSREG",
+	"LFREG",
+	"LFCONST",
+	"LSCONST",
+	"LSP",
+	"LNAME",
+	"LLAB",
+	"LVAR",
+	" :",
+	" ;",
+	" =",
+	" ,",
+	" (",
+	" )",
+	" $",
+	" ~",
+};
+char*	yystates[] =
+{
+	0, /*0*/
+	"$accept:  prog.$end \nprog:  prog.line \n", /*1*/
+	0, /*2*/
+	"line:  LLAB.: $$3 line \n", /*3*/
+	"line:  LNAME.: $$5 line \ninst:  LNAME.= expr \n", /*4*/
+	0, /*5*/
+	"line:  inst.; \n", /*6*/
+	"line:  error.; \n", /*7*/
+	"inst:  LVAR.= expr \n", /*8*/
+	0, /*9*/
+	"inst:  LTYPE1.nonrem \n", /*10*/
+	"inst:  LTYPE2.rimnon \n", /*11*/
+	"inst:  LTYPE3.rimrem \n", /*12*/
+	"inst:  LTYPE4.remrim \n", /*13*/
+	"inst:  LTYPER.nonrel \n", /*14*/
+	"inst:  LTYPED.spec1 \n", /*15*/
+	"inst:  LTYPET.spec2 \n", /*16*/
+	"inst:  LTYPEC.spec3 \n", /*17*/
+	0, /*18*/
+	"inst:  LTYPES.spec5 \n", /*19*/
+	"inst:  LTYPEM.spec6 \n", /*20*/
+	"inst:  LTYPEI.spec7 \n", /*21*/
+	"inst:  LTYPEG.spec8 \n", /*22*/
+	0, /*23*/
+	0, /*24*/
+	"inst:  LNAME =.expr \n", /*25*/
+	0, /*26*/
+	0, /*27*/
+	"inst:  LVAR =.expr \n", /*28*/
+	0, /*29*/
+	0, /*30*/
+	0, /*31*/
+	"nonrem:  ,.rem \n", /*32*/
+	0, /*33*/
+	0, /*34*/
+	0, /*35*/
+	0, /*36*/
+	0, /*37*/
+	0, /*38*/
+	0, /*39*/
+	0, /*40*/
+	0, /*41*/
+	0, /*42*/
+	0, /*43*/
+	"omem:  (.LLREG ) \nomem:  (.LSP ) \nomem:  (.LLREG * con ) \nomem:  (.LLREG ) ( LLREG * con ) \ncon:  (.expr ) \n", /*44*/
+	0, /*45*/
+	0, /*46*/
+	0, /*47*/
+	"con:  -.con \n", /*48*/
+	"con:  +.con \n", /*49*/
+	"con:  ~.con \n", /*50*/
+	0, /*51*/
+	0, /*52*/
+	0, /*53*/
+	0, /*54*/
+	0, /*55*/
+	"imm:  $.con \nimm:  $.nam \nimm:  $.LSCONST \nimm:  $.LFCONST \nimm:  $.( LFCONST ) \nimm:  $.- LFCONST \n", /*56*/
+	0, /*57*/
+	"rimrem:  rim., rem \n", /*58*/
+	0, /*59*/
+	"remrim:  rem., rim \n", /*60*/
+	0, /*61*/
+	"nonrel:  ,.rel \n", /*62*/
+	0, /*63*/
+	"rel:  con.( LPC ) \n", /*64*/
+	0, /*65*/
+	0, /*66*/
+	"con:  (.expr ) \n", /*67*/
+	0, /*68*/
+	"spec1:  nam./ con , imm \n", /*69*/
+	0, /*70*/
+	"spec2:  mem., imm \nspec2:  mem., con , imm \n", /*71*/
+	0, /*72*/
+	"spec3:  ,.rom \n", /*73*/
+	0, /*74*/
+	0, /*75*/
+	0, /*76*/
+	"rom:  *.reg \nrom:  *.omem \n", /*77*/
+	0, /*78*/
+	0, /*79*/
+	0, /*80*/
+	0, /*81*/
+	0, /*82*/
+	0, /*83*/
+	0, /*84*/
+	0, /*85*/
+	0, /*86*/
+	0, /*87*/
+	"spec5:  rim., rem \nspec5:  rim., rem : LLREG \n", /*88*/
+	0, /*89*/
+	"spec6:  rim., rem \nspec6:  rim., rem : LSREG \n", /*90*/
+	0, /*91*/
+	0, /*92*/
+	0, /*93*/
+	"spec8:  mem., imm \nspec8:  mem., con , imm \n", /*94*/
+	"line:  LLAB : $$3.line \n", /*95*/
+	"line:  LNAME : $$5.line \n", /*96*/
+	0, /*97*/
+	0, /*98*/
+	0, /*99*/
+	0, /*100*/
+	"omem:  con (.LLREG ) \nomem:  con (.LSP ) \nomem:  con (.LLREG * con ) \nomem:  con (.LLREG ) ( LLREG * con ) \nomem:  con (.LSREG ) \n", /*101*/
+	"omem:  ( LLREG.) \nomem:  ( LLREG.* con ) \nomem:  ( LLREG.) ( LLREG * con ) \n", /*102*/
+	"omem:  ( LSP.) \n", /*103*/
+	"con:  ( expr.) \nexpr:  expr.+ expr \nexpr:  expr.- expr \nexpr:  expr.* expr \nexpr:  expr./ expr \nexpr:  expr.% expr \nexpr:  expr.< < expr \nexpr:  expr.> > expr \nexpr:  expr.& expr \nexpr:  expr.^ expr \nexpr:  expr.| expr \n", /*104*/
+	"nmem:  nam (.LLREG * con ) \n", /*105*/
+	0, /*106*/
+	0, /*107*/
+	0, /*108*/
+	"nam:  LNAME offset.( pointer ) \n", /*109*/
+	"nam:  LNAME <.> offset ( LSB ) \n", /*110*/
+	"offset:  +.con \n", /*111*/
+	"offset:  -.con \n", /*112*/
+	0, /*113*/
+	0, /*114*/
+	0, /*115*/
+	0, /*116*/
+	0, /*117*/
+	"imm:  $ (.LFCONST ) \ncon:  (.expr ) \n", /*118*/
+	"imm:  $ -.LFCONST \ncon:  -.con \n", /*119*/
+	"rimrem:  rim ,.rem \n", /*120*/
+	"remrim:  rem ,.rim \n", /*121*/
+	0, /*122*/
+	"rel:  con (.LPC ) \n", /*123*/
+	0, /*124*/
+	0, /*125*/
+	"spec1:  nam /.con , imm \n", /*126*/
+	"spec2:  mem ,.imm \nspec2:  mem ,.con , imm \n", /*127*/
+	0, /*128*/
+	0, /*129*/
+	0, /*130*/
+	"rel:  con (.LPC ) \nomem:  con (.LLREG ) \nomem:  con (.LSP ) \nomem:  con (.LLREG * con ) \nomem:  con (.LLREG ) ( LLREG * con ) \nomem:  con (.LSREG ) \n", /*131*/
+	0, /*132*/
+	"spec5:  rim ,.rem \nspec5:  rim ,.rem : LLREG \n", /*133*/
+	"spec6:  rim ,.rem \nspec6:  rim ,.rem : LSREG \n", /*134*/
+	0, /*135*/
+	"spec8:  mem ,.imm \nspec8:  mem ,.con , imm \n", /*136*/
+	0, /*137*/
+	0, /*138*/
+	"expr:  expr +.expr \n", /*139*/
+	"expr:  expr -.expr \n", /*140*/
+	"expr:  expr *.expr \n", /*141*/
+	"expr:  expr /.expr \n", /*142*/
+	"expr:  expr %.expr \n", /*143*/
+	"expr:  expr <.< expr \n", /*144*/
+	"expr:  expr >.> expr \n", /*145*/
+	"expr:  expr &.expr \n", /*146*/
+	"expr:  expr ^.expr \n", /*147*/
+	"expr:  expr |.expr \n", /*148*/
+	"omem:  con ( LLREG.) \nomem:  con ( LLREG.* con ) \nomem:  con ( LLREG.) ( LLREG * con ) \n", /*149*/
+	"omem:  con ( LSP.) \n", /*150*/
+	"omem:  con ( LSREG.) \n", /*151*/
+	0, /*152*/
+	"omem:  ( LLREG *.con ) \n", /*153*/
+	0, /*154*/
+	0, /*155*/
+	"nmem:  nam ( LLREG.* con ) \n", /*156*/
+	"nam:  LNAME offset (.pointer ) \n", /*157*/
+	0, /*158*/
+	0, /*159*/
+	0, /*160*/
+	"imm:  $ ( LFCONST.) \n", /*161*/
+	0, /*162*/
+	0, /*163*/
+	0, /*164*/
+	"rel:  con ( LPC.) \n", /*165*/
+	"spec1:  nam / con., imm \n", /*166*/
+	0, /*167*/
+	"spec2:  mem , con., imm \n", /*168*/
+	0, /*169*/
+	0, /*170*/
+	0, /*171*/
+	0, /*172*/
+	"spec8:  mem , con., imm \n", /*173*/
+	0, /*174*/
+	0, /*175*/
+	0, /*176*/
+	0, /*177*/
+	0, /*178*/
+	"expr:  expr < <.expr \n", /*179*/
+	"expr:  expr > >.expr \n", /*180*/
+	0, /*181*/
+	0, /*182*/
+	0, /*183*/
+	0, /*184*/
+	"omem:  con ( LLREG *.con ) \n", /*185*/
+	0, /*186*/
+	0, /*187*/
+	"omem:  ( LLREG ) (.LLREG * con ) \n", /*188*/
+	"omem:  ( LLREG * con.) \n", /*189*/
+	"nmem:  nam ( LLREG *.con ) \n", /*190*/
+	"nam:  LNAME offset ( pointer.) \n", /*191*/
+	0, /*192*/
+	0, /*193*/
+	0, /*194*/
+	"nam:  LNAME < > offset.( LSB ) \n", /*195*/
+	0, /*196*/
+	0, /*197*/
+	"spec1:  nam / con ,.imm \n", /*198*/
+	"spec2:  mem , con ,.imm \n", /*199*/
+	"spec5:  rim , rem :.LLREG \n", /*200*/
+	"spec6:  rim , rem :.LSREG \n", /*201*/
+	"spec8:  mem , con ,.imm \n", /*202*/
+	0, /*203*/
+	0, /*204*/
+	"omem:  con ( LLREG ) (.LLREG * con ) \n", /*205*/
+	"omem:  con ( LLREG * con.) \n", /*206*/
+	"omem:  ( LLREG ) ( LLREG.* con ) \n", /*207*/
+	0, /*208*/
+	"nmem:  nam ( LLREG * con.) \n", /*209*/
+	0, /*210*/
+	"nam:  LNAME < > offset (.LSB ) \n", /*211*/
+	0, /*212*/
+	0, /*213*/
+	0, /*214*/
+	0, /*215*/
+	0, /*216*/
+	"omem:  con ( LLREG ) ( LLREG.* con ) \n", /*217*/
+	0, /*218*/
+	"omem:  ( LLREG ) ( LLREG *.con ) \n", /*219*/
+	0, /*220*/
+	"nam:  LNAME < > offset ( LSB.) \n", /*221*/
+	"omem:  con ( LLREG ) ( LLREG *.con ) \n", /*222*/
+	"omem:  ( LLREG ) ( LLREG * con.) \n", /*223*/
+	0, /*224*/
+	"omem:  con ( LLREG ) ( LLREG * con.) \n", /*225*/
+	0, /*226*/
+	0, /*227*/
+};
diff --git a/utils/8a/y.tab.c b/utils/8a/y.tab.c
new file mode 100644
index 0000000..ce5d9c0
--- /dev/null
+++ b/utils/8a/y.tab.c
@@ -0,0 +1,1069 @@
+
+#line	2	"a.y"
+#include "a.h"
+
+#line	4	"a.y"
+typedef union 	{
+	Sym	*sym;
+	long	lval;
+	struct {
+		long v1;
+		long v2;
+	} con2;
+	double	dval;
+	char	sval[8];
+	Gen	gen;
+	Gen2	gen2;
+} YYSTYPE;
+extern	int	yyerrflag;
+#ifndef	YYMAXDEPTH
+#define	YYMAXDEPTH	150
+#endif
+YYSTYPE	yylval;
+YYSTYPE	yyval;
+#define	LTYPE0	57346
+#define	LTYPE1	57347
+#define	LTYPE2	57348
+#define	LTYPE3	57349
+#define	LTYPE4	57350
+#define	LTYPEC	57351
+#define	LTYPED	57352
+#define	LTYPEN	57353
+#define	LTYPER	57354
+#define	LTYPET	57355
+#define	LTYPES	57356
+#define	LTYPEM	57357
+#define	LTYPEI	57358
+#define	LTYPEG	57359
+#define	LCONST	57360
+#define	LFP	57361
+#define	LPC	57362
+#define	LSB	57363
+#define	LBREG	57364
+#define	LLREG	57365
+#define	LSREG	57366
+#define	LFREG	57367
+#define	LFCONST	57368
+#define	LSCONST	57369
+#define	LSP	57370
+#define	LNAME	57371
+#define	LLAB	57372
+#define	LVAR	57373
+#define YYEOFCODE 1
+#define YYERRCODE 2
+short	yyexca[] =
+{-1, 1,
+	1, -1,
+	-2, 0,
+};
+#define	YYNPROD	121
+#define	YYPRIVATE 57344
+#define	yydebug	1
+#define	YYLAST	529
+short	yyact[] =
+{
+  43,  55,   2, 109,  41,  74,  34,  56, 185,  42,
+  53, 153, 227,  75, 226,  64, 224, 104,  81,  80,
+  45, 220,  79,  58,  78, 218,  98,  76,  63,  98,
+  88,  90,  92, 210, 208, 197,  69, 196, 187, 186,
+ 154, 211, 205,  97, 184,  98,  99, 152,  54, 106,
+ 107, 108, 188, 157, 131, 123, 105, 114, 101,  33,
+ 202, 199,  60,  64, 198, 136, 135,  33,  98, 124,
+ 125,  49,  48,  77,  81,  80, 122, 115,  79, 128,
+  78, 100, 130,  76, 129, 134, 132, 133, 127, 121,
+  46, 120, 113,  30,  36,  38,  40,  37, 137, 138,
+  39,  82,  66,  47,  28, 215,  27,  73,  44,  26,
+  56,  50, 159, 160,  24, 201,  25, 200,  23,  98,
+ 106,  51, 165, 217, 214, 149, 151, 166, 168, 167,
+ 150, 207, 164, 156, 221, 100, 165, 173, 172, 126,
+  98,  98,  98,  98,  98, 149, 151,  98,  98,  98,
+ 150, 222,  31, 219, 189,  35,  29, 174, 175, 176,
+ 177, 178, 195, 190, 181, 182, 183, 180, 194, 163,
+ 192,  85,  71, 111, 112,  84, 158, 193,  94, 179,
+  98,  98, 169, 170, 171,   6, 206,  49,  48,  77,
+  96, 209, 139, 140, 141, 142, 143, 203, 204,  95,
+ 212, 213,   1,  93, 216,  91,  46, 141, 142, 143,
+  36,  38,  40,  37,  49,  48,  39,  82,  66,  47,
+ 223,  89,  87, 225,  44,  83,  56,  50, 110,  72,
+ 111, 112,  70,  46,  68,  59,  57,  36,  38,  40,
+  37,  52,  61,  39,  51,   7,  47, 191,   0,   0,
+   0,  44,   0,  56,  50,   0,   0,   9,  10,  11,
+  12,  13,  17,  15,  18,  14,  16,  19,  20,  21,
+  22,  49,  48, 147, 146, 144, 145, 139, 140, 141,
+ 142, 143,   4,   3,   8,   0,   5,   0,   0,   0,
+  46,  49,  48,   0,  36,  38,  40,  37,   0,   0,
+  39,  51,   0,  47,   0,   0,   0,  86,  44,   0,
+  46,  50,   0,   0,  36,  38,  40,  37,  49,  48,
+  39,  51,   0,  47,   0,   0,   0,  32,  44,   0,
+   0,  50,   0,   0,   0,   0,   0,  46,  49,  48,
+   0,  36,  38,  40,  37,   0,   0,  39,  51,   0,
+  47,   0,   0,   0,   0,  44,   0,  46,  50,   0,
+   0,  36,  38,  40,  37,   0,   0,  39,   0,   0,
+  47,  49, 119,   0,   0,  44,   0,   0,  50, 148,
+ 147, 146, 144, 145, 139, 140, 141, 142, 143,   0,
+  46,   0,   0,  49,  48,   0,   0,   0, 117, 116,
+   0,  51,   0,  47,   0,   0,   0,   0, 118,  49,
+  48,  50,  46,  49,  48,  49,  48,   0,   0,  49,
+  48,   0, 155,  65,  66,  47,   0,   0,  46,  62,
+  67,   0,  46,  50,  46,   0,   0, 102,  46,  65,
+  66,  47, 103,  49,  48,  47,  67,  47,   0,  50,
+  67,  47,  67,  50,  56,  50,  67,  49,  48,  50,
+   0,   0,  46,  49,  48,   0,   0,   0,   0,   0,
+ 162,   0,   0,   0,   0,  47,  46,   0,   0,   0,
+  67,   0,  46,  50, 161,   0,   0,   0,   0,  47,
+   0,   0,   0,  51,  67,  47,   0,  50,   0,   0,
+  44,   0,   0,  50, 148, 147, 146, 144, 145, 139,
+ 140, 141, 142, 143, 146, 144, 145, 139, 140, 141,
+ 142, 143, 144, 145, 139, 140, 141, 142, 143
+};
+short	yypact[] =
+{
+-1000, 243,-1000,  76,  72,-1000,  66,  63,  60,  48,
+ 282, 205, 205, 309, 384,  82, 454,  62, 262, 205,
+ 205, 205, 454,-1000,-1000, 410,-1000,-1000, 410,-1000,
+-1000,-1000, 309,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
+-1000,-1000,-1000,  12, 404,  10,-1000,-1000, 410, 410,
+ 410, 221,-1000,  47,-1000,-1000, 362,-1000,  46,-1000,
+  44,-1000, 400,-1000,   9, 164, 164, 410,-1000, 127,
+-1000,  43,-1000, 178,-1000,-1000,-1000, 329,-1000,-1000,
+-1000,   8, 221,-1000,-1000,-1000, 309,-1000,  42,-1000,
+  40,-1000,  21,-1000,  20, 243, 243, 500,-1000, 500,
+-1000, 112,   0,  -7, 375, 100,-1000,-1000,-1000,   7,
+ 168, 410, 410,-1000,-1000,-1000,-1000,-1000, 448, 434,
+ 309, 205,-1000, 106,-1000,-1000, 410, 406,-1000,-1000,
+-1000,  92,   7, 309, 309, 309, 406,-1000,-1000, 410,
+ 410, 410, 410, 410, 172, 159, 410, 410, 410,  -3,
+  -8,  -9,   6, 410,-1000,-1000, 152, 139, 164,-1000,
+-1000, -10,-1000,-1000,-1000, -12,  19,-1000,  16,  75,
+  73,-1000,-1000,  15, 196, 196,-1000,-1000,-1000, 410,
+ 410, 515, 508, 268,  -4, 410,-1000,-1000,  98, -13,
+ 410, -14,-1000,-1000,-1000,  -5,-1000,-1000, -41, -41,
+  91,  71, -41, 183, 183,  90, -22, 142,-1000, -26,
+-1000, 103,-1000,-1000,-1000,-1000,-1000, 140,-1000, 410,
+-1000, -31, 410, -33,-1000, -35,-1000,-1000
+};
+short	yypgo[] =
+{
+   0,   0,  17, 247,   3, 247, 155,   1, 247,   6,
+  20,  13,  48,  10,   5,   4,   9, 156, 242, 152,
+ 241, 236, 235, 234, 232, 229, 225, 222, 221, 205,
+ 203, 202,   2, 199, 190, 185
+};
+short	yyr1[] =
+{
+   0,  31,  31,  33,  32,  34,  32,  32,  32,  32,
+  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,
+  35,  35,  35,  35,  35,  35,  17,  17,  21,  22,
+  20,  20,  19,  19,  18,  18,  23,  24,  24,  25,
+  25,  26,  26,  27,  27,  28,  28,  29,  29,  29,
+  30,  30,  12,  12,  14,  14,  14,  14,  14,  14,
+  14,  13,  13,  11,  11,  11,   9,   9,   9,   9,
+   9,   7,   7,   7,   7,   7,   7,   8,   5,   5,
+   5,   5,   6,   6,  15,  15,  15,  15,  15,  15,
+  15,  15,  15,  15,  16,  16,  10,  10,   4,   4,
+   4,   3,   3,   3,   1,   1,   1,   1,   1,   1,
+   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
+   2
+};
+short	yyr2[] =
+{
+   0,   0,   2,   0,   4,   0,   4,   1,   2,   2,
+   3,   3,   2,   2,   2,   2,   2,   2,   2,   2,
+   2,   2,   2,   2,   2,   2,   0,   1,   3,   3,
+   2,   1,   2,   1,   2,   1,   5,   3,   5,   2,
+   1,   1,   1,   3,   5,   3,   5,   2,   1,   3,
+   3,   5,   1,   1,   1,   1,   2,   2,   1,   1,
+   1,   1,   1,   4,   2,   2,   1,   1,   1,   1,
+   1,   2,   2,   2,   2,   4,   3,   2,   1,   2,
+   3,   4,   1,   1,   1,   4,   4,   6,   9,   3,
+   3,   4,   5,   8,   1,   6,   5,   7,   0,   2,
+   2,   1,   1,   1,   1,   1,   2,   2,   2,   3,
+   1,   3,   3,   3,   3,   3,   4,   4,   3,   3,
+   3
+};
+short	yychk[] =
+{
+-1000, -31, -32,  40,  39,  43, -35,   2,  41,  14,
+  15,  16,  17,  18,  22,  20,  23,  19,  21,  24,
+  25,  26,  27,  42,  42,  44,  43,  43,  44, -17,
+  45, -19,  45, -12,  -9,  -6,  32,  35,  33,  38,
+  34, -15, -16,  -1,  46, -10,  28,  41,  10,   9,
+  49,  39, -20, -13, -12,  -7,  48, -21, -13, -22,
+ -12, -18,  45, -11,  -1,  39,  40,  46, -23, -10,
+ -24,  -6, -25,  45, -14, -11, -16,  11,  -9, -15,
+  -7,  -1,  39, -26, -17, -19,  45, -27, -13, -28,
+ -13, -29, -13, -30,  -6, -33, -34,  -2,  -1,  -2,
+ -12,  46,  33,  38,  -2,  46,  -1,  -1,  -1,  -4,
+   7,   9,  10,  45,  -1, -10,  37,  36,  46,  10,
+  45,  45, -11,  46,  -4,  -4,  12,  45, -14,  -9,
+ -15,  46,  -4,  45,  45,  45,  45, -32, -32,   9,
+  10,  11,  12,  13,   7,   8,   6,   5,   4,  33,
+  38,  34,  47,  11,  47,  47,  33,  46,   8,  -1,
+  -1,  36,  36, -12, -13,  30,  -1,  -7,  -1, -12,
+ -12, -12,  -7,  -1,  -2,  -2,  -2,  -2,  -2,   7,
+   8,  -2,  -2,  -2,  47,  11,  47,  47,  46,  -1,
+  11,  -3,  31,  38,  29,  -4,  47,  47,  45,  45,
+  42,  42,  45,  -2,  -2,  46,  -1,  33,  47,  -1,
+  47,  46,  -7,  -7,  33,  34,  -7,  33,  47,  11,
+  47,  31,  11,  -1,  47,  -1,  47,  47
+};
+short	yydef[] =
+{
+   1,  -2,   2,   0,   0,   7,   0,   0,   0,  26,
+   0,   0,   0,   0,   0,   0,   0,   0,  26,   0,
+   0,   0,   0,   3,   5,   0,   8,   9,   0,  12,
+  27,  13,   0,  33,  52,  53,  66,  67,  68,  69,
+  70,  82,  83,  84,   0,  94, 104, 105,   0,   0,
+   0,  98,  14,  31,  61,  62,   0,  15,   0,  16,
+   0,  17,   0,  35,   0,  98,  98,   0,  18,   0,
+  19,   0,  20,   0,  40,  54,  55,   0,  58,  59,
+  60,  84,  98,  21,  41,  42,  27,  22,   0,  23,
+   0,  24,  48,  25,   0,   0,   0,  10, 110,  11,
+  32,   0,   0,   0,   0,   0, 106, 107, 108,   0,
+   0,   0,   0,  30,  71,  72,  73,  74,   0,   0,
+   0,   0,  34,   0,  64,  65,   0,   0,  39,  56,
+  57,   0,  64,   0,   0,  47,   0,   4,   6,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,  89,   0,  90, 109,   0,   0,  98,  99,
+ 100,   0,  76,  28,  29,   0,   0,  37,   0,  43,
+  45,  49,  50,   0, 111, 112, 113, 114, 115,   0,
+   0, 118, 119, 120,  85,   0,  86,  91,   0,   0,
+   0,   0, 101, 102, 103,   0,  75,  63,   0,   0,
+   0,   0,   0, 116, 117,   0,   0,   0,  92,   0,
+  96,   0,  36,  38,  44,  46,  51,   0,  87,   0,
+  95,   0,   0,   0,  97,   0,  93,  88
+};
+short	yytok1[] =
+{
+   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,  48,  13,   6,   0,
+  46,  47,  11,   9,  45,  10,   0,  12,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,  42,  43,
+   7,  44,   8,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   5,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+   0,   0,   0,   0,   4,   0,  49
+};
+short	yytok2[] =
+{
+   2,   3,  14,  15,  16,  17,  18,  19,  20,  21,
+  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,
+  32,  33,  34,  35,  36,  37,  38,  39,  40,  41
+};
+long	yytok3[] =
+{
+   0
+};
+#define YYFLAG 		-1000
+#define	yyclearin	yychar = -1
+#define	yyerrok		yyerrflag = 0
+
+#ifdef	yydebug
+#include	"y.debug"
+#else
+#define	yydebug		0
+char*	yytoknames[1];		/* for debugging */
+char*	yystates[1];		/* for debugging */
+#endif
+
+/*	parser for yacc output	*/
+
+int	yynerrs = 0;		/* number of errors */
+int	yyerrflag = 0;		/* error recovery flag */
+
+extern	int	fprint(int, char*, ...);
+extern	int	sprint(char*, char*, ...);
+
+char*
+yytokname(int yyc)
+{
+	static char x[16];
+
+	if(yyc > 0 && yyc <= sizeof(yytoknames)/sizeof(yytoknames[0]))
+	if(yytoknames[yyc-1])
+		return yytoknames[yyc-1];
+	sprint(x, "<%d>", yyc);
+	return x;
+}
+
+char*
+yystatname(int yys)
+{
+	static char x[16];
+
+	if(yys >= 0 && yys < sizeof(yystates)/sizeof(yystates[0]))
+	if(yystates[yys])
+		return yystates[yys];
+	sprint(x, "<%d>\n", yys);
+	return x;
+}
+
+long
+yylex1(void)
+{
+	long yychar;
+	long *t3p;
+	int c;
+
+	yychar = yylex();
+	if(yychar <= 0) {
+		c = yytok1[0];
+		goto out;
+	}
+	if(yychar < sizeof(yytok1)/sizeof(yytok1[0])) {
+		c = yytok1[yychar];
+		goto out;
+	}
+	if(yychar >= YYPRIVATE)
+		if(yychar < YYPRIVATE+sizeof(yytok2)/sizeof(yytok2[0])) {
+			c = yytok2[yychar-YYPRIVATE];
+			goto out;
+		}
+	for(t3p=yytok3;; t3p+=2) {
+		c = t3p[0];
+		if(c == yychar) {
+			c = t3p[1];
+			goto out;
+		}
+		if(c == 0)
+			break;
+	}
+	c = 0;
+
+out:
+	if(c == 0)
+		c = yytok2[1];	/* unknown char */
+	if(yydebug >= 3)
+		fprint(2, "lex %.4lux %s\n", yychar, yytokname(c));
+	return c;
+}
+
+int
+yyparse(void)
+{
+	struct
+	{
+		YYSTYPE	yyv;
+		int	yys;
+	} yys[YYMAXDEPTH], *yyp, *yypt;
+	short *yyxi;
+	int yyj, yym, yystate, yyn, yyg;
+	long yychar;
+	YYSTYPE save1, save2;
+	int save3, save4;
+
+	save1 = yylval;
+	save2 = yyval;
+	save3 = yynerrs;
+	save4 = yyerrflag;
+
+	yystate = 0;
+	yychar = -1;
+	yynerrs = 0;
+	yyerrflag = 0;
+	yyp = &yys[-1];
+	goto yystack;
+
+ret0:
+	yyn = 0;
+	goto ret;
+
+ret1:
+	yyn = 1;
+	goto ret;
+
+ret:
+	yylval = save1;
+	yyval = save2;
+	yynerrs = save3;
+	yyerrflag = save4;
+	return yyn;
+
+yystack:
+	/* put a state and value onto the stack */
+	if(yydebug >= 4)
+		fprint(2, "char %s in %s", yytokname(yychar), yystatname(yystate));
+
+	yyp++;
+	if(yyp >= &yys[YYMAXDEPTH]) {
+		yyerror("yacc stack overflow");
+		goto ret1;
+	}
+	yyp->yys = yystate;
+	yyp->yyv = yyval;
+
+yynewstate:
+	yyn = yypact[yystate];
+	if(yyn <= YYFLAG)
+		goto yydefault; /* simple state */
+	if(yychar < 0)
+		yychar = yylex1();
+	yyn += yychar;
+	if(yyn < 0 || yyn >= YYLAST)
+		goto yydefault;
+	yyn = yyact[yyn];
+	if(yychk[yyn] == yychar) { /* valid shift */
+		yychar = -1;
+		yyval = yylval;
+		yystate = yyn;
+		if(yyerrflag > 0)
+			yyerrflag--;
+		goto yystack;
+	}
+
+yydefault:
+	/* default state action */
+	yyn = yydef[yystate];
+	if(yyn == -2) {
+		if(yychar < 0)
+			yychar = yylex1();
+
+		/* look through exception table */
+		for(yyxi=yyexca;; yyxi+=2)
+			if(yyxi[0] == -1 && yyxi[1] == yystate)
+				break;
+		for(yyxi += 2;; yyxi += 2) {
+			yyn = yyxi[0];
+			if(yyn < 0 || yyn == yychar)
+				break;
+		}
+		yyn = yyxi[1];
+		if(yyn < 0)
+			goto ret0;
+	}
+	if(yyn == 0) {
+		/* error ... attempt to resume parsing */
+		switch(yyerrflag) {
+		case 0:   /* brand new error */
+			yyerror("syntax error");
+			yynerrs++;
+			if(yydebug >= 1) {
+				fprint(2, "%s", yystatname(yystate));
+				fprint(2, "saw %s\n", yytokname(yychar));
+			}
+
+		case 1:
+		case 2: /* incompletely recovered error ... try again */
+			yyerrflag = 3;
+
+			/* find a state where "error" is a legal shift action */
+			while(yyp >= yys) {
+				yyn = yypact[yyp->yys] + YYERRCODE;
+				if(yyn >= 0 && yyn < YYLAST) {
+					yystate = yyact[yyn];  /* simulate a shift of "error" */
+					if(yychk[yystate] == YYERRCODE)
+						goto yystack;
+				}
+
+				/* the current yyp has no shift onn "error", pop stack */
+				if(yydebug >= 2)
+					fprint(2, "error recovery pops state %d, uncovers %d\n",
+						yyp->yys, (yyp-1)->yys );
+				yyp--;
+			}
+			/* there is no state on the stack with an error shift ... abort */
+			goto ret1;
+
+		case 3:  /* no shift yet; clobber input char */
+			if(yydebug >= 2)
+				fprint(2, "error recovery discards %s\n", yytokname(yychar));
+			if(yychar == YYEOFCODE)
+				goto ret1;
+			yychar = -1;
+			goto yynewstate;   /* try again in the same state */
+		}
+	}
+
+	/* reduction by production yyn */
+	if(yydebug >= 2)
+		fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
+
+	yypt = yyp;
+	yyp -= yyr2[yyn];
+	yyval = (yyp+1)->yyv;
+	yym = yyn;
+
+	/* consult goto table to find next state */
+	yyn = yyr1[yyn];
+	yyg = yypgo[yyn];
+	yyj = yyg + yyp->yys + 1;
+
+	if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
+		yystate = yyact[yyg];
+	switch(yym) {
+		
+case 3:
+#line	40	"a.y"
+{
+		if(yypt[-1].yyv.sym->value != pc)
+			yyerror("redeclaration of %s", yypt[-1].yyv.sym->name);
+		yypt[-1].yyv.sym->value = pc;
+	} break;
+case 5:
+#line	47	"a.y"
+{
+		yypt[-1].yyv.sym->type = LLAB;
+		yypt[-1].yyv.sym->value = pc;
+	} break;
+case 10:
+#line	58	"a.y"
+{
+		yypt[-2].yyv.sym->type = LVAR;
+		yypt[-2].yyv.sym->value = yypt[-0].yyv.lval;
+	} break;
+case 11:
+#line	63	"a.y"
+{
+		if(yypt[-2].yyv.sym->value != yypt[-0].yyv.lval)
+			yyerror("redeclaration of %s", yypt[-2].yyv.sym->name);
+		yypt[-2].yyv.sym->value = yypt[-0].yyv.lval;
+	} break;
+case 12:
+#line	68	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 13:
+#line	69	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 14:
+#line	70	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 15:
+#line	71	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 16:
+#line	72	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 17:
+#line	73	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 18:
+#line	74	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 19:
+#line	75	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 20:
+#line	76	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 21:
+#line	77	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 22:
+#line	78	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 23:
+#line	79	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 24:
+#line	80	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 25:
+#line	81	"a.y"
+{ outcode(yypt[-1].yyv.lval, &yypt[-0].yyv.gen2); } break;
+case 26:
+#line	84	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = nullgen;
+	} break;
+case 27:
+#line	89	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = nullgen;
+	} break;
+case 28:
+#line	96	"a.y"
+{
+		yyval.gen2.from = yypt[-2].yyv.gen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 29:
+#line	103	"a.y"
+{
+		yyval.gen2.from = yypt[-2].yyv.gen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 30:
+#line	110	"a.y"
+{
+		yyval.gen2.from = yypt[-1].yyv.gen;
+		yyval.gen2.to = nullgen;
+	} break;
+case 31:
+#line	115	"a.y"
+{
+		yyval.gen2.from = yypt[-0].yyv.gen;
+		yyval.gen2.to = nullgen;
+	} break;
+case 32:
+#line	122	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 33:
+#line	127	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 34:
+#line	134	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 35:
+#line	139	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 36:
+#line	146	"a.y"
+{
+		yyval.gen2.from = yypt[-4].yyv.gen;
+		yyval.gen2.from.scale = yypt[-2].yyv.lval;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 37:
+#line	154	"a.y"
+{
+		yyval.gen2.from = yypt[-2].yyv.gen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 38:
+#line	159	"a.y"
+{
+		yyval.gen2.from = yypt[-4].yyv.gen;
+		yyval.gen2.from.scale = yypt[-2].yyv.lval;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 39:
+#line	167	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 40:
+#line	172	"a.y"
+{
+		yyval.gen2.from = nullgen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 43:
+#line	183	"a.y"
+{
+		yyval.gen2.from = yypt[-2].yyv.gen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 44:
+#line	188	"a.y"
+{
+		yyval.gen2.from = yypt[-4].yyv.gen;
+		yyval.gen2.to = yypt[-2].yyv.gen;
+		if(yyval.gen2.from.index != D_NONE)
+			yyerror("dp shift with lhs index");
+		yyval.gen2.from.index = yypt[-0].yyv.lval;
+	} break;
+case 45:
+#line	198	"a.y"
+{
+		yyval.gen2.from = yypt[-2].yyv.gen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 46:
+#line	203	"a.y"
+{
+		yyval.gen2.from = yypt[-4].yyv.gen;
+		yyval.gen2.to = yypt[-2].yyv.gen;
+		if(yyval.gen2.to.index != D_NONE)
+			yyerror("dp move with lhs index");
+		yyval.gen2.to.index = yypt[-0].yyv.lval;
+	} break;
+case 47:
+#line	213	"a.y"
+{
+		yyval.gen2.from = yypt[-1].yyv.gen;
+		yyval.gen2.to = nullgen;
+	} break;
+case 48:
+#line	218	"a.y"
+{
+		yyval.gen2.from = yypt[-0].yyv.gen;
+		yyval.gen2.to = nullgen;
+	} break;
+case 49:
+#line	223	"a.y"
+{
+		yyval.gen2.from = yypt[-2].yyv.gen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 50:
+#line	230	"a.y"
+{
+		yyval.gen2.from = yypt[-2].yyv.gen;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 51:
+#line	235	"a.y"
+{
+		yyval.gen2.from = yypt[-4].yyv.gen;
+		yyval.gen2.from.scale = yypt[-2].yyv.lval;
+		yyval.gen2.to = yypt[-0].yyv.gen;
+	} break;
+case 56:
+#line	249	"a.y"
+{
+		yyval.gen = yypt[-0].yyv.gen;
+	} break;
+case 57:
+#line	253	"a.y"
+{
+		yyval.gen = yypt[-0].yyv.gen;
+	} break;
+case 63:
+#line	266	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_BRANCH;
+		yyval.gen.offset = yypt[-3].yyv.lval + pc;
+	} break;
+case 64:
+#line	272	"a.y"
+{
+		yyval.gen = nullgen;
+		if(pass == 2)
+			yyerror("undefined label: %s", yypt[-1].yyv.sym->name);
+		yyval.gen.type = D_BRANCH;
+		yyval.gen.sym = yypt[-1].yyv.sym;
+		yyval.gen.offset = yypt[-0].yyv.lval;
+	} break;
+case 65:
+#line	281	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_BRANCH;
+		yyval.gen.sym = yypt[-1].yyv.sym;
+		yyval.gen.offset = yypt[-1].yyv.sym->value + yypt[-0].yyv.lval;
+	} break;
+case 66:
+#line	290	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = yypt[-0].yyv.lval;
+	} break;
+case 67:
+#line	295	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = yypt[-0].yyv.lval;
+	} break;
+case 68:
+#line	300	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = yypt[-0].yyv.lval;
+	} break;
+case 69:
+#line	305	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_SP;
+	} break;
+case 70:
+#line	310	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = yypt[-0].yyv.lval;
+	} break;
+case 71:
+#line	317	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_CONST;
+		yyval.gen.offset = yypt[-0].yyv.lval;
+	} break;
+case 72:
+#line	323	"a.y"
+{
+		yyval.gen = yypt[-0].yyv.gen;
+		yyval.gen.index = yypt[-0].yyv.gen.type;
+		yyval.gen.type = D_ADDR;
+		/*
+		if($2.type == D_AUTO || $2.type == D_PARAM)
+			yyerror("constant cannot be automatic: %s",
+				$2.sym->name);
+		 */
+	} break;
+case 73:
+#line	334	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_SCONST;
+		memcpy(yyval.gen.sval, yypt[-0].yyv.sval, sizeof(yyval.gen.sval));
+	} break;
+case 74:
+#line	340	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_FCONST;
+		yyval.gen.dval = yypt[-0].yyv.dval;
+	} break;
+case 75:
+#line	346	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_FCONST;
+		yyval.gen.dval = yypt[-1].yyv.dval;
+	} break;
+case 76:
+#line	352	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_FCONST;
+		yyval.gen.dval = -yypt[-0].yyv.dval;
+	} break;
+case 77:
+#line	360	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_CONST2;
+		yyval.gen.offset = yypt[-0].yyv.con2.v1;
+		yyval.gen.offset2 = yypt[-0].yyv.con2.v2;
+	} break;
+case 78:
+#line	369	"a.y"
+{
+		yyval.con2.v1 = yypt[-0].yyv.lval;
+		yyval.con2.v2 = 0;
+	} break;
+case 79:
+#line	374	"a.y"
+{
+		yyval.con2.v1 = -yypt[-0].yyv.lval;
+		yyval.con2.v2 = 0;
+	} break;
+case 80:
+#line	379	"a.y"
+{
+		yyval.con2.v1 = yypt[-2].yyv.lval;
+		yyval.con2.v2 = yypt[-0].yyv.lval;
+	} break;
+case 81:
+#line	384	"a.y"
+{
+		yyval.con2.v1 = -yypt[-2].yyv.lval;
+		yyval.con2.v2 = yypt[-0].yyv.lval;
+	} break;
+case 84:
+#line	395	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+D_NONE;
+		yyval.gen.offset = yypt[-0].yyv.lval;
+	} break;
+case 85:
+#line	401	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+yypt[-1].yyv.lval;
+		yyval.gen.offset = yypt[-3].yyv.lval;
+	} break;
+case 86:
+#line	407	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+D_SP;
+		yyval.gen.offset = yypt[-3].yyv.lval;
+	} break;
+case 87:
+#line	413	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+D_NONE;
+		yyval.gen.offset = yypt[-5].yyv.lval;
+		yyval.gen.index = yypt[-3].yyv.lval;
+		yyval.gen.scale = yypt[-1].yyv.lval;
+		checkscale(yyval.gen.scale);
+	} break;
+case 88:
+#line	422	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+yypt[-6].yyv.lval;
+		yyval.gen.offset = yypt[-8].yyv.lval;
+		yyval.gen.index = yypt[-3].yyv.lval;
+		yyval.gen.scale = yypt[-1].yyv.lval;
+		checkscale(yyval.gen.scale);
+	} break;
+case 89:
+#line	431	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+yypt[-1].yyv.lval;
+	} break;
+case 90:
+#line	436	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+D_SP;
+	} break;
+case 91:
+#line	441	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+yypt[-1].yyv.lval;
+		yyval.gen.offset = yypt[-3].yyv.lval;
+	} break;
+case 92:
+#line	447	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+D_NONE;
+		yyval.gen.index = yypt[-3].yyv.lval;
+		yyval.gen.scale = yypt[-1].yyv.lval;
+		checkscale(yyval.gen.scale);
+	} break;
+case 93:
+#line	455	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_INDIR+yypt[-6].yyv.lval;
+		yyval.gen.index = yypt[-3].yyv.lval;
+		yyval.gen.scale = yypt[-1].yyv.lval;
+		checkscale(yyval.gen.scale);
+	} break;
+case 94:
+#line	465	"a.y"
+{
+		yyval.gen = yypt[-0].yyv.gen;
+	} break;
+case 95:
+#line	469	"a.y"
+{
+		yyval.gen = yypt[-5].yyv.gen;
+		yyval.gen.index = yypt[-3].yyv.lval;
+		yyval.gen.scale = yypt[-1].yyv.lval;
+		checkscale(yyval.gen.scale);
+	} break;
+case 96:
+#line	478	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = yypt[-1].yyv.lval;
+		yyval.gen.sym = yypt[-4].yyv.sym;
+		yyval.gen.offset = yypt[-3].yyv.lval;
+	} break;
+case 97:
+#line	485	"a.y"
+{
+		yyval.gen = nullgen;
+		yyval.gen.type = D_STATIC;
+		yyval.gen.sym = yypt[-6].yyv.sym;
+		yyval.gen.offset = yypt[-3].yyv.lval;
+	} break;
+case 98:
+#line	493	"a.y"
+{
+		yyval.lval = 0;
+	} break;
+case 99:
+#line	497	"a.y"
+{
+		yyval.lval = yypt[-0].yyv.lval;
+	} break;
+case 100:
+#line	501	"a.y"
+{
+		yyval.lval = -yypt[-0].yyv.lval;
+	} break;
+case 102:
+#line	508	"a.y"
+{
+		yyval.lval = D_AUTO;
+	} break;
+case 105:
+#line	516	"a.y"
+{
+		yyval.lval = yypt[-0].yyv.sym->value;
+	} break;
+case 106:
+#line	520	"a.y"
+{
+		yyval.lval = -yypt[-0].yyv.lval;
+	} break;
+case 107:
+#line	524	"a.y"
+{
+		yyval.lval = yypt[-0].yyv.lval;
+	} break;
+case 108:
+#line	528	"a.y"
+{
+		yyval.lval = ~yypt[-0].yyv.lval;
+	} break;
+case 109:
+#line	532	"a.y"
+{
+		yyval.lval = yypt[-1].yyv.lval;
+	} break;
+case 111:
+#line	539	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval + yypt[-0].yyv.lval;
+	} break;
+case 112:
+#line	543	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval - yypt[-0].yyv.lval;
+	} break;
+case 113:
+#line	547	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval * yypt[-0].yyv.lval;
+	} break;
+case 114:
+#line	551	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval / yypt[-0].yyv.lval;
+	} break;
+case 115:
+#line	555	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval % yypt[-0].yyv.lval;
+	} break;
+case 116:
+#line	559	"a.y"
+{
+		yyval.lval = yypt[-3].yyv.lval << yypt[-0].yyv.lval;
+	} break;
+case 117:
+#line	563	"a.y"
+{
+		yyval.lval = yypt[-3].yyv.lval >> yypt[-0].yyv.lval;
+	} break;
+case 118:
+#line	567	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval & yypt[-0].yyv.lval;
+	} break;
+case 119:
+#line	571	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval ^ yypt[-0].yyv.lval;
+	} break;
+case 120:
+#line	575	"a.y"
+{
+		yyval.lval = yypt[-2].yyv.lval | yypt[-0].yyv.lval;
+	} break;
+	}
+	goto yystack;  /* stack new state and value */
+}
diff --git a/utils/8a/y.tab.h b/utils/8a/y.tab.h
new file mode 100644
index 0000000..0e910a1
--- /dev/null
+++ b/utils/8a/y.tab.h
@@ -0,0 +1,42 @@
+
+typedef union 	{
+	Sym	*sym;
+	long	lval;
+	struct {
+		long v1;
+		long v2;
+	} con2;
+	double	dval;
+	char	sval[8];
+	Gen	gen;
+	Gen2	gen2;
+}	YYSTYPE;
+extern	YYSTYPE	yylval;
+#define	LTYPE0	57346
+#define	LTYPE1	57347
+#define	LTYPE2	57348
+#define	LTYPE3	57349
+#define	LTYPE4	57350
+#define	LTYPEC	57351
+#define	LTYPED	57352
+#define	LTYPEN	57353
+#define	LTYPER	57354
+#define	LTYPET	57355
+#define	LTYPES	57356
+#define	LTYPEM	57357
+#define	LTYPEI	57358
+#define	LTYPEG	57359
+#define	LCONST	57360
+#define	LFP	57361
+#define	LPC	57362
+#define	LSB	57363
+#define	LBREG	57364
+#define	LLREG	57365
+#define	LSREG	57366
+#define	LFREG	57367
+#define	LFCONST	57368
+#define	LSCONST	57369
+#define	LSP	57370
+#define	LNAME	57371
+#define	LLAB	57372
+#define	LVAR	57373