Quellcode durchsuchen

Initial revision

em vor 40 Jahren
Ursprung
Commit
315806b282
5 geänderte Dateien mit 4421 neuen und 0 gelöschten Zeilen
  1. 104 0
      lib/vax4/sedf
  2. 8 0
      mach/vax4/cg/READ_ME
  3. 270 0
      mach/vax4/cg/mach.c
  4. 23 0
      mach/vax4/cg/mach.h
  5. 4016 0
      mach/vax4/cg/table

+ 104 - 0
lib/vax4/sedf

@@ -0,0 +1,104 @@
+# $Header$
+/movab/ {
+s/movab	1(\(.*\)),\1$/incl	\1/
+s/movab	-1(\(.*\)),\1$/decl	\1/
+s/movab	\([0-9]*\)(\(.*\)),\2$/addl2	$\1,\2/
+s/movab	-\([0-9]*\)(\(.*\)),\2$/subl2	$\1,\2/
+s/movab	0(\(.*\)) \[\(.*\)\],\1$/addl2	\2,\1/
+s/movab	0(\(.*\)) \[\(.*\)\],\2$/addl2	\1,\2/
+}
+/$0/ {
+s/movz[bw]\([wl]\)	$0,/clr\1	/
+s/mov\([bwl]\)	$0,/clr\1	/
+s/cvt[bw]\([wl]\)	$0,/clr\1	/
+}
+/add/ {
+s/\(add[fdlw]\)3	\(.*\),\(.*\),\3$/\12	\2,\3/
+s/\(add[fdlw]\)3	\(.*\),\(.*\),\2$/\12	\3,\2/
+s/add\([wl]\)2	\$-\([0-9]*\),/sub\12	$\2,/
+s/add\([wl]\)3	\$-\([0-9]*\),/sub\13	$\2,/
+s/add\([wl]\)3	\(.*\),\$-\([0-9]*\),/sub\13	$\3,\2,/
+}
+/mul/ {
+s/\(mul[fdlw]\)3	\(.*\),\(.*\),\3$/\12	\2,\3/
+s/\(mul[fdlw]\)3	\(.*\),\(.*\),\2$/\12	\3,\2/
+}
+/sub/ {
+s/\(sub[fdlw]\)3	\(.*\),\(.*\),\3$/\12	\2,\3/
+s/sub\([wl]\)2	\$-\([0-9]*\),/add\12	$\2,/
+s/sub\([wl]\)3	\$-\([0-9]*\),/add\13	$\2,/
+}
+/div/s/\(div[fdlw]\)3	\(.*\),\(.*\),\3$/\12	\2,\3/
+/bi/s/\(bi[cs][lw]\)3	\(.*\),\(.*\),\3$/\12	\2,\3/
+/bis/s/\(bis[lw]\)3	\(.*\),\(.*\),\2$/\12	\3,\2/
+/xor/ {
+s/\(xor[lw]\)3	\(.*\),\(.*\),\3$/\12	\2,\3/
+s/\(xor[lw]\)3	\(.*\),\(.*\),\2$/\12	\3,\2/
+}
+/$1/ {
+s/add\([wl]\)2	\$1,/inc\1	/
+s/sub\([wl]\)2	\$1,/dec\1	/
+}
+/$-1/ {
+s/add\([wl]\)2	\$-1,/dec\1	/
+s/sub\([wl]\)2	\$-1,/inc\1	/
+}
+/cmp[bwl].*$0/ {
+N
+s/cmp\([bwl]\)	\(.*\),$0$/tst\1	\2/
+s/cmp\([bwl]\)	$0,\(.*\)\njneq/tst\1	\2\
+jneq/
+s/cmp\([bwl]\)	$0,\(.*\)\njeql/tst\1	\2\
+jeql/
+s/cmp\([bwl]\)	$0,\(.*\)\njgtr/tst\1	\2\
+jlss/
+s/cmp\([bwl]\)	$0,\(.*\)\njlss/tst\1	\2\
+jgtr/
+s/cmp\([bwl]\)	$0,\(.*\)\njgeq/tst\1	\2\
+jleq/
+s/cmp\([bwl]\)	$0,\(.*\)\njleq/tst\1	\2\
+jgeq/
+P
+D
+}
+/(sp)+/ {
+N
+s/movl	(sp)+,\(.*\)\npushl	\1$/movl	(sp),\1/
+s/tst[wl]	(sp)+\nmovl	fp,sp$/movl	fp,sp/
+s/tst\([wl]\)	(sp)+\nmov\1	\(.*\),-(sp)/mov\1	\2,(sp)/
+s/tst\([wl]\)	(sp)+\nclr\1	-(sp)/clr\1	(sp)/
+s/tst\([wl]\)	(sp)+\nmovzb\1	\(.*\),-(sp)/movzb\1	\2,(sp)/
+s/tst\([wl]\)	(sp)+\ncvtb\1	\(.*\),-(sp)/cvtb\1	\2,(sp)/
+s/tst\([wl]\)	(sp)+\ntst\1	\(.*\)$/mov\1	\2,(sp)+/
+s/tstl	(sp)+\npushl	\(.*\)$/movl	\1,(sp)/
+s/tstl	(sp)+\npusha\([bwlq]\)	\(.*\)$/mova\1	\2,(sp)/
+P
+D
+}
+/^addl2	.*,sp/ {
+N
+s/addl2	.*,sp\nmovl	fp,sp$/movl	fp,sp/
+s/^addl2	$6,sp\nmovw	\(.*\),-(sp)/tstl	(sp)+\
+movw	\1,(sp)/
+s/^addl2	$6,sp\nclrw	-(sp)/tstl	(sp)+\
+clrw	(sp)/
+s/^addl2	$8,sp\nmovq	\(.*\),-(sp)/movq	\1,(sp)/
+P
+D
+}
+/clrw	-(sp)/ {
+N
+s/clrw	-(sp)\nmovw	\($[0-9]*\),-(sp)/pushl	\1/
+s/clrw	-(sp)\nmnegw	$\([0-9]*\),-(sp)/movzwl	$-\1,-(sp)/
+s/clrw	-(sp)\nmovw	\(.*\),-(sp)/movzwl	\1,-(sp)/
+s/clrw	-(sp)\ncvtbw	\(\$[0-9]*\),-(sp)/pushl	\1/
+s/clrw	-(sp)\ncvtbw	\(\$.*\),-(sp)/movzwl	\1,-(sp)/
+P
+D
+}
+/mov/ {
+N
+s/mov\([wl]\)	\(.*\),\(.*\)\ntst\1	\3$/mov\1	\2,\3/
+P
+D
+}

+ 8 - 0
mach/vax4/cg/READ_ME

@@ -0,0 +1,8 @@
+--------- $Header$ --------
+The file "table" is too large. The "cgg" program cannot generate
+"tables.h" and "tables.c" on a PDP 11/44.
+Therefore the distribution includes two files "tables1.c" and "tables1.h",
+which you can copy to "tables.c" and "tables.h".
+Make sure "tables.c" and "tables.h" are newer than "table",
+before trying again. They also must be newer than the "cgg" program
+(../../../lib/cgg).

+ 270 - 0
mach/vax4/cg/mach.c

@@ -0,0 +1,270 @@
+#ifndef NORCSID
+static char rcsid[] = "$Header$";
+#endif
+/*
+ * (c) copyright 1983 by the Vrije Universiteit, Amsterdam, The Netherlands.
+ *
+ *          This product is part of the Amsterdam Compiler Kit.
+ *
+ * Permission to use, sell, duplicate or disclose this software must be
+ * obtained in writing. Requests for such permissions may be sent to
+ *
+ *      Dr. Andrew S. Tanenbaum
+ *      Wiskundig Seminarium
+ *      Vrije Universiteit
+ *      Postbox 7161
+ *      1007 MC Amsterdam
+ *      The Netherlands
+ *
+ */
+
+/* Machine dependent back end routines for the VAX using 4-byte words
+ */
+
+con_part(sz,w) register sz; word w; {
+
+	/* Byte order: |  3  |  2  |  1  |  0  | */
+
+	/* Align new bytes on boundary of its on size.  */
+	while (part_size % sz) part_size++;
+
+	if (part_size == EM_WSIZE)
+		part_flush();
+	if (sz == 1 || sz == 2) {
+		/* Smaller than a machineword. */
+		w &= (sz == 1 ? 0xFF : 0xFFFF);
+		w <<= 8 * part_size;
+		part_word |= w;
+	} else {
+		assert(sz == 4);
+		part_word = w;
+	}
+	part_size += sz;
+} /* con_part */
+
+con_mult(sz) word sz; {
+
+	if (sz != 4)
+		fatal("bad icon/ucon size");
+	fprintf(codefile,".long\t%s\n",str);
+}
+
+mes(mesno) word mesno ; {
+	while (getarg(any_ptyp) != sp_cend );
+}
+
+con_float() {
+
+	/* Insert a dot at the right position, if it is not present,
+	 * to make the floating point constant acceptable to the assembler.
+	 */
+	register char *	c;
+	extern char *	index();
+
+	if (argval != 4 && argval != 8)
+		fatal("bad fcon size");
+	if (argval == 8)
+		fprintf(codefile,".double\t0d");
+	else	fprintf(codefile,".float\t0f");
+
+	if (index(str,'.') != (char *) 0) {
+		fprintf(codefile,"%s\n",str);
+	
+	/* There must be a dot after the `e' or - if the `e' is not present -
+	 * at the end.
+	 */
+	} else if ((c = index(str,'e')) != (char *) 0) {
+		*c++ = '\0';
+		fprintf(codefile,"%s.e%s\n",str,c--);
+		*c = 'e';
+	} else	fprintf(codefile,"%s.\n",str);
+} /* con_float */
+
+#ifndef REGVARS
+prolog(nlocals) full nlocals; {
+
+	fprintf(codefile,"\tpushl\tfp\n\tmovl\tsp,fp\n");
+	if (nlocals == 0)
+		return;
+	if (nlocals == 4)
+		fprintf(codefile,"\tclrl\t-(sp)\n");
+	else if (nlocals == 8)
+		fprintf(codefile,"\tclrq\t-(sp)\n");
+	else
+		fprintf(codefile,"\tsubl2\t$%ld,sp\n",nlocals);
+}
+
+#endif REGVARS
+
+char    *segname[] = {
+	".text",	/* SEGTXT */
+	".data",	/* SEGCON */
+	".data",	/* SEGROM */
+	".data"		/* SEGBSS */
+};
+
+#ifdef REGVARS
+int		EM_BSIZE;	/* Difference between AB and LB. */
+static int	nlocals;	/* Number of local variables. */
+
+#define NR_REG		8	/* Number of registers. */
+#define FIRST_REG	4
+#define LAST_REG	(FIRST_REG + NR_REG - 1)
+
+prolog(n) { /* Save number of locals. */
+	nlocals = n;
+}
+
+/*
+ * Structure to store information about the registers to be stored.
+ */
+static struct s_reg {
+	char *	sr_str;	/* Name of register used.	*/
+	long	sr_off;	/* Offset from LB.		*/
+	int	sr_size;/* Size in bytes.		*/
+} a_reg[NR_REG + 1], *p_reg;
+
+i_regsave() { /* Initialize saving of registers. */
+	EM_BSIZE = 0;
+	p_reg = a_reg;
+}
+
+regsave(str, off, size) char * str; long off; int size; {
+
+	/* Called for each register to be saved. */
+
+	p_reg->sr_str = str;
+	p_reg->sr_off = off;
+	(p_reg++)->sr_size = size;
+	fprintf(codefile,
+		"\t# Local %ld, size %d, to register %s\n",
+		off, size, str
+	       );
+}
+
+f_regsave() {
+
+	register struct s_reg *	p;
+	register int	mask;
+	register int	i;
+	register int	count;
+
+	mask = 0;
+	count = p_reg - a_reg;
+	for (p = a_reg; p < p_reg; p++) {
+		/* For each register to be saved, set a bit in the
+		 * mask corresponding to its number.
+		 */
+		i = atoi(p->sr_str + 1);
+		if (p->sr_size <= 4)
+			mask |= (1 << i);
+		else {
+			mask |= (3 << i);
+			count++;
+		}
+	}
+
+	/* Generate code to save registers. */
+	if (count > 2)
+		fprintf(codefile, "pushr\t$%d\n", mask);
+	else
+		for (i = FIRST_REG; i <= LAST_REG; i++) {
+			/* For all registers that can be used,
+			 * see if it must be saved, and do that as cheap
+			 * as possible.
+			 */
+			if (((mask >> i) & 03) == 03) {
+				fprintf(codefile, "movq\tr%d,-(sp)\n",i);
+				break;
+			} else if ((1 << i) & mask) {
+				if (count == 1)
+					fprintf(codefile,"pushl\tr%d\n",i);
+				else
+					fprintf(codefile,"pushr\t$%d\n",mask);
+				break;
+			}
+		}
+
+	/* Save a word indicating which registers were saved.
+	 * The count uniquely specifies which registers were saved, because
+	 * registers are always allocated consecutively within a class,
+	 * starting from FIRST_REG. I only have one class.
+	 */
+	fprintf(codefile, "pushl\t$%d\n", count);
+
+	/* Compute AB - LB. */
+	EM_BSIZE = 4 * count + 12;
+
+	/* Now finish the procedure prolog. */
+	fprintf(codefile, "pushl\tfp\nmovl\tsp,fp\n");
+
+	/* Emit code to initialize parameters in registers. */
+	for (p = a_reg; p < p_reg; p++) {
+		if (p->sr_off >= 0) {
+			if (p->sr_size == 4) {
+				fprintf(codefile,
+					"movl\t%ld(fp),%s\n",
+					p->sr_off + EM_BSIZE, p->sr_str
+				       );
+			} else if (p->sr_size == 8) {
+				fprintf(codefile,
+					"movq\t%ld(fp),%s\n",
+					p->sr_off + EM_BSIZE, p->sr_str
+				       );
+			}
+		}
+	}
+
+	/* Generate room for locals. */
+	if (nlocals == 0)
+		return;
+	if (nlocals == 4)
+		fprintf(codefile,"clrl\t-(sp)\n");
+	else if (nlocals == 8)
+		fprintf(codefile,"clrq\t-(sp)\n");
+	else
+		fprintf(codefile,"subl2\t$%ld,sp\n",nlocals);
+
+} /* f_regsave */
+
+regreturn() {
+
+	fprintf(codefile, "jmp\t.return\n");
+} /* regreturn */
+
+regscore(off, size, typ, score, totyp) long off; {
+
+	register int	i;
+
+	i = score;	/* Local/parameter is used score times. */
+	
+	/* If the offset doesn't fit in a byte, word-offset is used,
+	 * which is one byte more expensive.
+	 */
+	if (off > 109 || off < -128) i *= 2;	/* Word offset. */
+	
+	/* 109: guestimate. We don't know AB -LB yet.
+	 * 109 is the number if there are two registervariables.
+	 */
+
+	/* Compute cost of initialization for parameters. */
+	if (off > 109)
+		i -= 5;
+	else if (off >= 0)
+		i -= 4;
+
+	if (typ == reg_pointer)
+		i += score;	/* Sometimes saves an instruction. */
+	else if (typ == reg_loop)
+		i += 5;
+
+	i -= 2;	/* Cost of save. */
+
+	/* Actually the first registers are more expensive, but then
+	 * the following registers are cheaper.
+	 */
+
+	return (i);
+} /* regscore */
+
+#endif REGVARS

+ 23 - 0
mach/vax4/cg/mach.h

@@ -0,0 +1,23 @@
+/* $Header$ */
+#define ex_ap(x)	fprintf(codefile,".globl\t%s\n",x)
+#define in_ap(x)	/* nothing */
+
+#define newilb(x)	fprintf(codefile,"%s:\n",x)
+#define newdlb(x)	fprintf(codefile,"%s:\n",x)
+#define	dlbdlb(s1,s2)	fprintf(codefile,"%s = %s\n",s1,s2)
+#define newlbss(x,f)	fprintf(codefile,"%s:.space\t%ld\n",x,f)
+
+#define cst_fmt		"$%ld"
+#define	off_fmt		"%ld"
+#define ilb_fmt		"I%03x%04x"
+#define dlb_fmt		"_%d"
+#define	hol_fmt		"hol%d"
+
+#define hol_off		"%ld+hol%d"
+
+#define con_cst(w)	fprintf(codefile,".long\t%ld\n",w)
+#define con_ilb(x)	fprintf(codefile,".long\t%s\n",x)
+#define con_dlb(x)	fprintf(codefile,".long\t%s\n",x)
+
+#define id_first	'_'
+#define BSS_INIT	0

+ 4016 - 0
mach/vax4/cg/table

@@ -0,0 +1,4016 @@
+"$Header$"
+#define SL 8
+#define SSL "8"
+#define DL 0
+#define SDL ""
+
+#define LOCLABS		/* define if target assembler recognizes local labels */
+#define REGVARS		/* define for register variables */
+
+/*#define DORCK		/* define if you want RCK */
+/*#define FLOAT4	/* define if you want better 4-byte FP arithmetic */
+
+EM_PSIZE = 4
+EM_WSIZE = 4
+#ifndef REGVARS
+EM_BSIZE = SL
+#endif REGVARS
+
+#define NC nocoercions :
+
+/****************************************************************
+ * VAX 11 Back end table.					*
+ * Author : Ceriel J.H. Jacobs, Duk Bekema			*
+ *								*
+ * Wordsize = 4 bytes						*
+ * Pointersize = 4 bytes					*
+ *								*
+ * There is hardly any instruction timing information available *
+ * for the DEC-VAX machines. Timing of addressing modes was done*
+ * by counting the memory references and multiplying them by	*
+ * 3.	300 nanosec seems to be a typical memory reference time.*
+ * However, the VAX can be much faster, if the "cache hit rate" *
+ * is high.							*
+ * Assumed hardware : VAX-11/7?0 with Floating Point Acc.	*
+ ****************************************************************/
+
+REGISTERS:
+LB	= ("fp",4),LocaLBase.
+R0	= ("r0",4),REG,RRET.
+R1	= ("r1",4),REG.
+R2	= ("r2",4),REG.
+R3	= ("r3",4),REG.
+#ifdef REGVARS
+R4	= ("r4",4) regvar,RREG.
+R5	= ("r5",4) regvar,RREG.
+R6	= ("r6",4) regvar,RREG.
+R7	= ("r7",4) regvar,RREG.
+R8	= ("r8",4) regvar,RREG.
+R9	= ("r9",4) regvar,RREG.
+RA	= ("r10",4) regvar,RREG.
+RB	= ("r11",4) regvar,RREG.
+#else REGVARS
+R4	= ("r4",4),REG.
+R5	= ("r5",4),REG.
+R6	= ("r6",4),REG.
+R7	= ("r7",4),REG.
+R8	= ("r8",4),REG.
+R9	= ("r9",4),REG.
+RA	= ("r10",4),REG.
+RB	= ("r11",4),REG.
+#endif REGVARS
+QR0	= ("r0",8,R0,R1),QREG,QRET.
+QR2	= ("r2",8,R2,R3),QREG.
+QR4	= ("r4",8,R4,R5),QREG.
+QR6	= ("r6",8,R6,R7),QREG.
+QR8	= ("r8",8,R8,R9),QREG.
+QRA	= ("r10",8,RA,RB),QREG.
+QR1	= ("r1",8,R1,R2),QREG.
+QR3	= ("r3",8,R3,R4),QREG.
+QR5	= ("r5",8,R5,R6),QREG.
+QR7	= ("r7",8,R7,R8),QREG.
+QR9	= ("r9",8,R9,RA),QREG.
+
+TOKENS:
+
+/* First some EM machine tokens */
+CONST1 =	{INT num;}		4 cost=(4,3)  "$%[num]"
+CONST2 =	{INT num;}		4 cost=(4,3)  "$%[num]"
+CONST4 =	{INT num;}		4 cost=(4,3)  "$%[num]"
+CONST8 =	{STRING ind;}		8 cost=(8,6)  "$%[ind]"
+FCONST8 =	{INT num;}		8 cost=(8,6)  "$0f%[num].0"
+LOCAL1 =	{INT num,size;}		4 cost=(2,6)  "%[num](fp)"
+LOCAL2 =	{INT num,size;}		4 cost=(2,6)  "%[num](fp)"
+LOCAL4 =	{INT num,size;}		4 cost=(2,6)  "%[num](fp)"
+LOCAL8 =	{INT num,size;}		8 cost=(2,6)  "%[num](fp)"
+ADDR_LOCAL =	{INT num;}		4 cost=(2,6)  "%[num](fp)"
+ADDR_EXTERNAL =	{STRING ind;}		4 cost=(4,6)  "%[ind]"
+EXTERNAL1 =	{STRING ind;}		4 cost=(4,6)  "%[ind]"
+EXTERNAL2 =	{STRING ind;}		4 cost=(4,6)  "%[ind]"
+EXTERNAL4 =	{STRING ind;}		4 cost=(4,6)  "%[ind]"
+EXTERNAL8 =	{STRING ind;}		8 cost=(4,9)  "%[ind]"
+DOUBLE =	{STRING ind;}		4 cost=(4,6)  "$%[ind]"
+/* Now tokens for the target machine */
+regdef1 =	{REGISTER reg;}		4 cost=(0,3)  "(%[reg])"
+regdef2 =	{REGISTER reg;} 	4 cost=(0,3)  "(%[reg])"
+regdef4 =	{REGISTER reg;} 	4 cost=(0,3)  "(%[reg])"
+regdef8 =	{REGISTER reg;} 	8 cost=(0,6)  "(%[reg])"
+#ifdef REGVARS
+reginc1 =	{REGISTER reg;}		4 cost=(0,3)  "(%[reg])+"
+reginc2 =	{REGISTER reg;}		4 cost=(0,3)  "(%[reg])+"
+reginc4 =	{REGISTER reg;}		4 cost=(0,3)  "(%[reg])+"
+reginc8 =	{REGISTER reg;}		8 cost=(0,6)  "(%[reg])+"
+regdec1 =	{REGISTER reg;}		4 cost=(0,3)  "-(%[reg])"
+regdec2 =	{REGISTER reg;}		4 cost=(0,3)  "-(%[reg])"
+regdec4 =	{REGISTER reg;}		4 cost=(0,3)  "-(%[reg])"
+regdec8 =	{REGISTER reg;}		8 cost=(0,6)  "-(%[reg])"
+#endif REGVARS
+displ1 =	{REGISTER reg; STRING ind;} 4 cost=(2,6)  "%[ind](%[reg])"
+displ2 =	{REGISTER reg; STRING ind;} 4 cost=(2,6)  "%[ind](%[reg])"
+displ4 =	{REGISTER reg; STRING ind;} 4 cost=(2,6)  "%[ind](%[reg])"
+displ8 =	{REGISTER reg; STRING ind;} 8 cost=(2,9)  "%[ind](%[reg])"
+displdef1 =	{REGISTER reg; STRING ind;} 4 cost=(2,9)  "*%[ind](%[reg])"
+displdef2 =	{REGISTER reg; STRING ind;} 4 cost=(2,9)  "*%[ind](%[reg])"
+displdef4 =	{REGISTER reg; STRING ind;} 4 cost=(2,9)  "*%[ind](%[reg])"
+displdef8 =	{REGISTER reg; STRING ind;} 8 cost=(2,12) "*%[ind](%[reg])"
+reldef1 =	{STRING ind;}		4 cost=(4,9)    "*%[ind]"
+reldef2 =	{STRING ind;}		4 cost=(4,9)    "*%[ind]"
+reldef4 =	{STRING ind;}		4 cost=(4,9)    "*%[ind]"
+reldef8 =	{STRING ind;}		8 cost=(4,12)   "*%[ind]"
+extind2 =	{REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
+extind4 =	{REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
+extind8 =	{REGISTER ireg; STRING ind; } 8 cost=(5,13) "%[ind] [%[ireg]]"
+displind1 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) 
+						"%[ind](%[reg]) [%[ireg]]"
+displind2 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) 
+						"%[ind](%[reg]) [%[ireg]]"
+displind4 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) 
+						"%[ind](%[reg]) [%[ireg]]"
+displind8 =	{REGISTER ireg,reg; STRING ind;} 8 cost=(3,13) 
+						"%[ind](%[reg]) [%[ireg]]"
+extdefind1 =	{REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
+extdefind2 =	{REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
+extdefind4 =	{REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
+extdefind8 =	{REGISTER ireg; STRING ind; } 8 cost=(5,16) "*%[ind] [%[ireg]]"
+displdefind1 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
+						"*%[ind](%[reg]) [%[ireg]]"
+displdefind2 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
+						"*%[ind](%[reg]) [%[ireg]]"
+displdefind4 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
+						"*%[ind](%[reg]) [%[ireg]]"
+displdefind8 =	{REGISTER ireg,reg; STRING ind;} 8 cost=(3,16)
+						"*%[ind](%[reg]) [%[ireg]]"
+
+/* Not really addressable modes */
+adispl =	{REGISTER reg; STRING ind; } 4 cost=(4,6)  "%[ind](%[reg])"
+aextind2 =	{REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
+aextind4 =	{REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
+aextind8 =	{REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
+adisplind1 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) 
+						"%[ind](%[reg]) [%[ireg]]"
+adisplind2 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) 
+						"%[ind](%[reg]) [%[ireg]]"
+adisplind4 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) 
+						"%[ind](%[reg]) [%[ireg]]"
+adisplind8 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,10) 
+						"%[ind](%[reg]) [%[ireg]]"
+aextdefind1 =	{REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
+aextdefind2 =	{REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
+aextdefind4 =	{REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
+aextdefind8 =	{REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
+adispldefind1 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
+						"*%[ind](%[reg]) [%[ireg]]"
+adispldefind2 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
+						"*%[ind](%[reg]) [%[ireg]]"
+adispldefind4 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
+						"*%[ind](%[reg]) [%[ireg]]"
+adispldefind8 =	{REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
+						"*%[ind](%[reg]) [%[ireg]]"
+
+
+TOKENEXPRESSIONS:
+CONST =		CONST1 + CONST2 + CONST4
+source1 =	regdef1 + displ1 + displdef1 +
+		EXTERNAL1 + reldef1 + CONST1 + LOCAL1
+		+ displind1 + extdefind1 + displdefind1
+#ifdef REGVARS
+		+ reginc1 + regdec1
+#endif REGVARS
+source2 =	regdef2 + displ2 + displdef2 +
+		EXTERNAL2 + reldef2 + CONST2 + LOCAL2
+		+ extind2 + displind2 + extdefind2 + displdefind2
+#ifdef REGVARS
+		+ reginc2 + regdec2
+#endif REGVARS
+source4 =	REG + regdef4 + displ4 + displdef4 + LocaLBase +
+		EXTERNAL4 + reldef4 + CONST + DOUBLE + LOCAL4
+		+ extind4 + displind4 + extdefind4 + displdefind4
+#ifdef REGVARS
+		+ RREG + reginc4 + regdec4
+#endif REGVARS
+noaddr4 =	source4 - REG - displ4 - EXTERNAL4
+source8 =	QREG + regdef8 + displ8 + displdef8 +
+		EXTERNAL8 + reldef8 + CONST8 + LOCAL8
+		+ extind8 + displind8 + extdefind8 + displdefind8
+#ifdef REGVARS
+		+ reginc8 + regdec8
+#endif REGVARS
+source1or2 =	source1 + source2
+source1or2or4 = source1or2 + source4
+source2or4 =	source2 + source4
+registers =	QREG + REG
+nonexist1 =	adispl + ADDR_EXTERNAL + ADDR_LOCAL
+aextind =	aextind2 + aextind4 + aextind8
+adisplind =	adisplind1 + adisplind2 + adisplind4 + adisplind8
+aextdefind =	aextdefind1 + aextdefind2 + aextdefind4 + aextdefind8
+adispldefind =	adispldefind1 + adispldefind2 + adispldefind4 + adispldefind8
+ind2 =		extind2 + displind2 + extdefind2 + displdefind2
+ind4 =		extind4 + displind4 + extdefind4 + displdefind4
+aind1 =		adisplind1 + aextdefind1 + adispldefind1
+aind2 =		aextind2 + adisplind2 + aextdefind2 + adispldefind2
+aind4 =		aextind4 + adisplind4 + aextdefind4 + adispldefind4
+aind8 =		aextind8 + adisplind8 + aextdefind8 + adispldefind8
+aind =		aind1 + aind2 + aind4 + aind8
+nonexist =	nonexist1 + aind
+#ifdef REGVARS
+regch4 =	reginc1 + regdec1 + reginc2 + regdec2 + reginc4 + regdec4
+regch8 =	reginc8 + regdec8
+regch =		regch4 + regch8
+#endif REGVARS
+displs =	displ1 + displ2 + displ4 + displ8
+		+ regdef1 + regdef2 + regdef4 + regdef8
+#ifdef REGVARS
+		+ regch
+#endif REGVARS
+displdefs =	displdef1 + displdef2 + displdef4 + displdef8
+EXTERNALS =	EXTERNAL1 + EXTERNAL2 + EXTERNAL4 + EXTERNAL8
+LOCALS =	LOCAL1 + LOCAL2 + LOCAL4 + LOCAL8
+reldefs =	reldef1 + reldef2 + reldef4 + reldef8
+displinds =	displind1 + displind2 + displind4 + displind8
+extinds =	extind2 + extind4 + extind8
+displdefinds =	displdefind1 + displdefind2 + displdefind4 + displdefind8
+extdefinds =	extdefind1 + extdefind2 + extdefind4 + extdefind8
+displaced =	displs + displdefs + reldefs
+		+ displinds + displdefinds + extdefinds
+externals =	EXTERNALS + displaced + extinds
+extandloc =	externals + LOCALS
+#ifdef REGVARS
+reg4 =		REG + RREG
+reg8 =		QREG
+#else REGVARS
+reg4 =		REG
+reg8 =		QREG
+#endif REGVARS
+sreg4 = 	REG * SCRATCH
+nosreg4 =	source4 - sreg4
+sreg8 = 	QREG * SCRATCH
+nosreg8 =	source8 - sreg8
+bigsource4 =	source1or2or4 + nonexist
+bigsource8 =	source8 + FCONST8
+all =		bigsource4 + bigsource8
+#ifdef REGVARS
+#define REMEXTANDLOC remove(externals) remove(LOCALS,inreg(%[num])==0)
+#define REMREG(x) remove(regch,%[reg]==regvar(x))
+#else REGVARS
+#define REMEXTANDLOC remove(extandloc)
+#endif REGVARS
+
+CODE:
+
+/********************************
+ * Group 1 : Load instructions	* 
+ ********************************/
+
+loc $1>=0 && $1<256	| |	| {CONST1, $1}				| |
+loc $1>=256 && $1<65536	| |	| {CONST2, $1}				| |
+loc		| |		| {CONST4, $1}				| |
+loc loc $1==0 && $2==0	| |	| {FCONST8, 0}				| |
+ldc		| |		| {CONST8,$1}				| |
+#ifdef REGVARS
+lol inreg($1)==2 | |		| regvar($1)				| |
+#endif REGVARS
+lol		| |		| {LOCAL4, $1, 4}			| |
+loe		| |		| {EXTERNAL4, $1}			| |
+#ifdef REGVARS
+lil inreg($1)==2 | |	REMREG($1)	| {regdef4,regvar($1)}		| |
+#endif REGVARS
+lil		| |		| {displdef4,LB, tostring($1)}		| |
+lof		| |		|			| adp $1 loi 4	|
+lal		| |		| {ADDR_LOCAL, $1}			| |
+lae		| |		| {ADDR_EXTERNAL, $1}			| |
+lxl $1==0	| |		| LB					| |
+lxl $1>0	| |	remove(ALL)
+			move({CONST4,$1},R0)
+			"jsb\t.lxl"
+			erase(R0)				| R0	| |
+lxa 		| |	remove(ALL)
+			move({CONST4,$1},R0)
+			"jsb\t.lxa"
+			erase(R0)				| R0	| |
+loi $1==1	| NC adispl |
+				| {displ1,%[1.reg],%[1.ind]}		| |
+...		| reg4 | 	| {regdef1,%[1]}			| |
+...		| NC ADDR_LOCAL | | {LOCAL1, %[1.num],1}	| |
+...		| displ4 |
+				| {displdef1,%[1.reg],%[1.ind]}		| |
+...		| NC LOCAL4 |
+				| {displdef1, LB, tostring(%[1.num])}	| |
+...		| NC ADDR_EXTERNAL |
+				| {EXTERNAL1,%[1.ind]}			| |
+...		| NC EXTERNAL4 |
+				| {reldef1,%[1.ind]}			| |
+...		| NC adisplind1 |
+			| {displind1,%[1.ireg],%[1.reg],%[1.ind]}	| |
+...		| NC aextdefind1 |
+				| {extdefind1,%[1.ireg],%[1.ind]}	| |
+...		| NC adispldefind1 |
+			| {displdefind1,%[1.ireg],%[1.reg],%[1.ind]}	| |
+loi $1==2	| NC adispl |
+				| {displ2,%[1.reg],%[1.ind]}		| |
+...		| reg4 |	| {regdef2,%[1]}			| |
+...		| NC ADDR_LOCAL | | {LOCAL2, %[1.num],2}	| |
+...		| displ4 |
+				| {displdef2,%[1.reg],%[1.ind]}		| |
+...		| NC ADDR_EXTERNAL |
+				| {EXTERNAL2,%[1.ind]}			| |
+...		| NC EXTERNAL4 |
+				| {reldef2,%[1.ind]}			| |
+...		| NC aextind2 |
+				| {extind2,%[1.ireg],%[1.ind]}		| |
+...		| NC adisplind2 |
+			| {displind2,%[1.ireg],%[1.reg],%[1.ind]}	| |
+...		| NC aextdefind2 |
+				| {extdefind2,%[1.ireg],%[1.ind]}	| |
+...		| NC adispldefind2 |
+			| {displdefind2,%[1.ireg],%[1.reg],%[1.ind]}	| |
+loi $1==4	| NC adispl |
+				| {displ4,%[1.reg],%[1.ind]}		| |
+...		| reg4 | 	| {regdef4,%[1]}			| |
+...		| NC ADDR_LOCAL | | {LOCAL4, %[1.num],4}	| |
+...		| displ4 |
+				| {displdef4,%[1.reg],%[1.ind]}		| |
+...		| NC ADDR_EXTERNAL |
+			    	| {EXTERNAL4,%[1.ind]}			| |
+...		| NC EXTERNAL4 |
+				| {reldef4,%[1.ind]}			| |
+...		| NC aextind4 |
+				| {extind4,%[1.ireg],%[1.ind]}		| |
+...		| NC adisplind4 |
+			| {displind4,%[1.ireg],%[1.reg],%[1.ind]}	| |
+...		| NC aextdefind4 |
+				| {extdefind4,%[1.ireg],%[1.ind]}	| |
+...		| NC adispldefind4 |
+			| {displdefind4,%[1.ireg],%[1.reg],%[1.ind]}	| |
+loi $1==8	| NC adispl |
+				| {displ8,%[1.reg],%[1.ind]}		| |
+...		| reg4 | 	| {regdef8,%[1]}			| |
+...		| NC ADDR_LOCAL | | {LOCAL8, %[1.num],8}	| |
+...		| displ4 |
+				| {displdef8,%[1.reg],%[1.ind]}		| |
+...		| NC ADDR_EXTERNAL |
+				| {EXTERNAL8,%[1.ind]}			| |
+...		| NC EXTERNAL4 |
+				| {reldef8,%[1.ind]}			| |
+...		| NC aextind8 |
+	     			| {extind8,%[1.ireg],%[1.ind]}		| |
+...		| NC adisplind8 |
+			| {displind8,%[1.ireg],%[1.reg],%[1.ind]}	| |
+...		| NC aextdefind8 |	     
+				| {extdefind8,%[1.ireg],%[1.ind]}	| |
+...		| NC adispldefind8 |    
+			| {displdefind8,%[1.ireg],%[1.reg],%[1.ind]}	| |
+loi $1>8 && $1<=16
+		| reg4 | | {displ8,%[1],tostring($1-8)} %[1]	| loi $1-8 |
+...		| NC ADDR_EXTERNAL |    
+				| {EXTERNAL8,%[1.ind]+"+"+tostring($1-8)}
+				%[1]				| loi $1-8 |
+...		| NC ADDR_LOCAL |
+				| {LOCAL8,%[1.num]+$1-8,8} %[1]	| loi $1-8 |	
+loi		| sreg4 |
+			remove(ALL)
+			allocate(REG={CONST4,$1/4})
+			"addl2\t$$$1,%[1]"
+#ifdef LOCLABS
+			"1:\nmovl\t-(%[1]),-(sp)"
+			"sobgtr\t%[a],1b"
+#else
+			"movl\t-(%[1]),-(sp)"
+			"sobgtr\t%[a],.-3"
+#endif
+			erase(%[a])				|	| |
+los $1==4	| |	remove(ALL)
+			move({CONST1,4},R0)
+			"jsb\t.los"
+			erase(R0)				|	| |
+los !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.los"
+			erase(R0)				|	| |
+ldl		| |		| {LOCAL8, $1, 8}			| |
+lde		| |		| {EXTERNAL8, $1}			| |
+ldf		| |		|		| adp $1 loi 8	|
+lpi		| |		| {ADDR_EXTERNAL, $1}			| |
+
+/********************************
+ * Group 2 : Store instructions *
+ ********************************/
+
+#ifdef REGVARS
+stl inreg($1)==2 | NC bigsource4 |
+			remove(regvar($1))
+			move(%[1],regvar($1))		|	| |
+...		| |	remove(ALL)
+			"movl\t(sp)+,%(regvar($1)%)"	|	| | (3,7)
+#endif REGVARS
+stl		| NC bigsource4 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1)
+			move(%[1], {LOCAL4,$1, 4})		|	| |
+...		| |	remove(ALL)
+			"movl\t(sp)+,$1(fp)"		|	| | (5,14)
+ste		| NC bigsource4 |
+			remove(externals)
+			move(%[1],{EXTERNAL4, $1})		|	| |
+...		| |	remove(ALL)
+			"movl\t(sp)+,$1"		|	| | (7,14)
+#ifdef REGVARS
+sil inreg($1)==2 | NC bigsource4 |
+			REMEXTANDLOC
+			move(%[1],{regdef4,regvar($1)})	|	| |
+...		| |	remove(ALL)
+			"movl\t(sp)+,(%(regvar($1)%))"	|	| | (3,10)
+#endif REGVARS
+sil		| NC bigsource4 |
+			REMEXTANDLOC
+			move(%[1],{displdef4,LB, tostring($1)})	|	| |
+...		| |	remove(ALL)
+			"movl\t(sp)+,*$1(fp)"		|	| | (5,17)
+stf		| |				| | adp $1 sti 4 |
+/*** C-problem: f(c) char c; {
+			write(1, &c, 1);
+		}
+		You don't know where the character is put in the word,
+		so the CEM-compiler generates: (shorts analogously)
+***/
+lol lal sti $1==$2 && $3<4	| | | | |
+/************************************************/
+sti $1==1	| NC adispl source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displ1,%[1.reg],%[1.ind]})	|	| |
+...		| NC ADDR_LOCAL source1or2or4 |
+			remove(displaced)
+			remove(LOCALS,
+				%[num]<=%[1.num] && %[num]+%[size]>%[1.num])
+			move(%[2],{LOCAL1,%[1.num],1})		|	| |
+...		| NC ADDR_LOCAL STACK |
+			"cvtlb\t(sp)+,%[1]"		|	| | (3,7)+%[1]
+...		| reg4 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{regdef1,%[1]})		|	| |
+...		| displ4 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displdef1,%[1.reg],%[1.ind]}) |	| |
+...		| NC ADDR_EXTERNAL source1or2or4 |
+			remove(externals)
+			move(%[2],{EXTERNAL1,%[1.ind]}) 	|	| |
+...		| NC EXTERNAL4 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{reldef1,%[1.ind]})		|	| |
+...		| NC adisplind1 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displind1,%[1.ireg],%[1.reg],%[1.ind]})
+								|	| |
+...		| NC aextdefind1 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{extdefind1,%[1.ireg],%[1.ind]}) |	| |
+...		| NC adispldefind1 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displdefind1,%[1.ireg],%[1.reg],%[1.ind]})
+								|	| |
+sti $1==2	| NC adispl source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displ2,%[1.reg],%[1.ind]}) |	| |
+...		| reg4 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{regdef2,%[1]})		|	| |
+...		| NC ADDR_LOCAL source1or2or4 |
+			remove(displaced)
+			remove(LOCALS,
+				%[num]<=%[1.num] && %[num]+%[size]>%[1.num])
+			move(%[2],{LOCAL2,%[1.num],2})		|	| |
+...		| displ4 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displdef2,%[1.reg],%[1.ind]}) |	| |
+...		| NC ADDR_EXTERNAL source1or2or4 |
+			remove(externals)
+			move(%[2],{EXTERNAL2,%[1.ind]}) 	|	| |
+...		| NC EXTERNAL4 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{reldef2,%[1.ind]})		|	| |
+...		| NC aextind2 source1or2or4 |
+			remove(externals)
+			move(%[2],{extind2,%[1.ireg],%[1.ind]})	|	| |
+...		| NC adisplind2 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displind2,%[1.ireg],%[1.reg],%[1.ind]}) | | |
+...		| NC aextdefind2 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{extdefind2,%[1.ireg],%[1.ind]}) |	| |
+...		| NC adispldefind2 source1or2or4 |
+			REMEXTANDLOC
+			move(%[2],{displdefind2,%[1.ireg],%[1.reg],%[1.ind]})
+								|	| |
+sti $1==4	| NC adispl bigsource4 |
+			REMEXTANDLOC
+			move(%[2],{displ4,%[1.reg],%[1.ind]}) |	| |
+...		| NC ADDR_LOCAL |		| | stl %[1.num] |
+...		| NC ADDR_EXTERNAL |		| | ste %[1.ind] |
+...		| adispl |
+			remove(ALL)
+			"movl\t(sp)+,%[1]"		|	| | (3,7)+%[1]
+...		| reg4 bigsource4 |
+			REMEXTANDLOC
+			move(%[2],{regdef4,%[1]})		|	| |
+...		| displ4 bigsource4 |
+			REMEXTANDLOC
+			move(%[2],{displdef4,%[1.reg],%[1.ind]}) |	| |
+...		| NC EXTERNAL4 bigsource4 |
+			REMEXTANDLOC
+			move(%[2],{reldef4,%[1.ind]})		|	| |
+...		| NC aextind4 bigsource4 |
+			remove(externals)
+			move(%[2],{extind4,%[1.ireg],%[1.ind]})	|	| |
+...		| NC adisplind4 bigsource4 |
+			REMEXTANDLOC
+			move(%[2],{displind4,%[1.ireg],%[1.reg],%[1.ind]}) | | |
+...		| NC aextdefind4 bigsource4 |
+			REMEXTANDLOC
+			move(%[2],{extdefind4,%[1.ireg],%[1.ind]}) |	| |
+...		| NC adispldefind4 bigsource4 |
+			REMEXTANDLOC
+			move(%[2],{displdefind4,%[1.ireg],%[1.reg],%[1.ind]})
+								|	| |
+sti $1==8	| NC adispl bigsource8 |
+			REMEXTANDLOC
+			move(%[2],{displ8,%[1.reg],%[1.ind]}) |	| |
+...		| NC ADDR_LOCAL |		| | sdl %[1.num] |
+...		| NC ADDR_EXTERNAL |		| | sde %[1.ind] |
+...		| reg4 bigsource8 |
+			REMEXTANDLOC
+			move(%[2],{regdef8,%[1]})		|	| |
+...		| displ4 bigsource8 |
+			REMEXTANDLOC
+			move(%[2],{displdef8,%[1.reg],%[1.ind]}) |	| |
+...		| NC EXTERNAL4 bigsource8 |
+			REMEXTANDLOC
+			move(%[2],{reldef8,%[1.ind]})		|	| |
+...		| NC aextind8 bigsource8 |
+			remove(externals)
+			move(%[2],{extind8,%[1.ireg],%[1.ind]})	|	| |
+...		| NC adisplind8 bigsource8 |
+			REMEXTANDLOC
+			move(%[2],{displind8,%[1.ireg],%[1.reg],%[1.ind]}) | | |
+...		| NC aextdefind8 bigsource8 |
+			REMEXTANDLOC
+			move(%[2],{extdefind8,%[1.ireg],%[1.ind]}) |	| |
+...		| NC adispldefind8 bigsource8 |
+			REMEXTANDLOC
+			move(%[2],{displdefind8,%[1.ireg],%[1.reg],%[1.ind]})
+								|	| |
+sti		| sreg4 |
+			remove(ALL)
+			allocate(REG={CONST4, $1/4})
+#ifdef LOCLABS
+			"1:\nmovl\t(sp)+,(%[1])+"
+			"sobgtr\t%[a],1b"
+#else
+			"movl\t(sp)+,(%[1])+"
+			"sobgtr\t%[a],.-3"
+#endif
+			erase(%[a])				|	| |
+sts $1==4	| STACK |
+			move({CONST1,4},R0)
+			"jsb\t.sts"
+			erase(R0)				|	| |
+sts !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sts"
+			erase(R0)				|	| |
+sdl		| NC bigsource8 |
+			remove(displaced)
+			remove(LOCALS, %[num]<=$1+7 && %[num]+%[size]>$1)
+			move(%[1],{LOCAL8,$1, 8})		|	| |
+...		| NC bigsource4 bigsource4 |
+			remove(displaced)
+			remove(LOCALS, %[num]<=$1+7 && %[num]+%[size]>$1)
+			move(%[1], {LOCAL4,$1,4})
+			move(%[2], {LOCAL4,$1+4,4})		|	| |
+...		| |	remove(ALL)
+			"movq\t(sp)+,$1(fp)"		|	| | (5,14)
+sde		| NC bigsource8 |
+			remove(externals)
+			move(%[1], {EXTERNAL8, $1})		|	| |
+...		| bigsource4 bigsource4 |
+			remove(externals)
+			move(%[1], {EXTERNAL4, $1})
+			move(%[2], {EXTERNAL4, $1+"+4"})	|	| |
+...		| |	remove(ALL)
+			"movq\t(sp)+,$1"		|	| | (7,14)
+sdf		| |					| | adp $1 sti 8 |
+
+/********************************
+ * Group 3 : Integer Arithmetic *
+ ********************************/
+
+adi $1==4	| source4 sreg4 |
+			"addl2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,4) + %[1]
+...		| sreg4 source4 |
+			"addl2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,4) + %[2]
+...		| NC nosreg4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"addl3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,4)+%[1]+%[2]
+#ifdef REGVARS
+adi stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			"addl3\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+adi stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, %[num]<=$2+3 && %[num]+%[size]>$2)
+			"addl3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4}) 		|	| |
+#ifdef REGVARS
+adi sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"addl3\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+adi sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"addl3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+adi ste $1==4	| source4 source4 |
+			remove(externals)
+			"addl3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})			|	| |
+adi !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.adi"			     |	     | |
+sbi $1==4	| source4 sreg4 |
+			"subl2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,4) + %[1]
+...		| NC source4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"subl3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,4)+%[1]+%[2]
+#ifdef REGVARS
+sbi stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			"subl3\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+sbi stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"subl3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4}) 		|	| |
+#ifdef REGVARS
+sbi sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"subl3\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+sbi sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"subl3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+sbi ste $1==4	| source4 source4 |
+			remove(externals)
+			"subl3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})			|	| |
+sbi !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sbi"			     |	     | |
+mli $1==4	| source4 sreg4 |
+			"mull2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,16) + %[1]
+...		| sreg4 source4 |
+			"mull2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,16) + %[2]
+...		| NC nosreg4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"mull3\t%[1],%[2],%[a]"
+			setcc(%[a])	    | %[a]  | | (4,16)+%[1]+%[2]
+#ifdef REGVARS
+mli stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			"mull3\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+mli stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"mull3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4}) 		|	| |
+#ifdef REGVARS
+mli sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"mull3\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+mli sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"mull3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+mli ste $1==4	| source4 source4 |
+			remove(externals)
+			"mull3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})			|	| |
+mli !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.mli"			     |	     | |
+dvi $1==4	| source4 sreg4 |
+			"divl2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		    | %[2]  | | (3,98) + %[1]
+...		| NC source4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"divl3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,98)+%[1]+%[2]
+#ifdef REGVARS
+dvi stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			"divl3\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+dvi stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"divl3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4}) 		|	| |
+#ifdef REGVARS
+dvi sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"divl3\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+dvi sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"divl3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+dvi ste $1==4	| source4 source4 |
+			remove(externals)
+			"divl3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})			|	| |
+dvi !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.dvi"			     |	     | |
+rmi $1==4	| source4 source4 |
+			allocate(REG)
+			"divl3\t%[1],%[2],%[a]"
+			"mull2\t%[1],%[a]"
+			"subl3\t%[a],%[2],%[a]"
+			setcc(%[a])				| %[a]	 | |
+#ifdef REGVARS
+rmi stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			allocate(REG)
+			"divl3\t%[1],%[2],%[a]"
+			"mull2\t%[1],%[a]"
+			"subl3\t%[a],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))		|	| |
+#endif REGVARS
+rmi stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num]<=$2+3 && %[num]+%[size]>$2))
+			allocate(REG)
+			"divl3\t%[1],%[2],%[a]"
+			"mull2\t%[1],%[a]"
+			"subl3\t%[a],%[2],$2(fp)"
+			setcc({LOCAL4, $2, 4})		|	| |
+#ifdef REGVARS
+rmi sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			allocate(REG)
+			"divl3\t%[1],%[2],%[a]"
+			"mull2\t%[1],%[a]"
+			"subl3\t%[a],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+rmi sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			allocate(REG)
+			"divl3\t%[1],%[2],%[a]"
+			"mull2\t%[1],%[a]"
+			"subl3\t%[a],%[2],*$2(fp)"
+			setcc({displdef4, LB, tostring($2)})	|	| |
+rmi ste $1==4	| source4 source4 |
+			remove(externals)
+			allocate(REG)
+			"divl3\t%[1],%[2],%[a]"
+			"mull2\t%[1],%[a]"
+			"subl3\t%[a],%[2],$2"
+			setcc({EXTERNAL4, $2})			|	| |
+rmi !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.rmi"
+			erase(R0)				|	| |
+ngi $1==4	| source4 |
+			allocate(%[1],REG)
+			"mnegl\t%[1],%[a]"
+			setcc(%[a])				| %[a]	| |
+#ifdef REGVARS
+ngi stl $1==4 && inreg($2)==2
+		| source4 |
+			remove(regvar($2))
+			"mnegl\t%[1],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2)) 		|	| |
+#endif REGVARS
+ngi stl $1==4	| source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"mnegl\t%[1],$2(fp)"
+			setcc({LOCAL4,$2, 4}) 		|	| |
+#ifdef REGVARS
+ngi sil $1==4 && inreg($2)==2
+		| source4 |
+			REMEXTANDLOC
+			"mnegl\t%[1],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+ngi sil $1==4	| source4 |
+			REMEXTANDLOC
+			"mnegl\t%[1],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+ngi ste $1==4	| source4 |
+			remove(externals)
+			"mnegl\t%[1],$2"
+			setcc({EXTERNAL4,$2})			|	| |
+ngi !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.ngi"				 |	 | |
+sli $1==4	| source1or2or4 source1or2or4 |
+			allocate(%[1],%[2],REG)
+			"ashl\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]  | | (4,4)+%[1]+%[2]
+#ifdef REGVARS
+sli stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			"ashl\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+sli stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"ashl\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4, $2, 4})	|	| |
+#ifdef REGVARS
+sli sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"ashl\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+sli sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"ashl\t%[1],%[2],*$2(fp)"
+			setcc({displdef4, LB, tostring($2)})	|	| |
+sli ste $1==4	| source4 source4 |
+			remove(externals)
+			"ashl\t%[1],%[2],$2"
+			setcc({EXTERNAL4, $2})	|	| | (8,10)+%[1]+%[2]
+sli !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sli"
+			erase(R0)				|	| |
+sri $1==4	| source4-CONST source4 |
+			allocate(%[1],REG)
+			"mnegl\t%[1],%[a]"
+			"ashl\t%[a],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (7,8)+%[1]+%[2]
+...		| NC CONST source4 |
+			allocate(%[2],REG)
+			"ashl\t$$%(0-%[1.num]%),%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,4)+%[1]+%[2]
+#ifdef REGVARS
+sri stl $1==4 && inreg($2)==2
+		| source4-CONST source4 |
+			remove(regvar($2))
+			allocate(%[1], REG)
+			"mnegl\t%[1],%[a]"
+			"ashl\t%[a],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| | (9,14)+%[1]+%[2]
+...		| CONST source4 |
+			remove(regvar($2))
+			"ashl\t$$%(0-%[1.num]%),%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| | (6,10)+%[1]+%[2]
+#endif REGVARS
+sri stl $1==4	| source4-CONST source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			allocate(%[1], REG)
+			"mnegl\t%[1],%[a]"
+			"ashl\t%[a],%[2],$2(fp)"
+			setcc({LOCAL4, $2, 4}) |	| | (9,11)+%[1]+%[2]
+...		| CONST source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"ashl\t$$%(0-%[1.num]%),%[2],$2(fp)"
+			setcc({LOCAL4, $2, 4}) |	| | (6,7)+%[1]+%[2]
+#ifdef REGVARS
+sri sil $1==4 && inreg($2)==2
+		| source4-CONST source4 |
+			REMEXTANDLOC
+			allocate(%[1], REG)
+			"mnegl\t%[1],%[a]"
+			"ashl\t%[a],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)}) |	| | (9,14)+%[1]+%[2]
+...		| CONST source4 |
+			REMEXTANDLOC
+			"ashl\t$$%(0-%[1.num]%),%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)}) |	| | (6,10)+%[1]+%[2]
+#endif REGVARS
+sri sil $1==4	| source4-CONST source4 |
+			REMEXTANDLOC
+			allocate(%[1], REG)
+			"mnegl\t%[1],%[a]"
+			"ashl\t%[a],%[2],*$2(fp)"
+			setcc({displdef4, LB, tostring($2)})
+						|	| | (9,17)+%[1]+%[2]
+...		| CONST source4 |
+			REMEXTANDLOC
+			"ashl\t$$%(0-%[1.num]%),%[2],*$2(fp)"
+			setcc({displdef4, LB, tostring($2)})
+						|	| | (6,13)+%[1]+%[2]
+sri ste $1==4	| source4-CONST source4 |
+			remove(externals)
+			allocate(%[1], REG)
+			"mnegl\t%[1],%[a]"
+			"ashl\t%[a],%[2],$2"
+			setcc({EXTERNAL4, $2})	|	| | (11,14)+%[1]+%[2]
+...		| CONST source4 |
+			remove(externals)
+			"ashl\t$$%(0-%[1.num]%),%[2],$2"
+			setcc({EXTERNAL4, $2})	|	| | (8,10)+%[1]+%[2]
+sri !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sri"
+			erase(R0)				|	| |
+
+/************************************************
+ * Group 4 : Unsigned arithmetic		*
+ ************************************************/
+
+adu		| |				|	| adi $1 |
+sbu		| |				|	| sbi $1 |
+mlu		| |				|	| mli $1 |
+dvu $1==4	| |	remove(ALL)
+			"jsb\t.dvu4"		| R0	| |
+dvu !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.dvu"
+			erase(R0)			|	| |
+rmu $1==4	| |	remove(ALL)
+			"jsb\t.rmu4"			| R0	| |
+rmu !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.rmu"
+			erase(R0)			|	| |
+slu		| |					|	| sli $1 |
+sru $1==4	| source4-CONST source4 |
+			allocate(%[1],REG,QREG)
+			"mnegl\t%[1],%[a]"
+			move(%[2],%[b.1])
+			move({CONST4,0},%[b.2])
+			"ashq\t%[a],%[b],%[b]"
+			erase(%[b])		| %[b.1] | | (10,12)+%[1]
+...		| NC CONST source4 |
+			allocate(%[2],QREG)
+			move(%[2],%[a.1])
+			move({CONST4,0},%[a.2])
+			"ashq\t$$%(0-%[1.num]%),%[a],%[a]"
+			erase(%[a])		| %[a.1] | | (4,4)+%[1]
+sru !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sru"
+			erase(R0)			|	| |
+
+/****************************************
+ * Group 5 : Floating point arithmetic	*
+ ****************************************/
+
+adf $1==4	| source4 sreg4 |
+			"addf2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,8) + %[1]
+...		| sreg4 source4 |
+			"addf2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,8) + %[2]
+...		| NC nosreg4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"addf3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,8)+%[1]+%[2]
+#ifdef FLOAT4
+adf stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2)
+			"addf3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})    |	   | |
+adf sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"addf3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+adf ste $1==4	| source4 source4 |
+			remove(externals)
+			"addf3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+#endif
+adf $1==8	| source8 sreg8 |
+			"addd2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,14) + %[1]
+...		| sreg8 source8 |
+			"addd2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,14) + %[2]
+...		| NC nosreg8 source8-sreg8 |
+			allocate(%[1],%[2],QREG)
+			"addd3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,14)+%[1]+%[2]
+adf sdl $1==8	| source8 source8 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2)
+			"addd3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL8,$2, 8})    |	   | |
+adf sde $1==8	| source8 source8 |
+			remove(externals)
+			"addd3\t%[1],%[2],$2"
+			setcc({EXTERNAL8,$2})	|	| |
+adf !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.adf"		 |	 | |
+sbf $1==4	| source4 sreg4 |
+			"subf2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,8) + %[1]
+...		| NC source4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"subf3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,8)+%[1]+%[2]
+#ifdef FLOAT4
+sbf stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2)
+			"subf3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})    |	   | |
+sbf sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"subf3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+sbf ste $1==4	| source4 source4 |
+			remove(externals)
+			"subf3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+#endif
+sbf $1==8	| source8 sreg8 |
+			"subd2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,14) + %[1]
+...		| NC source8 nosreg8 |
+			allocate(%[1],%[2],QREG)
+			"subd3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,14)+%[1]+%[2]
+sbf sdl $1==8	| source8 source8 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2)
+			"subd3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL8,$2, 8})    |	   | |
+sbf sde $1==8	| source8 source8 |
+			remove(externals)
+			"subd3\t%[1],%[2],$2"
+			setcc({EXTERNAL8,$2})	|	| |
+sbf !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sbf"		 |	 | |
+mlf $1==4	| source4 sreg4 |
+			"mulf2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,12) + %[1]
+...		| sreg4 source4 |
+			"mulf2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,12) + %[2]
+...		| NC nosreg4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"mulf3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,12)+%[1]+%[2]
+#ifdef FLOAT4
+mlf stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2)
+			"mulf3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})    |	   | |
+mlf sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"mulf3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})    |	   | |
+mlf ste $1==4	| source4 source4 |
+			remove(externals)
+			"mulf3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+#endif
+mlf $1==8	| source8 sreg8 |
+			"muld2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,20) + %[1]
+...		| sreg8 source8 |
+			"muld2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,20) + %[2]
+...		| NC nosreg8 source8-sreg8 |
+			allocate(%[1],%[2],QREG)
+			"muld3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,20)+%[1]+%[2]
+mlf sdl $1==8	| source8 source8 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2)
+			"muld3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL8,$2, 8})    |	   | |
+mlf sde $1==8	| source8 source8 |
+			remove(externals)
+			"muld3\t%[1],%[2],$2"
+			setcc({EXTERNAL8,$2})	|	| |
+mlf !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.mlf"		 |	 | |
+dvf $1==4	| source4 sreg4 |
+			"divf2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,46) + %[1]
+...		| NC source4 nosreg4 |
+			allocate(%[1],%[2],REG)
+			"divf3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,46)+%[1]+%[2]
+#ifdef FLOAT4
+dvf stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2)
+			"divf3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})    |	   | |
+dvf sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"divf3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})    |	   | |
+dvf ste $1==4	| source4 source4 |
+			remove(externals)
+			"divf3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+#endif
+dvf $1==8	| source8 sreg8 |
+			"divd2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,80) + %[1]
+...		| NC source8 nosreg8 |
+			allocate(%[1],%[2],QREG)
+			"divd3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,80)+%[1]+%[2]
+dvf sdl $1==8	| source8 source8 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2)
+			"divd3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL8,$2, 8})    |	   | |
+dvf sde $1==8	| source8 source8 |
+			remove(externals)
+			"divd3\t%[1],%[2],$2"
+			setcc({EXTERNAL8,$2})	|	| |
+dvf !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.dvf"		 |	 | |
+ngf $1==4	| source4 |
+			allocate(%[1],REG)
+			"mnegf\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+#ifdef FLOAT4
+ngf stl $1==4	| source4 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+3 && %[num]+%[size] > $2)
+			"mnegf\t%[1],$2(fp)"
+			setcc({LOCAL4,$2, 4})    |	   | |
+ngf sil $1==4	| source4 |
+			REMEXTANDLOC
+			"mnegf\t%[1],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})    |	   | |
+ngf ste $1==4	| source4 |
+			remove(externals)
+			"mnegf\t%[1],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+#endif
+ngf $1==8	| source8 |
+			allocate(%[1],QREG)
+			"mnegd\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+ngf sdl $1==8	| source8 |
+			remove(displaced)
+			remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2)
+			"mnegd\t%[1],$2(fp)"
+			setcc({LOCAL8,$2, 8})    |	   | |
+ngf sde $1==8	| source8 |
+			remove(externals)
+			"mnegd\t%[1],$2"
+			setcc({EXTERNAL8,$2})	|	| |
+ngf !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.ngf"		 |	 | |
+loc loc loc cif fif $1==1 && $2==4 && $3==4 && $5==4
+		| source4 |
+			allocate(%[1],REG,REG)
+			"emodf\t%[1],$$0,$$0f1.0,%[b],%[a]"
+			/* Don't trust the integer part in %[b], *
+			 * integer overflow might occur.	 */
+			"subf3\t%[a],%[1],%[b]"	| %[a] %[b]	| |
+loc loc loc cif fif $1==1 && $2==4 && $3==8 && $5==8
+		| source8 |
+			allocate(%[1],QREG,QREG)
+			"emodd\t%[1],$$0,$$0f1.0,%[b],%[a]"
+			"subd3\t%[a],%[1],%[b]"	| %[a] %[b]	| |
+fif $1==4	| source4 source4 |
+			allocate(%[1],%[2],REG,REG,REG)
+			"mulf3\t%[1],%[2],%[a]"
+			"emodf\t%[a],$$0,$$0f1.0,%[b],%[c]"
+			"subf2\t%[c],%[a]"	| %[c] %[a]	| |
+fif $1==8	| source8 source8 |
+			allocate(%[1],%[2],QREG,QREG)
+			"muld3\t%[1],%[2],%[a]"
+			"emodd\t%[a],$$0,$$0f1.0,-(sp),%[b]"
+			"tstl\t(sp)+"
+			"subd2\t%[b],%[a]"	| %[b] %[a]	| |
+fif !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.fif"
+			erase(R0)		|	| |
+fef $1==4	| sreg4 |
+			allocate(REG)
+			"extzv\t$$7,$$8,%[1],%[a]"
+			"subl2\t$$128,%[a]"
+			"insv\t$$128,$$7,$$8,%[1]" 
+			erase(%[1])		| %[1] %[a] | |
+fef $1==8	| sreg8 |
+			allocate(REG)
+			"extzv\t$$7,$$8,%[1],%[a]"
+			"subl2\t$$128,%[a]"
+			"insv\t$$128,$$7,$$8,%[1]" 
+			erase(%[1])		| %[1] %[a] | |
+fef !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.fef"
+			erase(R0)		|	| |
+
+/********************************
+ * Group 6 : pointer arithmetic *
+ ********************************/
+
+adp $1==0	| | | | |
+adp		| NC adispl |
+			| {adispl,%[1.reg],%[1.ind]+"+"+tostring($1)} | |
+...		| NC ADDR_EXTERNAL |
+				| {ADDR_EXTERNAL,%[1.ind]+"+"+tostring($1)} | |
+...		| NC ADDR_LOCAL |	| {ADDR_LOCAL,%[1.num]+$1} | |
+...		| reg4 | 	| {adispl,%[1],tostring($1)}		  | |
+...		| NC adisplind1 |
+			| {adisplind1,%[1.ireg],%[1.reg],
+					%[1.ind]+"+"+tostring($1)} | |
+...		| NC adisplind2 |
+			| {adisplind2,%[1.ireg],%[1.reg],
+					%[1.ind]+"+"+tostring($1)} | |
+...		| NC adisplind4 |
+			| {adisplind4,%[1.ireg],%[1.reg],
+					%[1.ind]+"+"+tostring($1)} | |
+...		| NC adisplind8 |
+			| {adisplind8,%[1.ireg],%[1.reg],
+					%[1.ind]+"+"+tostring($1)} | |
+...		| NC aextind2 |
+			| {aextind2,%[1.ireg],%[1.ind]+"+"+tostring($1)} | |
+...		| NC aextind4 |
+			| {aextind4,%[1.ireg],%[1.ind]+"+"+tostring($1)} | |
+...		| NC aextind8 |
+			| {aextind8,%[1.ireg],%[1.ind]+"+"+tostring($1)} | |
+ads $1==4	| NC reg4 adispl |
+				| {adisplind1,%[1],%[2.reg],%[2.ind]}	| |
+...		| NC reg4 ADDR_LOCAL |
+				| {adisplind1,%[1],LB,tostring(%[2.num])} | |
+...		| NC reg4 ADDR_EXTERNAL |
+				| {adispl,%[1],%[2.ind]}	| |
+...		| NC reg4 displ4 |
+				| {adispldefind1,%[1],%[2.reg],%[2.ind]} | |
+...		| NC reg4 LOCAL4 |
+				| {adispldefind1,%[1],LB,tostring(%[2.num])} | |
+...		| NC reg4 EXTERNAL4 |
+				| {aextdefind1,%[1],%[2.ind]}		| |
+...		| source4 source4 |
+			allocate(%[1],%[2],REG)
+			"addl3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,4)+%[1]+%[2]
+ads		| |		|		| loc $1 loc 4 cii ads 4 |
+ads !defined($1) | |		|		| loc 4 cii ads 4 |
+sbs $1==4	| |		|		| sbu $1 |
+sbs $1!=4	| |		|		| sbu 4 loc 4 loc $1 cii |
+sbs !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sbs"
+			erase(R0)		|	| |
+adp dup sil adp $1==(0-$4) && $2==4 
+		| reg4 | | %[1] %[1]	| adp $1 sil $3 |
+adp dup loe sti adp $1==(0-$5) && $2==4 && $4==4
+		| reg4 | | %[1] %[1]	| adp $1 loe $3 sti 4 |
+#ifdef REGVARS
+lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==1 && $5==1
+		| |	remove(regvar($1))
+			| {reginc1,regvar($1)}		| |
+lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==2 && $5==2
+		| |	remove(regvar($1))
+			| {reginc2,regvar($1)}		| |
+lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==4 && $5==4
+		| |	remove(regvar($1))
+			| {reginc4,regvar($1)}		| |
+lol lol adp stl loi $1==$4 && $2==$1 && inreg($1)==2 && $3==8 && $5==8
+		| |	remove(regvar($1))
+			| {reginc8,regvar($1)}		| |
+lol adp dup stl loi $1==$4 && $2==(0-1) && inreg($1)==2 && $3==4 && $5==1
+		| |	remove(regvar($1))
+			| {regdec1,regvar($1)}		| |
+lol adp dup stl loi $1==$4 && $2==(0-2) && inreg($1)==2 && $3==4 && $5==2
+		| |	remove(regvar($1))
+			| {regdec2,regvar($1)}		| |
+lol adp stl lil $1==$4 && $2==(0-4) && inreg($1)==2 && $3==$1
+		| |	remove(regvar($1))
+			| {regdec4,regvar($1)}		| |
+lol adp dup stl loi $1==$4 && $2==(0-8) && inreg($1)==2 && $3==4 && $5==8
+		| |	remove(regvar($1))
+			| {regdec8,regvar($1)}		| |
+lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==1 && $5==1
+		| NC source1 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movb\t%[1],(%(regvar($1)%))+"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+...		| NC source2 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"cvtwb\t%[1],(%(regvar($1)%))+"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+...		| source4 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"cvtlb\t%[1],(%(regvar($1)%))+"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==2 && $5==2
+		| NC source2 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movw\t%[1],(%(regvar($1)%))+"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+...		| source4 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"cvtlw\t%[1],(%(regvar($1)%))+"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==4 && $5==4
+		| source4 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movl\t%[1],(%(regvar($1)%))+"
+			erase(regvar($1))		|	| |
+lol lol adp stl sti $1==$4 && $2==$1 && inreg($1)==2 && $3==8 && $5==8
+		| source8 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movq\t%[1],(%(regvar($1)%))+"
+			erase(regvar($1))		|	| |
+lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-1) && $3==4 && $5==1
+		| NC source1 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movb\t%[1],-(%(regvar($1)%))"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+...		| NC source2 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"cvtwb\t%[1],-(%(regvar($1)%))"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+...		| source4 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"cvtlb\t%[1],-(%(regvar($1)%))"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-2) && $3==4 && $5==2
+		| NC source2 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movw\t%[1],-(%(regvar($1)%))"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+...		| source4 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"cvtlw\t%[1],-(%(regvar($1)%))"
+			erase(regvar($1))		|	| | (3,7)+%[1]
+lol adp stl sil $1==$4 && inreg($1)==2 && $2==(0-4) && $3==$4
+		| source4 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movl\t%[1],-(%(regvar($1)%))"
+			erase(regvar($1))		|	| |
+lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-8) && $3==4 && $5==8
+		| source8 |
+			REMEXTANDLOC
+			remove(regvar($1))
+			"movq\t%[1],-(%(regvar($1)%))"
+			erase(regvar($1))		|	| |
+lol lol adp stl $1==$4 && $2==$4 && inreg($1)==2
+		| |	remove(regvar($1))
+			allocate(REG=regvar($1))
+			"addl2\t$$$3,%(regvar($1)%)"
+			erase(regvar($1))		| %[a]	| |
+lol adp stl $1==$3 && inreg($1)==2
+		| |	remove(regvar($1))
+			"addl2\t$$$2,%(regvar($1)%)"
+			erase(regvar($1))		|	| |
+#endif REGVARS
+lol adp stl $1==$3
+		| |	remove(displaced)
+			remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1)
+			"addl2\t$$$2,$1(fp)" 
+			setcc({LOCAL4,$1,4})	|	| |
+lol lol adp stl $1==$4 && $2==$4
+		| |	remove(displaced)
+			remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1)
+			allocate(REG={LOCAL4,$1,4})
+			"addl2\t$$$3,$1(fp)"
+			setcc({LOCAL4,$1,4})	| %[a]	| |
+#ifdef REGVARS
+lil lil adp sil $1==$2 && $1==$4 && inreg($1)==2
+		| |	REMEXTANDLOC
+			allocate(REG={regdef4, regvar($1)})
+			"addl2\t$$$3,(%(regvar($1)%))"	| %[a]	| |
+#endif
+loe adp ste $1==$3
+		| |	remove(externals)
+			"addl2\t$$$2,$1"	|		| |
+loe loe adp ste $1==$4 && $2==$1
+		| |	remove(externals)
+			allocate(REG={EXTERNAL4,$1})
+			"addl2\t$$$3,$1"	| %[a]		| |
+
+/****************************************
+ * Group 7 : Increment/decrement/zero	*
+ ****************************************/
+
+lil inc dup sil $3==4 && $1==$4	| | | | lil $1 loc 1 adi 4 sil $1 lil $1 |
+lil dec dup sil $3==4 && $1==$4	| | | | lil $1 loc 1 sbi 4 sil $1 lil $1 |
+inc		| 	|	| {CONST1,1}	| adi 4 |
+dec		|	|	| {CONST1,1}	| sbi 4 |
+#ifdef REGVARS
+inl inreg($1)==2 | |	remove(regvar($1))
+			"incl\t%(regvar($1)%)"
+			erase(regvar($1))
+			setcc(regvar($1))	|	| |
+#endif REGVARS
+inl		| |	remove(displaced)
+			remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1)
+			"incl\t$1(fp)"
+			setcc({LOCAL4,$1, 4})    |	   | |
+#ifdef REGVARS
+lol inl $1==$2 && inreg($1)==2
+		| |	remove(regvar($1))
+			allocate(REG=regvar($1))
+			"incl\t%(regvar($1)%)"
+			erase(regvar($1))
+			setcc(regvar($1))	| %[a]	| |
+#endif REGVARS
+ine		| |	remove(externals)
+			"incl\t$1"
+			setcc({EXTERNAL4, $1})	|	| |
+#ifdef REGVARS
+del inreg($1)==2 | |	remove(regvar($1))
+			"decl\t%(regvar($1)%)"
+			erase(regvar($1))
+			setcc(regvar($1))	|	| |
+#endif REGVARS
+del		| |	remove(displaced)
+			remove(LOCALS, %[num] <= $1+3 && %[num]+%[size] > $1)
+			"decl\t$1(fp)"
+			setcc({LOCAL4,$1, 4})    |	   | |
+#ifdef REGVARS
+lol del $1==$2 && inreg($1)==2
+		| |	remove(regvar($1))
+			allocate(REG=regvar($1))
+			"decl\t%(regvar($1)%)"
+			erase(regvar($1))
+			setcc(regvar($1))	| %[a]	| |
+#endif REGVARS
+dee		| |	remove(externals)
+			"decl\t$1"
+			setcc({EXTERNAL4, $1})	|	| |
+#ifdef REGVARS
+zrl inreg($1)==2 | |	remove(regvar($1))
+			"clrl\t%(regvar($1)%)"
+			erase(regvar($1))
+			setcc(regvar($1))	|	   | |
+#endif REGVARS
+zrl		| |	remove(displaced)
+			remove(LOCALS,%[num] <= $1+3 && %[num]+%[size] > $1)
+			"clrl\t$1(fp)"
+			setcc({LOCAL4,$1, 4})    |	   | |
+zrl zrl $1==$2+4	
+#ifdef REGVARS
+	&& inreg($1)<2 && inreg($2)<2
+#endif REGVARS
+		| |	remove(displaced)
+			remove(LOCALS, %[num] <= $2+7 && %[num]+%[size] > $2)
+			"clrq\t$2(fp)"
+			setcc({LOCAL8,$2, 8})	|	| |
+zrl zrl $1==$2-4 | |				|	| zrl $2 zrl $1 |
+zre		| |	remove(externals)
+			"clrl\t$1"
+			setcc({EXTERNAL4, $1})	|	| |
+zrf $1==4	| |		| {CONST4,0}		| |
+zrf $1==8	| |		| {FCONST8,0}		| |
+zer $1==4	| |		| {CONST4,0}				| |
+zer $1==8	| |	allocate(QREG)
+			"clrq\t%[a]"		| %[a]	| |
+zer $1<=32	| |	remove(ALL)
+			"clrq\t-(sp)"		|	| zer $1-8 |
+zer defined($1)	| |	remove(ALL)
+			move({CONST4,$1/4}, R0)
+#ifdef LOCLABS
+			"1:\tclrl\t-(sp)"
+			"sobgtr\tr0,1b"
+#else LOCLABS
+			"clrl\t-(sp)"
+			"sobgtr\tr0,.-2"
+#endif LOCLABS
+			erase(R0)		|	| |
+zer !defined($1) | source1or2or4 |
+			remove(ALL)
+			move(%[1],R0)
+#ifdef LOCLABS
+			"1:\tclrl\t-(sp)"
+			"sobgtr\tr0,1b"
+#else LOCLABS
+			"clrl\t-(sp)"
+			"sobgtr\tr0,.-2"
+#endif LOCLABS
+			erase(R0)		|	| |
+
+/********************************
+ * Group 8 : Convertions	*
+ ********************************/
+
+cii		| |	remove(ALL)
+			"jsb\t.cii"		|	| |
+cfi		| |	remove(ALL)
+			"jsb\t.cfi"		|	| |
+cfu		| |	remove(ALL)
+			"jsb\t.cfu"		|	| |
+cuf		| |	remove(ALL)
+			"jsb\t.cuf"		|	| |
+cif		| |	remove(ALL)
+			"jsb\t.cif"		|	| |
+cff		| |	remove(ALL)
+			"jsb\t.cff"		|	| |
+cuu		| |	remove(ALL)
+			"jsb\t.cuu"		|	| |
+ciu		| |				|	| cuu |
+cui		| |	remove(ALL)
+			"jsb\t.cui"		|	| |
+loc loc cii $1==1 && $2==2	| source1or2or4 |
+			allocate(%[1],REG)
+			"cvtbw\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+#ifdef REGVARS
+loc loc cii stl $1==1 && $2==4 && inreg($4)==2
+		| source1or2or4 |
+			remove(regvar($4))
+			"cvtbl\t%[1],%(regvar($4)%)"
+			erase(regvar($1))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cii stl $1==1 && $2==4	| source1or2or4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"cvtbl\t%[1],$4(fp)"
+			setcc({LOCAL4,$4, 4})	|	| |
+loc loc cii ste $1==1 && $2==4	| source1or2or4 |
+			remove(externals)
+			"cvtbl\t%[1],$4"
+			setcc({EXTERNAL4, $4})	|	| |
+loc loc cii $1==1 && $2==4	| source1or2or4 |
+			allocate(%[1],REG)
+			"cvtbl\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+#ifdef REGVARS
+loc loc cii stl $1==2 && $2==4 && inreg($4)==2
+		| source2or4 |
+			remove(regvar($4))
+			"cvtwl\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cii stl $1==2 && $2==4	| source2or4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"cvtwl\t%[1],$4(fp)"
+			setcc({LOCAL4,$4, 4})	|	| |
+loc loc cii ste $1==2 && $2==4	| source2or4 |
+			remove(externals)
+			"cvtwl\t%[1],$4"
+			setcc({EXTERNAL4, $4})	|	| |
+loc loc cii $1==2 && $2==4	| source2or4 |
+			allocate(%[1],REG)
+			"cvtwl\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+loc loc cii $1==2 && $2==1  | | |				    | |
+loc loc cii $1==4 && $2==1  | | |				    | |
+loc loc cii $1==4 && $2==2  | | |				    | |
+loc loc cui $1==$2	|	|	|	|	|
+loc loc ciu	|	|	|	| loc $1 loc $2 cuu	|
+#ifdef REGVARS
+loc loc cfi stl $1==4 && $2==4 && inreg($4)==2
+		| source4 |
+			remove(regvar($4))
+			"cvtfl\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cfi stl $1==4 && $2==4	| source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"cvtfl\t%[1],$4(fp)"
+			setcc({LOCAL4,$4, 4}) |	| |
+loc loc cfi ste $1==4 && $2==4	| source4 |
+			remove(externals)
+			"cvtfl\t%[1],$4"
+			setcc({EXTERNAL4, $4})	|	| |
+loc loc cfi $1==4 && $2==4	| source4 |
+			allocate(%[1],REG)
+			"cvtfl\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| | (3,4) + %[1]
+#ifdef REGVARS
+loc loc cfi stl $1==8 && $2==4 && inreg($4)==2
+		| source8 |
+			remove(regvar($4))
+			"cvtdl\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cfi stl $1==8 && $2==4	| source8 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"cvtdl\t%[1],$4(fp)"
+			setcc({LOCAL4,$4, 4})	|	| |
+loc loc cfi ste $1==8 && $2==4	| source8 |
+			remove(externals)
+			"cvtdl\t%[1],$4"
+			setcc({EXTERNAL4, $4})	|	| |
+loc loc cfi $1==8 && $2==4	| source8 |
+			allocate(%[1],REG)
+			"cvtdl\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+#ifdef REGVARS
+loc loc cif stl $1==4 && $2==4 && inreg($4)==2
+		| source4 |
+			remove(regvar($4))
+			"cvtlf\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cif stl $1==4 && $2==4	| source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"cvtlf\t%[1],$4(fp)"	|	| |
+loc loc cif ste $1==4 && $2==4	| source4 |
+			remove(externals)
+			"cvtlf\t%[1],$4"	|	| |
+loc loc cif $1==4 && $2==4	| source4 |
+			allocate(%[1],REG)
+			"cvtlf\t%[1],%[a]"	| %[a]	| |
+/* No double registervariables yet...
+#ifdef REGVARS
+loc loc cif sdl $1==4 && $2==8 && inreg($4)==2
+		| source4 |
+			remove(regvar($4))
+			"cvtld\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+*/
+loc loc cif sdl $1==4 && $2==8	| source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"cvtld\t%[1],$4(fp)"	|	| |
+loc loc cif sde $1==4 && $2==8	| source4 |
+			remove(externals)
+			"cvtld\t%[1],$4"	|	| |
+loc loc loc cif $1!=0 && $2==4 && $3==8	| |	| {FCONST8,$1}	| |
+/* $1!=0: kludge to avoid known bug in Vax assembler, that
+ * doesn't handle 0f0.0 (and other numbers that have the 0x4000 bit off
+ * in the exponent) right.
+ */
+loc loc cif $1==4 && $2==8	| source4 |
+			allocate(%[1],QREG)
+			"cvtld\t%[1],%[a]"	| %[a]	| |
+loc loc cfu $1==4	| source4 |
+			allocate(%[1],REG=%[1])
+			"bicl2\t$$32768,%[a]"	| %[a]	| loc $1 loc $2 cfi |
+loc loc cfu $1==8	| source8 |
+			allocate(%[1],QREG=%[1])
+			"bicl2\t$$32768,%[a]"	| %[a]	| loc $1 loc $2 cfi |
+#ifdef REGVARS
+loc loc cff sdl $1==4 && $2==8 && inreg($4)==2
+		| source4 |
+			remove(regvar($4))
+			"cvtfd\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cff sdl $1==4 && $2==8	| source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+7 && %[num]+%[size] > $4))
+			"cvtfd\t%[1],$4(fp)"	|	| |
+loc loc cff sde $1==4 && $2==8	| source4 |
+			remove(externals)
+			"cvtfd\t%[1],$4"	|	| |
+loc loc cff $1==4 && $2==8	| source4 |
+			allocate(%[1],QREG)
+			"cvtfd\t%[1],%[a]"	| %[a]	| |
+#ifdef REGVARS
+loc loc cff stl $1==8 && $2==4 && inreg($4)==2
+		| source8 |
+			remove(regvar($4))
+			"cvtdf\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cff stl $1==8 && $2==4	| source8 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"cvtdf\t%[1],$4(fp)"	|	| |
+loc loc cff ste $1==8 && $2==4	| source8 |
+			remove(externals)
+			"cvtdf\t%[1],$4"	|	| |
+loc loc cff $1==8 && $2==4	| source8 |
+			allocate(%[1],REG)
+			"cvtdf\t%[1],%[a]"	| %[a]	| |
+#ifdef REGVARS
+loc loc cuu stl $1==2 && $2==4 && inreg($4)==2
+		| source2or4 |
+			remove(regvar($4))
+			"movzwl\t%[1],%(regvar($4)%)"
+			erase(regvar($4))
+			setcc(regvar($4))	|	| |
+#endif REGVARS
+loc loc cuu stl $1==2 && $2==4	| source2or4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $4+3 && %[num]+%[size] > $4))
+			"movzwl\t%[1],$4(fp)"
+			setcc({LOCAL4,$4, 4})	|	| |
+loc loc cuu ste $1==2 && $2==4	| source2or4 |
+			remove(externals)
+			"movzwl\t%[1],$4"
+			setcc({EXTERNAL4, $4})	|	| |
+loc loc cuu $1==2 && $2==4	| source2or4 |
+			allocate(%[1],REG)
+			"movzwl\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+
+/****************************************
+ * Group 9 : Logical instructions	*
+ ****************************************/
+
+and $1==4	| source4 source4 |
+			allocate(%[1],REG)
+			"mcoml\t%[1],%[a]"
+			"bicl3\t%[a],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (7,6)+%[1]+%[2]
+...		| CONST source4 |
+			allocate(%[2],REG)
+			"bicl3\t$$~%[1.num],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,3)+%[1]+%[2]
+...		| source4 CONST |
+			allocate(%[1],REG)
+			"bicl3\t$$~%[2.num],%[1],%[a]"
+			setcc(%[a])		| %[a]	| | (4,3)+%[1]+%[2]
+and zeq $1==4	| source1 source1 |
+			remove(ALL)
+			"bitb\t%[1],%[2]"
+			"jeql\t$2"	|	| |
+...		| source2 source2 |
+			remove(ALL)
+			"bitw\t%[1],%[2]"
+			"jeql\t$2"	|	| |
+...		| source4 source4 |
+			remove(ALL)
+			"bitl\t%[1],%[2]"
+			"jeql\t$2"	|	| |
+and zne $1==4	| source1 source1 |
+			remove(ALL)
+			"bitb\t%[1],%[2]"
+			"jneq\t$2"	|	| |
+...		| source2 source2 |
+			remove(ALL)
+			"bitw\t%[1],%[2]"
+			"jneq\t$2"	|	| |
+...		| source4 source4 |
+			remove(ALL)
+			"bitl\t%[1],%[2]"
+			"jneq\t$2"	|	| |
+and tne $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"bitl\t%[1],%[2]"
+#ifdef LOCLABS
+			"jeql\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"jeql\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])		| %[a]	| |
+#ifdef REGVARS
+and stl $1==4 && inreg($2)==2
+		| source4-CONST source4 |
+			remove(regvar($2))
+			allocate(%[1],REG)
+			"mcoml\t%[1],%[a]"
+			"bicl3\t%[a],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| | (8,8)+%[1]+%[2]
+...		| CONST source4 |
+			remove(regvar($2))
+			"bicl3\t$$~%[1.num],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| | (4,4)+%[1]+%[2]
+...		| source4 CONST |
+			remove(regvar($2))
+			"bicl3\t$$~%[2.num],%[1],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| | (4,4)+%[1]+%[2]
+#endif REGVARS
+and stl $1==4	| source4-CONST source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			allocate(%[1],REG)
+			"mcoml\t%[1],%[a]"
+			"bicl3\t%[a],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| | (9,12)+%[1]+%[2]
+...		| NC CONST source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"bicl3\t$$~%[1.num],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| | (6,9)+%[1]+%[2]
+...		| NC source4 CONST |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"bicl3\t$$~%[2.num],%[1],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| | (6,9)+%[1]+%[2]
+#ifdef REGVARS
+and sil $1==4 && inreg($2)==2
+		| source4-CONST source4 |
+			REMEXTANDLOC
+			allocate(%[1],REG)
+			"mcoml\t%[1],%[a]"
+			"bicl3\t%[a],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})
+						|	| | (9,15)+%[1]+%[2]
+...		| CONST source4 |
+			REMEXTANDLOC
+			"bicl3\t$$~%[1.num],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})
+						|	| | (6,12)+%[1]+%[2]
+...		| source4 CONST |
+			REMEXTANDLOC
+			"bicl3\t$$~%[2.num],%[1],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})
+						|	| | (6,12)+%[1]+%[2]
+#endif REGVARS
+and sil $1==4	| source4-CONST source4 |
+			REMEXTANDLOC
+			allocate(%[1],REG)
+			"mcoml\t%[1],%[a]"
+			"bicl3\t%[a],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})
+						|	| | (9,15)+%[1]+%[2]
+...		| CONST source4 |
+			REMEXTANDLOC
+			"bicl3\t$$~%[1.num],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})
+						|	| | (6,12)+%[1]+%[2]
+...		| source4 CONST |
+			REMEXTANDLOC
+			"bicl3\t$$~%[2.num],%[1],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})
+						|	| | (6,12)+%[1]+%[2]
+and ste $1==4	| source4-CONST source4 |
+			remove(externals)
+			allocate(%[1],REG)
+			"mcoml\t%[1],%[a]"
+			"bicl3\t%[a],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| | (11,12)+%[1]+%[2]
+...		| CONST source4 |
+			remove(externals)
+			"bicl3\t$$~%[1.num],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| | (8,9)+%[1]+%[2]
+...		| source4 CONST |
+			remove(externals)
+			"bicl3\t$$~%[2.num],%[1],$2"
+			setcc({EXTERNAL4,$2})	|	| | (8,9)+%[1]+%[2]
+and defined($1) | |	remove(ALL)
+			move({CONST4,$1},R0)
+			"jsb\t.and"
+			erase(R0)		|	| |
+and !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.and"
+			erase(R0)		|	| |
+ior $1==4	| NC source4 source4 |
+			allocate(%[1],%[2],REG)
+			"bisl3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,4)+%[1]+%[2]
+...		| sreg4 source4 |
+			"bisl2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,4) + %[2]
+...		| source4 sreg4 |
+			"bisl2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,4) + %[1]
+#ifdef REGVARS
+ior stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			"bisl3\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+ior stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"bisl3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| |
+#ifdef REGVARS
+ior sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"bisl3\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+ior sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"bisl3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)}) |	| |
+ior ste $1==4	| source4 source4 |
+			remove(externals)
+			"bisl3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+ior defined($1) | |	remove(ALL)
+			move({CONST4, $1},R0)
+			"jsb\t.ior"
+			erase(R0)		|	| |
+ior !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.ior"
+			erase(R0)		|	| |
+xor $1==4	| source4 source4 |
+			allocate(%[1],%[2],REG)
+			"xorl3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,4)+%[1]+%[2]
+...		| NC sreg4 source4 |
+			"xorl2\t%[2],%[1]"
+			erase(%[1])
+			setcc(%[1])		| %[1]	| | (3,4) + %[2]
+...		| NC source4 sreg4 |
+			"xorl2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,4) + %[1]
+#ifdef REGVARS
+xor stl $1==4 && inreg($2)==2
+	| source4 source4 |
+			remove(regvar($2))
+			"xorl3\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+xor stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"xorl3\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| |
+#ifdef REGVARS
+xor sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"xorl3\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+xor sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"xorl3\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)}) |	| |
+xor ste $1==4	| source4 source4 |
+			remove(externals)
+			"xorl3\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+xor defined($1) | |	remove(ALL)
+			move({CONST4, $1},R0)
+			"jsb\t.xor"
+			erase(R0)		|	| |
+xor !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.xor"
+			erase(R0)		|	| |
+com $1==4	| source4 |
+			allocate(%[1],REG)
+			"mcoml\t%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+#ifdef REGVARS
+com stl $1==4 && inreg($2)==2
+		| source4 |
+			remove(regvar($2))
+			"mcoml\t%[1],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+com stl $1==4	| source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"mcoml\t%[1],$2(fp)"
+			setcc({LOCAL4,$2, 4}) |	| |
+#ifdef REGVARS
+com sil $1==4 && inreg($2)==2
+		| source4 |
+			REMEXTANDLOC
+			"mcoml\t%[1],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+com sil $1==4	| source4 |
+			REMEXTANDLOC
+			"mcoml\t%[1],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)}) |	| |
+com ste $1==4	| source4 |
+			remove(externals)
+			"mcoml\t%[1],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+com defined($1) | |	remove(ALL)
+			move({CONST4,$1},R0)
+			"jsb\t.com"
+			erase(R0)		|	| |
+com !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.com"
+			erase(R0)		|	| |
+rol $1==4	| source4 source4 |
+			allocate(%[1],REG=%[1])
+			"rotl\t%[a],%[2],%[a]"
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+#ifdef REGVARS
+rol stl $1==4 && inreg($2)==2
+		| source4 source4 |
+			remove(regvar($2))
+			"rotl\t%[1],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+rol stl $1==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"rotl\t%[1],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| |
+#ifdef REGVARS
+rol sil $1==4 && inreg($2)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"rotl\t%[1],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+rol sil $1==4	| source4 source4 |
+			REMEXTANDLOC
+			"rotl\t%[1],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+rol ste $1==4	| source4 source4 |
+			remove(externals)
+			"rotl\t%[1],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+rol !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.rol"
+			erase(R0)		|	| |
+ror $1==4	| source4-CONST source4 |
+			allocate(%[1],REG)
+			"subl3\t%[1],$$32,%[a]"
+			"rotl\t%[a],%[2],%[a]"
+			setcc(%[a])		| %[a]	| |
+...		| CONST source4 |
+			allocate(%[2],REG)
+			"rotl\t$$%(32-%[1.num]%),%[2],%[a]"
+			setcc(%[a])		| %[a]	| |
+#ifdef REGVARS
+ror stl $1==4 && inreg($2)==2
+		| source4-CONST source4 |
+			remove(regvar($2))
+			allocate(%[1],REG)
+			"subl3\t%[1],$$32,%[a]"
+			"rotl\t%[a],%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+...		| CONST source4 |
+			remove(regvar($2))
+			"rotl\t$$%(32-%[1.num]%),%[2],%(regvar($2)%)"
+			erase(regvar($2))
+			setcc(regvar($2))	|	| |
+#endif REGVARS
+ror stl $1==4	| source4-CONST source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			allocate(%[1],REG)
+			"subl3\t%[1],$$32,%[a]"
+			"rotl\t%[a],%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| |
+...		| CONST source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $2+3 && %[num]+%[size] > $2))
+			"rotl\t$$%(32-%[1.num]%),%[2],$2(fp)"
+			setcc({LOCAL4,$2, 4})	|	| |
+#ifdef REGVARS
+ror sil $1==4 && inreg($2)==2
+		| source4-CONST source4 |
+			REMEXTANDLOC
+			allocate(%[1],REG)
+			"subl3\t%[1],$$32,%[a]"
+			"rotl\t%[a],%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+...		| CONST source4 |
+			REMEXTANDLOC
+			"rotl\t$$%(32-%[1.num]%),%[2],(%(regvar($2)%))"
+			setcc({regdef4,regvar($2)})	|	| |
+#endif REGVARS
+ror sil $1==4	| source4-CONST source4 |
+			REMEXTANDLOC
+			allocate(%[1],REG)
+			"subl3\t%[1],$$32,%[a]"
+			"rotl\t%[a],%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+...		| CONST source4 |
+			REMEXTANDLOC
+			"rotl\t$$%(32-%[1.num]%),%[2],*$2(fp)"
+			setcc({displdef4,LB,tostring($2)})	|	| |
+ror ste $1==4	| source4-CONST source4 |
+			remove(externals)
+			allocate(%[1],REG)
+			"subl3\t%[1],$$32,%[a]"
+			"rotl\t%[a],%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+...		| CONST source4 |
+			remove(externals)
+			"rotl\t$$%(32-%[1.num]%),%[2],$2"
+			setcc({EXTERNAL4,$2})	|	| |
+ror !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.ror"
+			erase(R0)		|	| |
+com and $1==4 && $2==4	| source4 source4 |
+			allocate(%[1],%[2],REG)
+			"bicl3\t%[1],%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (4,4)+%[1]+%[2]
+...		| NC source4 sreg4 |
+			"bicl2\t%[1],%[2]"
+			erase(%[2])
+			setcc(%[2])		| %[2]	| | (3,4) + %[1]
+...		| source4 source4 |
+			remove(ALL)
+			"bicl3\t%[1],%[2],(sp)+" |	| | (4,7)+%[1]+%[2]
+#ifdef REGVARS
+com and stl $1==4 && $2==4 && inreg($3)==2
+		| source4 source4 |
+			remove(regvar($3))
+			"bicl3\t%[1],%[2],%(regvar($3)%)"
+			erase(regvar($3))
+			setcc(regvar($3))	|	| |
+#endif REGVARS
+com and stl $1==4 && $2==4	| source4 source4 |
+			remove(displaced)
+			remove(LOCALS, (%[num] <= $3+3 && %[num]+%[size] > $3))
+			"bicl3\t%[1],%[2],$3(fp)"
+			setcc({LOCAL4,$3, 4})	|	| |
+#ifdef REGVARS
+com and sil $1==4 && $2==4 && inreg($3)==2
+		| source4 source4 |
+			REMEXTANDLOC
+			"bicl3\t%[1],%[2],(%(regvar($3)%))"
+			setcc({regdef4,regvar($3)})	|	| |
+#endif REGVARS
+com and sil $1==4 && $2==4	| source4 source4 |
+			REMEXTANDLOC
+			"bicl3\t%[1],%[2],*$3(fp)"
+			setcc({displdef4,LB,tostring($3)})	|	| |
+com and ste $1==4 &&$2==4	| source4 source4 |
+			remove(externals)
+			"bicl3\t%[1],%[2],$3"
+			setcc({EXTERNAL4,$3})	|	| |
+com and $1==$2	| |	remove(ALL)
+			move({CONST4, $1}, R0)
+			"jsb\t.cmand"
+			erase(R0)		|	| |
+
+/********************************
+ * Group 10: Set instructions	*
+ ********************************/
+
+loc inn $1==0 && $2==4	| source4 |
+			allocate(%[1], REG)
+			"bicl3\t$$~1,%[1],%[a]"
+			setcc(%[a])		| %[a]	| |
+loc inn $2==4	| source4 |
+			allocate(%[1], REG)
+			"ashl\t$$%(0-$1%),%[1],%[a]"
+			"bicl2\t$$~1,%[a]"
+			setcc(%[a])		| %[a]	| |
+#ifdef LOCLABS
+inn $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],$$31"
+			"bgtru\t1f"
+			"mnegl\t%[1],%[a]"
+			"ashl\t%[a],%[2],%[a]"
+			"bicl2\t$$~1,%[a]\n1:"
+			setcc(%[a])
+			erase(%[a])		| %[a]	| |
+#endif
+loc inn zeq $2==4	| source4 |
+			remove(ALL)
+			"bitl\t%[1],$$%(1<<$1%)"
+			"jeql\t$3"		|	| |
+loc inn zne $2==4	| source4 |
+			remove(ALL)
+			"bitl\t%[1],$$%(1<<$1%)"
+			"jneq\t$3"		|	| |
+inn zeq $1==4	| source4 source4 |
+			remove(ALL)
+			allocate(REG)
+			"cmpl\t%[1],$$31"
+			"jgtru\t$2"
+			"ashl\t%[1],$$1,%[a]"
+			"bitl\t%[2],%[a]"
+			"jeql\t$2"		|	| |
+#ifdef LOCLABS
+inn zne $1==4	| source4 source4 |
+			remove(ALL)
+			allocate(REG)
+			"cmpl\t%[1],$$31"
+			"bgtru\t1f"
+			"ashl\t%[1],$$1,%[a]"
+			"bitl\t%[2],%[a]"
+			"jneq\t$2\n1:"		|	| |
+#endif
+loc inn zeq $2==8 && $1<32	/* First half of set. */
+		| REG REG |
+			remove(ALL)
+			"bitl\t%[1],$$%(1<<$1%)"
+			"jeql\t$3"		|	| |
+loc inn zeq $2==8 && $1>=32	/* Second half. */
+		| REG REG |
+			remove(ALL)
+			"bitl\t%[2],$$%(1<<($1-32)%)"
+			"jeql\t$3"		|	| |
+loc inn zne $2==8 && $1<32	/* First half of set. */
+		| REG REG |
+			remove(ALL)
+			"bitl\t%[1],$$%(1<<$1%)"
+			"jneq\t$3"		|	| |
+loc inn zne $2==8 && $1>=32	/* Second half. */
+		| REG REG |
+			remove(ALL)
+			"bitl\t%[2],$$%(1<<($1-32)%)"
+			"jneq\t$3"		|	| |
+inn defined($1) | |	remove(ALL)
+			move({CONST4, $1},R0)
+			"jsb\t.inn"
+			erase(R0)		| R1	| |
+inn !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.inn"
+			erase(R0)		| R1	| |
+set $1==4	| source4 | |	{CONST4,1} %[1] | sli 4 |
+set defined($1) | |	remove(ALL)
+			move({CONST4, $1},R0)
+			"jsb\t.setx"
+			erase(R0)		|	| |
+set !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.setx"
+			erase(R0)		|	| |
+
+/****************************************
+ * Group 11 : Array instructions	*
+ ****************************************/
+
+lae aar $2==4 && rom(1,3)==1	| | | | ads 4 adp 0-rom(1,1) |
+lae aar $2==4 && rom(1,3)==2	| | | | loc 1 sli 4 ads 4 adp 0-2*rom(1,1) |
+lae aar $2==4 && rom(1,3)==4	| | | | loc 2 sli 4 ads 4 adp 0-4*rom(1,1) |
+lae aar $2==4 && rom(1,3)==8	| | | | loc 3 sli 4 ads 4 adp 0-8*rom(1,1) |
+lae aar $2==4 && defined(rom(1,3)) && rom(1,1)==0
+		| source4 source4 |
+			allocate(%[1],REG)
+			"mull3\t$$%(rom(1,3)%),%[1],%[a]"
+			"addl2\t%[2],%[a]"
+			setcc(%[a])		| %[a]	| | (10,20)+%[1]+%[2]
+...		| NC source4 adispl |
+			allocate(%[1],REG)
+			"mull3\t$$%(rom(1,3)%),%[1],%[a]"
+			"addl2\t%[2.reg],%[a]"
+			setcc(%[a])
+			| {adispl,%[a],%[2.ind]}	| | (10,20)+%[1]
+...		| NC source4 ADDR_LOCAL |
+			allocate(%[1],REG)
+			"mull3\t$$%(rom(1,3)%),%[1],%[a]"
+			"addl2\tfp,%[a]"
+			setcc(%[a])
+			| {adispl,%[a],tostring(%[2.num])} | | (10,20)+%[1]
+...		| NC source4 ADDR_EXTERNAL |
+			allocate(%[1],REG)
+			"mull3\t$$%(rom(1,3)%),%[1],%[a]"
+			setcc(%[a])
+			| {adispl,%[a],%[2.ind]}	| | (7,16)+%[1]
+lae aar $2==4 && defined(rom(1,3))
+		| source4 adispl |
+			allocate(%[1],REG)
+			"mull3\t$$%(rom(1,3)%),%[1],%[a]"
+			"addl2\t%[2.reg],%[a]"
+			setcc(%[a])
+			| {adispl,%[a],
+				%[2.ind]+"+"+tostring(0-rom(1,1)*rom(1,3))}
+				| | (10,20)+%[1]
+...		| NC source4 source4 |
+			allocate(%[1],REG)
+			"mull3\t$$%(rom(1,3)%),%[1],%[a]"
+			"addl2\t%[2],%[a]"
+			setcc(%[a])
+			| {adispl,%[a],tostring(0-rom(1,1)*rom(1,3))}
+				| | (10,20)+%[1]+%[2]
+...		| NC source4 ADDR_EXTERNAL |
+			allocate(%[1],REG)
+			"mull3\t$$%(rom(1,3)%),%[1],%[a]"
+			setcc(%[a])
+			| {adispl,%[a],
+				%[2.ind]+"+"+tostring(0-rom(1,1)*rom(1,3))}
+				| | (7,16)+%[1]
+/* Sequence used by the CEM-compiler and the codegenerator. */
+loc sli ads $1==2 && $2==4 && $3==4
+		| reg4 ADDR_EXTERNAL |
+				| {aextind4,%[1],%[2.ind]} | |
+...		| reg4 adispl |
+				| {adisplind4,%[1],%[2.reg],%[2.ind]} | |
+...		| reg4 displ4 |
+				| {adispldefind4,%[1],%[2.reg],%[2.ind]} | |
+...		| reg4 EXTERNAL4 |
+				| {aextdefind4,%[1],%[2.ind]} | |
+loc sli ads $1==3 && $2==4 && $3==4
+		| reg4 ADDR_EXTERNAL |
+				| {aextind8,%[1],%[2.ind]} | |
+...		| reg4 adispl |
+				| {adisplind8,%[1],%[2.reg],%[2.ind]} | |
+...		| reg4 displ4 |
+				| {adispldefind8,%[1],%[2.reg],%[2.ind]} | |
+...		| reg4 EXTERNAL4 |
+				| {aextdefind8,%[1],%[2.ind]} | |
+aar $1==4	| |	remove(ALL)
+			"jsb\t.aar4"		 | R0	| |
+aar !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.aar"
+			erase(R0)		| R0	| |
+lae sar defined(rom(1,3))	| | |	| lae $1 aar $2 sti rom(1,3)	|
+lae lar defined(rom(1,3))	| | |	| lae $1 aar $2 loi rom(1,3)	|
+sar $1==4	| |	remove(ALL)
+			"jsb\t.sar4"		 |	 | |
+sar !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.sar"
+			erase(R0)		|	| |
+lar $1==4	| |	remove(ALL)
+			"jsb\t.lar4"		 |	 | |
+lar !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.lar"
+			erase(R0)		|	| |
+
+/****************************************
+ * Group 12 : Compare instructions	*
+ ****************************************/
+
+cmi $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"beql\t2f"
+			"bgtr\t1f"
+#else
+			"beql\t.+10"
+			"bgtr\t.+6"
+#endif
+			"incl\t%[a]"
+#ifdef LOCLABS
+			"brb\t2f\n1:"
+			"decl\t%[a]\n2:"
+#else
+			"brb\t.+4"
+			"decl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmi !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.cmi"
+			setcc(R0)
+			erase(R0)		| R0	| |
+cmf $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpf\t%[1],%[2]"
+#ifdef LOCLABS
+			"beql\t2f"
+			"bgtr\t1f"
+#else
+			"beql\t.+10"
+			"bgtr\t.+6"
+#endif
+			"incl\t%[a]"
+#ifdef LOCLABS
+			"brb\t2f\n1:"
+			"decl\t%[a]\n2:"
+#else
+			"brb\t.+4"
+			"decl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf $1==8	| source8 source8 |
+/* trouble, possible lack of scratch registers */
+			allocate(%[1],%[2],REG)
+			"cmpd\t%[1],%[2]"
+#ifdef LOCLABS
+			"blss\t2f"
+			"bgtr\t1f"
+#else
+			"blss\t.+8"
+			"bgtr\t.+11"
+#endif
+			"clrl\t%[a]"
+#ifdef LOCLABS
+			"brb\t3f\n2:"
+#else
+			"brb\t.+10"
+#endif
+			"movl\t$$1,%[a]"
+#ifdef LOCLABS
+			"brb\t3f\n1:"
+			"mnegl\t$$1,%[a]\n3:"
+#else
+			"brb\t.+5"
+			"mnegl\t$$1,%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.cmf"
+			setcc(R0)
+			erase(R0)		| R0	| |
+cmu $1==4	| |				|	| cmp |
+cmu !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.cmu"
+			setcc(R0)
+			erase(R0)		| R0	| |
+cmp		| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"beqlu\t2f"
+			"bgtru\t1f"
+#else
+			"beqlu\t.+10"
+			"bgtru\t.+6"
+#endif
+			"incl\t%[a]"
+#ifdef LOCLABS
+			"brb\t2f\n1:"
+			"decl\t%[a]\n2:"
+#else
+			"brb\t.+4"
+			"decl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cms $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bneq\t.+4"
+			"incl\t%[a]"
+#endif
+			setcc(%[a])
+			erase(%[a])		| %[a]	| |
+cms defined($1) | |	remove(ALL)
+			move({CONST1,$1},R0)
+			"jsb\t.cms"
+			setcc(R0)
+			erase(R0)		| R0	| |
+cms !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.cms"
+			setcc(R0)
+			erase(R0)		| R0	| |
+tlt		| source4 |
+			allocate(REG={CONST1,0})
+			test(%[1])
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgeq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 | 	| {CONST1,0}	| |
+tlt and $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"blss\t1f"
+			"clrl\t%[2]\n1:"
+#else
+			"blss\t.+4"
+			"clrl\t%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tlt ior $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"bisl2\t$$1,%[2]\n1:"
+#else
+			"bgeq\t.+4"
+			"bisl2\t$$1,%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tle		| source4 |
+			allocate(REG={CONST1,0})
+			test(%[1])
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgtr\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 |		| %[1]	| teq |
+tle and $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bleq\t1f"
+			"clrl\t%[2]\n1:"
+#else
+			"bleq\t.+4"
+			"clrl\t%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tle ior $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"bisl2\t$$1,%[2]\n1:"
+#else
+			"bgtr\t.+4"
+			"bisl2\t$$1,%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tge		| source4 |
+			allocate(REG={CONST1,0})
+			test(%[1])
+#ifdef LOCLABS
+			"blss\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blss\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 |	| {CONST1,1} | |
+tge and $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"clrl\t%[2]\n1:"
+#else
+			"bgeq\t.+4"
+			"clrl\t%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tge ior $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"blss\t1f"
+			"bisl2\t$$1,%[2]\n1:"
+#else
+			"blss\t.+4"
+			"bisl2\t$$1,%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tgt		| source4 |
+			allocate(REG={CONST1,0})
+			test(%[1])
+#ifdef LOCLABS
+			"bleq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bleq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 |	| %[1]	| tne |
+tgt and $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"clrl\t%[2]\n1:"
+#else
+			"bgtr\t.+4"
+			"clrl\t%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tgt ior $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bleq\t1f"
+			"bisl2\t$$1,%[2]\n1:"
+#else
+			"bleq\t.+4"
+			"bisl2\t$$1,%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+teq		| source1or2or4 |
+			allocate(REG={CONST1,0})
+			test(%[1])
+#ifdef LOCLABS
+			"bneq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bneq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+teq and $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"beql\t1f"
+			"clrl\t%[2]\n1:"
+#else
+			"beql\t.+4"
+			"clrl\t%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+teq ior $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bneq\t1f"
+			"bisl2\t$$1,%[2]\n1:"
+#else
+			"bneq\t.+4"
+			"bisl2\t$$1,%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tne		| source1or2or4 |
+			allocate(REG={CONST1,0})
+			test(%[1])
+#ifdef LOCLABS
+			"beql\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"beql\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+tne and $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"bneq\t1f"
+			"clrl\t%[2]\n1:"
+#else
+			"bneq\t.+4"
+			"clrl\t%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+tne ior $2==4	| source4 sreg4 |
+			test(%[1])
+#ifdef LOCLABS
+			"beql\t1f"
+			"bisl2\t$$1,%[2]\n1:"
+#else
+			"beql\t.+4"
+			"bisl2\t$$1,%[2]"
+#endif
+			setcc(%[2])
+			erase(%[2])		| %[2]	| |
+cmi tlt $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bleq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bleq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 source1or2 |
+						| %[2] %[1] | cmu 4 tlt |
+cmi tle $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"blss\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blss\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		|  %[a]  | |
+...		| NC source1or2 source1or2 |
+						| %[2] %[1] | cmu 4 tle |
+cmi teq $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bneq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 source1or2 |
+						| %[2] %[1] | cmu 4 teq |
+cmi tne $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"beql\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"beql\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 source1or2 |
+						| %[2] %[1] | cmu 4 tne |
+cmi tge $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgtr\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 source1or2 |
+						| %[2] %[1] | cmu 4 tge |
+cmi tgt $1==4	| source4 source4 |
+			allocate(REG={CONST4,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgeq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1or2 source1or2 |
+						| %[2] %[1] | cmu 4 tgt |
+cmi tlt and $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"blss\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"blss\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tle and $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bleq\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"bleq\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi teq and $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"beql\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"beql\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tne and $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"bneq\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tge and $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"bgeq\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tgt and $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"bgtr\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tlt ior $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"bgeq\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tle ior $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"bgtr\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi teq ior $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"bneq\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tne ior $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"beql\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"beql\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tge ior $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"blss\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"blss\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmi tgt ior $1==4 && $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bleq\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"bleq\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmf tlt $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpf\t%[1],%[2]"
+#ifdef LOCLABS
+			"bleq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bleq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tle $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpf\t%[1],%[2]"
+#ifdef LOCLABS
+			"blss\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blss\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		|  %[a]  | |
+cmf teq $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpf\t%[1],%[2]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bneq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tne $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpf\t%[1],%[2]"
+#ifdef LOCLABS
+			"beql\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"beql\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tge $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpf\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgtr\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tgt $1==4	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpf\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgeq\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tlt $1==8	| source8 source8 |
+			allocate(%[1],%[2],REG)
+			"cmpd\t%[1],%[2]"
+#ifdef LOCLABS
+			"bleq\t1f"
+			"movl\t$$1,%[a]"
+			"brb\t2f\n1:"
+			"clrl\t%[a]\n2:"
+#else
+			"bleq\t.+9"
+			"movl\t$$1,%[a]"
+			"brb\t.+4"
+			"clrl\t%[a]"
+#endif
+			
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tle $1==8	| source8 source8 |
+			allocate(%[1],%[2],REG)
+			"cmpd\t%[1],%[2]"
+#ifdef LOCLABS
+			"blss\t1f"
+			"movl\t$$1,%[a]"
+			"brb\t2f\n1:"
+			"clrl\t%[a]\n2:"
+#else
+			"blss\t.+9"
+			"movl\t$$1,%[a]"
+			"brb\t.+4"
+			"clrl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		|  %[a]  | |
+cmf teq $1==8	| source8 source8 |
+			allocate(%[1],%[2],REG)
+			"cmpd\t%[1],%[2]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"movl\t$$1,%[a]"
+			"brb\t2f\n1:"
+			"clrl\t%[a]\n2:"
+#else
+			"bneq\t.+9"
+			"movl\t$$1,%[a]"
+			"brb\t.+4"
+			"clrl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tne $1==8	| source8 source8 |
+			allocate(%[1],%[2],REG)
+			"cmpd\t%[1],%[2]"
+#ifdef LOCLABS
+			"beql\t1f"
+			"movl\t$$1,%[a]"
+			"brb\t2f\n1:"
+			"clrl\t%[a]\n2:"
+#else
+			"beql\t.+9"
+			"movl\t$$1,%[a]"
+			"brb\t.+4"
+			"clrl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tge $1==8	| source8 source8 |
+			allocate(%[1],%[2],REG)
+			"cmpd\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgtr\t1f"
+			"movl\t$$1,%[a]"
+			"brb\t2f\n1:"
+			"clrl\t%[a]\n2:"
+#else
+			"bgtr\t.+9"
+			"movl\t$$1,%[a]"
+			"brb\t.+4"
+			"clrl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmf tgt $1==8	| source8 source8 |
+			allocate(%[1],%[2],REG)
+			"cmpd\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgeq\t1f"
+			"movl\t$$1,%[a]"
+			"brb\t2f\n1:"
+			"clrl\t%[a]\n2:"
+#else
+			"bgeq\t.+9"
+			"movl\t$$1,%[a]"
+			"brb\t.+4"
+			"clrl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+/* Remember that cmu was replaced by cmp. */
+cmp tlt 	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"blequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1 source1 |
+			allocate(REG={CONST1,0})
+			"cmpb\t%[1],%[2]"
+#ifdef LOCLABS
+			"blequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source2 source2 |
+			allocate(REG={CONST1,0})
+			"cmpw\t%[1],%[2]"
+#ifdef LOCLABS
+			"blequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmp tle 	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"blssu\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blssu\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1 source1 |
+			allocate(REG={CONST1,0})
+			"cmpb\t%[1],%[2]"
+#ifdef LOCLABS
+			"blssu\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blssu\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source2 source2 |
+			allocate(REG={CONST1,0})
+			"cmpw\t%[1],%[2]"
+#ifdef LOCLABS
+			"blssu\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"blssu\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmp teq 	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bnequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bnequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1 source1 |
+			allocate(REG={CONST1,0})
+			"cmpb\t%[1],%[2]"
+#ifdef LOCLABS
+			"bnequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bnequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source2 source2 |
+			allocate(REG={CONST1,0})
+			"cmpw\t%[1],%[2]"
+#ifdef LOCLABS
+			"bnequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bnequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmp tne 	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"beqlu\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"beqlu\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1 source1 |
+			allocate(REG={CONST1,0})
+			"cmpb\t%[1],%[2]"
+#ifdef LOCLABS
+			"beqlu\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"beqlu\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source2 source2 |
+			allocate(REG={CONST1,0})
+			"cmpw\t%[1],%[2]"
+#ifdef LOCLABS
+			"beqlu\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"beqlu\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmp tge 	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgtru\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgtru\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1 source1 |
+			allocate(REG={CONST1,0})
+			"cmpb\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgtru\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgtru\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source2 source2 |
+			allocate(REG={CONST1,0})
+			"cmpw\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgtru\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgtru\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmp tgt 	| source4 source4 |
+			allocate(REG={CONST1,0})
+			"cmpl\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source1 source1 |
+			allocate(REG={CONST1,0})
+			"cmpb\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+...		| NC source2 source2 |
+			allocate(REG={CONST1,0})
+			"cmpw\t%[1],%[2]"
+#ifdef LOCLABS
+			"bgequ\t1f"
+			"incl\t%[a]\n1:"
+#else
+			"bgequ\t.+4"
+			"incl\t%[a]"
+#endif
+			erase(%[a])
+			setcc(%[a])		| %[a]	| |
+cmp teq and $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"beql\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"beql\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmp tne and $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"clrl\t%[3]\n1:"
+#else
+			"bneq\t.+4"
+			"clrl\t%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmp teq ior $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"bneq\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"bneq\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cmp tne ior $3==4
+		| source4 source4 sreg4 |
+			"cmpl\t%[2],%[1]"
+#ifdef LOCLABS
+			"beql\t1f"
+			"bisl2\t$$1,%[3]\n1:"
+#else
+			"beql\t.+7"
+			"bisl2\t$$1,%[3]"
+#endif
+			setcc(%[3])
+			erase(%[3])		| %[3]	| |
+cms teq $1==4	|	|			|	| cmp teq	|
+cms tne $1==4	|	|			|	| cmp tne	|
+
+/****************************************
+ * Group 13 : Branch instructions	*
+ ****************************************/
+
+bra		| STACK |
+			"jbr\t$1"		 |	 | |
+blt		| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jgtr\t$1"		|	| |
+...		| NC source2 source2 STACK |
+			"cmpw\t%[1],%[2]"
+			"jgtru\t$1"		|	| |
+...		| NC source1 source1 STACK |
+			"cmpb\t%[1],%[2]"
+			"jgtru\t$1"		|	| |
+...		| NC source4 STACK |
+			"cmpl\t%[1],(sp)+"
+			"jgtr\t$1"		|	| |
+...		| STACK |
+			"cmpl\t(sp)+,(sp)+"
+			"jgtr\t$1"		|	| |
+ble		| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jgeq\t$1"		|	| |
+...		| NC source2 source2 STACK |
+			"cmpw\t%[1],%[2]"
+			"jgequ\t$1"		|	| |
+...		| NC source1 source1 STACK |
+			"cmpb\t%[1],%[2]"
+			"jgequ\t$1"		|	| |
+...		| NC source4 STACK |
+			"cmpl\t%[1],(sp)+"
+			"jgeq\t$1"		|	| |
+...		| STACK |
+			"cmpl\t(sp)+,(sp)+"
+			"jgeq\t$1"		|	| |
+beq		| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jeql\t$1"		|	| |
+...		| NC source2 source2 STACK |
+			"cmpw\t%[1],%[2]"
+			"jeqlu\t$1"		|	| |
+...		| NC source1 source1 STACK |
+			"cmpb\t%[1],%[2]"
+			"jeqlu\t$1"		|	| |
+...		| NC source4 STACK |
+			"cmpl\t%[1],(sp)+"
+			"jeql\t$1"		|	| |
+...		| STACK |
+			"cmpl\t(sp)+,(sp)+"
+			"jeql\t$1"		|	| |
+bne		| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jneq\t$1"		|	| |
+...		| NC source2 source2 STACK |
+			"cmpw\t%[1],%[2]"
+			"jnequ\t$1"		|	| |
+...		| NC source1 source1 STACK |
+			"cmpb\t%[1],%[2]"
+			"jnequ\t$1"		|	| |
+...		| NC source4 STACK |
+			"cmpl\t%[1],(sp)+"
+			"jneq\t$1"		|	| |
+...		| STACK |
+			"cmpl\t(sp)+,(sp)+"
+			"jneq\t$1"		|	| |
+bge		| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jleq\t$1"		|	| |
+...		| NC source2 source2 STACK |
+			"cmpw\t%[1],%[2]"
+			"jlequ\t$1"		|	| |
+...		| NC source1 source1 STACK |
+			"cmpb\t%[1],%[2]"
+			"jlequ\t$1"		|	| |
+...		| NC source4 STACK |
+			"cmpl\t%[1],(sp)+"
+			"jleq\t$1"		|	| |
+...		| STACK |
+			"cmpl\t(sp)+,(sp)+"
+			"jleq\t$1"		|	| |
+bgt		| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jlss\t$1"		|	| |
+...		| NC source2 source2 STACK |
+			"cmpw\t%[1],%[2]"
+			"jlssu\t$1"		|	| |
+...		| NC source1 source1 STACK |
+			"cmpb\t%[1],%[2]"
+			"jlssu\t$1"		|	| |
+...		| NC source4 STACK |
+			"cmpl\t%[1],(sp)+"
+			"jlss\t$1"		|	| |
+...		| STACK |
+			"cmpl\t(sp)+,(sp)+"
+			"jlss\t$1"		|	| |
+zlt		| source4 STACK |
+			test(%[1])
+			"jlss\t$1"
+			samecc			|	| |
+...		| NC source1or2 |	|	| |
+zle		| source4 STACK |
+			test(%[1])
+			"jleq\t$1"
+			samecc			|	| |
+...		| NC source1or2 |	| %[1]	| zeq $1 |
+zeq		| source1or2or4 STACK |
+			test(%[1])
+			"jeql\t$1"
+			samecc			|	| |
+zne		| source1or2or4 STACK |
+			test(%[1])
+			"jneq\t$1"
+			samecc			|	| |
+zge		| source4 STACK |
+			test(%[1])
+			"jgeq\t$1"
+			samecc			|	| |
+...		| NC source1or2 |	|	| bra $1 |
+zgt		| source4 STACK |
+			test(%[1])
+			"jgtr\t$1"
+			samecc			|	| |
+...		| NC source1or2 |	| %[1]	| zne $1 |
+cmf zlt $1==4	| source4 source4 STACK |
+			"cmpf\t%[1],%[2]"
+			"jgtr\t$2"		 |	 | |
+cmf zle $1==4	| source4 source4 STACK |
+			"cmpf\t%[1],%[2]"
+			"jgeq\t$2"		 |	 | |
+cmf zne $1==4	| source4 source4 STACK |
+			"cmpf\t%[1],%[2]"
+			"jneq\t$2"		 |	 | |
+cmf zeq $1==4	| source4 source4 STACK |
+			"cmpf\t%[1],%[2]"
+			"jeql\t$2"		 |	 | |
+cmf zge $1==4	| source4 source4 STACK |
+			"cmpf\t%[1],%[2]"
+			"jleq\t$2"		 |	 | |
+cmf zgt $1==4	| source4 source4 STACK |
+			"cmpf\t%[1],%[2]"
+			"jlss\t$2"		 |	 | |
+cmf zlt $1==8	| source8 source8 |
+			remove(ALL)
+			"cmpd\t%[1],%[2]"
+			"jgtr\t$2"		 |	 | |
+cmf zle $1==8	| source8 source8 |
+			remove(ALL)
+			"cmpd\t%[1],%[2]"
+			"jgeq\t$2"		 |	 | |
+cmf zne $1==8	| source8 source8 |
+			remove(ALL)
+			"cmpd\t%[1],%[2]"
+			"jneq\t$2"		 |	 | |
+cmf zeq $1==8	| source8 source8 |
+			remove(ALL)
+			"cmpd\t%[1],%[2]"
+			"jeql\t$2"		 |	 | |
+cmf zge $1==8	| source8 source8 |
+			remove(ALL)
+			"cmpd\t%[1],%[2]"
+			"jleq\t$2"		 |	 | |
+cmf zgt $1==8	| source8 source8 |
+			remove(ALL)
+			"cmpd\t%[1],%[2]"
+			"jlss\t$2"		 |	 | |
+cmp zlt 	| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jgtru\t$2"		 |	 | |
+...		| NC source1or2 source1or2 | | %[2] %[1] | blt $2 |
+cmp zle 	| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jgequ\t$2"		 |	 | |
+...		| NC source1or2 source1or2 | | %[2] %[1] | ble $2 |
+cmp zne 	| |					| | bne $2 |
+cmp zeq 	| |					| | beq $2 |
+cmp zge 	| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jlequ\t$2"		 |	 | |
+...		| NC source1or2 source1or2 | | %[2] %[1] | bge $2 |
+cmp zgt 	| source4 source4 STACK |
+			"cmpl\t%[1],%[2]"
+			"jlssu\t$2"		 |	 | |
+...		| NC source1or2 source1or2 | | %[2] %[1] | bgt $2 |
+cms zeq $1==4	| |				|	| cmp zeq $2 |
+cms zne $1==4	| |				|	| cmp zne $2 |
+
+/************************************************
+ * Group 14 : Procedure call instructions	*
+ ************************************************/
+
+cai		| |	remove(ALL)
+			"jsb\t*(sp)+"		 |	 | | (2,10)
+...		| reg4 |
+			remove(ALL)
+			"jsb\t(%[1])"		 |	 | | (2,7)
+cal		| |	remove(ALL)
+			"jsb\t$1"		 |	 | |
+lfr $1==4	| |				| R0	| |
+lfr $1==8	| |				| QR0	| |
+asp ret $2==0	| |				|	| ret 0 |
+ass ret $2==0	| |				|	| ret 0 |
+asp lfr ret $2==$3 | |				|	| ret 0 |
+ass lfr ret $2==$3 | |				|	| ret 0 |
+lfr ret $1==$2 | |				|	| ret 0 |
+#ifdef REGVARS
+ret $1==0	| |	remove(ALL)
+			return			|	| |
+#else REGVARS
+ret $1==0	| |	remove(ALL)
+			"movl\tfp,sp"
+			"movl\t(sp)+,fp"
+			"rsb"			|	| |
+#endif REGVARS
+ret $1==4	| bigsource4 |
+			move(%[1],R0)		| | ret 0 |
+ret $1==8	| bigsource8 |
+			move(%[1],QR0)		| | ret 0 |
+...		| bigsource4 bigsource4 |
+			move(%[1],R0)
+			move(%[2],R1)		| | ret 0 |
+
+/********************************
+ * Group 15 : Miscellaneous	*
+ ********************************/
+
+#ifdef REGVARS
+asp $1==4	| bigsource4 - regch4 |		|	| |
+#else REGVARS
+asp $1==4	| NC bigsource4 |	|	| |
+#endif REGVARS
+...		| |	remove(ALL)
+			"tstl\t(sp)+"		|	| | (2,7)
+asp $1>0	| |	remove(ALL)
+			"addl2\t$$$1,sp"	|	| |
+asp $1==(0-4)	| |				| {CONST4,0} | |
+asp $1==(0-8)	| |				| {CONST8,"0"} | |
+asp		| |	remove(ALL)
+			"subl2\t$$%(0-$1%),sp"	|	| |
+ass $1==4	| source4 |
+			remove(ALL)
+			"addl2\t%[1],sp"	|	| |
+ass !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R2)
+			"jsb\t.ass"
+			erase(R2)		|	| |
+blm $1==4	| nonexist1 nonexist1 |
+			remove(ALL)
+			"movl\t%[2],%[1]"	|	| |
+blm $1==8	| nonexist1 nonexist1 |
+			remove(ALL)
+			"movq\t%[2],%[1]"	|	| |
+blm $1==12	| sreg4 sreg4 |
+			remove(ALL)
+			"movl\t(%[2])+,(%[1])+"
+			"movq\t(%[2]),(%[1])"
+			erase(%[1]) erase(%[2])	|	| |
+blm $1==16	| sreg4 sreg4 |
+			remove(ALL)
+			"movq\t(%[2])+,(%[1])+"
+			"movq\t(%[2]),(%[1])"
+			erase(%[1]) erase(%[2])	|	| |
+blm		| sreg4 sreg4 |
+			remove(ALL)
+			allocate(REG={CONST1, $1/4})
+#ifdef LOCLABS
+			"1:\nmovl\t(%[2])+,(%[1])+"
+			"sobgtr\t%[a],1b"
+#else
+			"\nmovl\t(%[2])+,(%[1])+"
+			"sobgtr\t%[a],.-3"
+#endif
+			erase(%[1]) erase(%[2]) erase(%[a])
+						|	| |
+bls $1==4	| |
+			remove(ALL)
+			move({CONST1,4},R0)
+			"jsb\t.bls"
+			erase(R0)		|	| |
+bls !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.bls"
+			erase(R0)		|	| |
+csa $1==4	| |	remove(ALL)
+			"jmp\t.csa4"		|	 | |
+csa !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jmp\t.csa"
+			erase(R0)		|	| |
+csb $1==4	| |	remove(ALL)
+			"jmp\t.csb4"		 |	 | |
+csb !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jmp\t.csb"
+			erase(R0)		|	| |
+dch		| |	| 	| loi 4 |
+dup stl $1==4	| |	|	| stl $2 lol $2 |
+#ifdef REGVARS
+dup sil $1==4 && inreg($2)==2
+		| bigsource4 |
+			REMEXTANDLOC
+			move(%[1],{regdef4,regvar($2)})
+						| {regdef4,regvar($2)}	| |
+#endif REGVARS
+dup $1==4	| reg4+regdef4 |		| %[1] %[1]	| |
+#ifdef REGVARS
+dup $1==8	| bigsource8-regch8 |		| %[1] %[1]	| |
+#else REGVARS
+dup $1==8	| bigsource8 |			| %[1] %[1]	| |
+#endif REGVARS
+dup		| |	remove(ALL)
+			allocate(REG,REG={CONST1,$1/4})
+			"addl3\tsp,$$$1,%[a]"
+#ifdef LOCLABS
+			"1:\nmovl\t-(%[a]),-(sp)"
+			"sobgtr\t%[b],1b"
+#else
+			"movl\t-(%[a]),-(sp)"
+			"sobgtr\t%[b],.-3"
+#endif
+			erase(%[b])		|	| |
+dus $1==4	| source4 |
+			remove(ALL)
+			allocate(REG,REG)
+			"ashl\t$$-2,%[1],%[b]"
+			"addl3\tsp,%[1],%[a]"
+#ifdef LOCLABS
+			"1:\nmovl\t-(%[a]),-(sp)"
+			"sobgtr\t%[b],1b"
+#else
+			"movl\t-(%[a]),-(sp)"
+			"sobgtr\t%[b],.-3"
+#endif
+						|	| |
+dus !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.dus"
+			erase(R0)		|	| |
+exg $1==4	| bigsource4 bigsource4 |	| %[1] %[2] | |
+exg $1==8	| bigsource8 bigsource8 |	| %[1] %[2] | |
+exg defined($1) | |	remove(ALL)
+			move({CONST4,$1},R0)
+			"jsb\t.exg"
+			erase(R0)		|	| |
+exg !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.exg"
+			erase(R0)		|	| |
+fil		| |	"movl\t$$$1,hol0+4"	|	| |
+lim		| |	allocate(REG)
+			"movl\t.trpim,%[a]"	| %[a]	| |
+lin		| |	"movl\t$$$1,hol0"	|	| |
+lni		| |	"incl\thol0"		|	| |
+gto		| |	remove(ALL)
+			"pushl\t$$$1"
+			"jmp\t.gto"		|	| |
+lor $1==0	| |				| LB	| |
+lor $1==1	| |	remove(ALL)
+			allocate(REG)
+			"movl\tsp,%[a]"		| %[a]  | |
+lor $1==2	| |	allocate(REG)
+			"movl\t.reghp,%[a]"	| %[a] | |
+lpb		| bigsource4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.lpb"
+			erase(R0)		| R0	| |
+mon		| |	remove(ALL)
+			"jsb\t.mon"		|	| |
+nop		| |	remove(ALL)
+			"jsb\t.nop"		|	| |
+#ifdef DORCK
+rck $1==4	| |	remove(ALL)
+			"jsb\t.rck4"		|	| |
+rck !defined($1) | source4 |
+			remove(ALL)
+			move(%[1],R0)
+			"jsb\t.rck"
+			erase(R0)		|	| |
+#else DORCK
+#ifdef REGVARS
+rck defined($1)	| bigsource4-regch4 |		|	| |
+rck !defined($1) | bigsource4-regch4 bigsource4-regch4 | | | |
+#else REGVARS
+rck defined($1)	| bigsource4 |		|	| |
+rck !defined($1) | bigsource4 bigsource4 |	|	| |
+#endif REGVARS
+#endif DORCK
+rtt		| |				|	| ret 0 |
+sig		| |	remove(ALL)
+			"jsb\t.sig"		 |	 | |
+sim		| |	remove(ALL)
+			"jsb\t.sim"		 |	 | |
+str $1==0	| source4 |
+			remove(ALL)
+			"movl\t%[1],fp" 	 |	 | |
+str $1==1	| source4 |
+			remove(ALL)
+			"movl\t%[1],sp" 	 |	 | |
+str $1==2	| |	remove(ALL)
+			"jsb\t.strhp"		 |	 | |
+trp		| |	remove(ALL)
+			"jsb\t.trp"		 |	 | |
+
+/********************************
+ * Coercions:			*
+ *				*
+ * A: From source to register,	*
+ *    from nonexist to source.	*
+ ********************************/
+
+| ADDR_EXTERNAL	| 				| {DOUBLE,%[1.ind]} | |
+| source1 |	allocate(%[1],REG=%[1]) 	| %[a]	| |
+| source2 |	allocate(%[1],REG=%[1]) 	| %[a]	| |
+| bigsource4 |	allocate(%[1],REG=%[1]) 	| %[a]	| |
+| bigsource8 |	allocate(%[1],QREG=%[1])	| %[a]	| |
+
+/********************************
+ * B: From STACK to register	*
+ ********************************/
+
+| STACK |	allocate(REG)
+		"movl\t(sp)+,%[a]"
+		setcc(%[a])			| %[a]	| | (3,7)
+| STACK |	allocate(QREG)
+		"movq\t(sp)+,%[a]"
+		setcc(%[a])			| %[a]	| | (3,10)
+| STACK |	allocate(REG)
+		"movl\t(sp)+,%[a]"
+		setcc(%[a])			| {adispl,%[a],"0"} | | (3,7)
+
+/****************
+ * C: General	*
+ ****************/
+
+| regdef8 |	| {displ4,%[1.reg],"4"} {regdef4,%[1.reg]}		| |
+| displ8 |	| {displ4,%[1.reg],%[1.ind]+"+4"}
+		  {displ4,%[1.reg],%[1.ind]}				| |
+| LOCAL8 |	| {LOCAL4,%[1.num]+4,4} {LOCAL4,%[1.num],4}		| |
+| EXTERNAL8 |	| {EXTERNAL4,%[1.ind]+"+4"} {EXTERNAL4,%[1.ind]}	| |
+| QREG |	| %[1.2] %[1.1] 			| |
+| regdef4 |	| {displ4,%[1.reg],"0"} 		| |
+| ADDR_LOCAL |	| {adispl,LB,tostring(%[1.num])}	| |
+| reg4 | 	| {adispl,%[1],"0"}			| |
+| LOCAL4 |	| {displ4,LB,tostring(%[1.num])}	| |
+| nonexist+source4-reg4-adispl-ADDR_LOCAL |
+		allocate(%[1],REG=%[1]) | {adispl,%[a],"0"} | |
+
+MOVES:
+(CONST %[num]==0, source1,	"clrb\t%[2]",		(2,4)+%[2])
+(CONST %[num]==0, source2,	"clrw\t%[2]",		(2,4)+%[2])
+(CONST %[num]==0, source4,	"clrl\t%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST %[num]<0 && ufit(0-%[num],6), source2,
+				"mnegw\t$$%(0-%[1.num]%),%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST ufit(%[num],8) && !ufit(%[num],6), source2,
+				"movzbw\t%[1],%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST sfit(%[num],8) && !ufit(%[num],6), source2,
+				"cvtbw\t%[1],%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST %[num]<0 && ufit(0-%[num],6), source4,
+				"mnegl\t$$%(0-%[1.num]%),%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST ufit(%[num],8) && !ufit(%[num],6), source4,
+				"movzbl\t%[1],%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST sfit(%[num],8) && !ufit(%[num],6), source4,
+				"cvtbl\t%[1],%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST ufit(%[num],16) && !ufit(%[num],6), source4,
+				"movzwl\t%[1],%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST sfit(%[num],16) && !ufit(%[num],6), source4,
+				"cvtwl\t%[1],%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(CONST8 %[ind]=="0", source8,	"clrq\t%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(FCONST8 %[num]==0, source8,	"clrq\t%[2]"
+				setcc(%[2]),		(2,4)+%[2])
+(FCONST8, source8,		"movd\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+#ifdef REGVARS
+/* Tokens with side effects should not be remembered. */
+(reginc1+regdec1,reg4,		"movzbl\t%[1],%[2]"
+				setcc(%[2]) erase(%[2]),(3,4)+%[1])
+(reginc2+regdec2,reg4,		"movzwl\t%[1],%[2]"
+				setcc(%[2]) erase(%[2]),(3,4)+%[1])
+(reginc4+regdec4,reg4,		"movl\t%[1],%[2]"
+				setcc(%[2]) erase(%[2]),(3,4)+%[1])
+(reginc8+regdec8,reg8,		"movq\t%[1],%[2]"
+				setcc(%[2]) erase(%[2]),(3,7)+%[1])
+#endif REGVARS
+(source8, source8,		"movq\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source4, source4,		"movl\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source2, source2,		"movw\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source1, source1,		"movb\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source1, source2,		"movzbw\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source1, source4,		"movzbl\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source2, source4,		"movzwl\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source2, source1,		"cvtwb\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source4, source1,		"cvtlb\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(source4, source2,		"cvtlw\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(aind1, source4,		"movab\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(aind2, source4,		"movaw\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(aind4, source4,		"moval\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(aind8, source4,		"movaq\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+(nonexist1, source4,		"movab\t%[1],%[2]"
+				setcc(%[2]),		(3,4)+%[1]+%[2])
+TESTS:
+(source1,	"tstb\t%[1]"		 ,(2,4) + %[1])
+(source2,	"tstw\t%[1]"		 ,(2,4) + %[1])
+(source4,	"tstl\t%[1]"		 ,(2,4) + %[1])
+
+STACKS:
+
+(CONST %[num]==0, ,
+		"clrl\t-(sp)",		(2,7))
+(CONST %[num]<0 && ufit(0-%[num],6), ,
+		"mnegl\t$$%(0-%[1.num]%),-(sp)",
+					(2,7) + %[1])
+(CONST ufit(%[num],6), ,
+		"pushl\t%[1]",		(2,7) + %[1])
+(CONST8 %[ind]=="0", ,
+		"clrq\t-(sp)",		(2,10))
+(CONST sfit(%[num],8), ,
+		"cvtbl\t%[1],-(sp)",	(3,7) + %[1])
+(source1, ,	"movzbl\t%[1],-(sp)",	(3,7) + %[1])
+(CONST sfit(%[num],16), ,
+		"cvtwl\t%[1],-(sp)",	(3,7) + %[1])
+(source2, ,	"movzwl\t%[1],-(sp)",	(3,7) + %[1])
+(source4, ,	"pushl\t%[1]"
+		setcc(%[1]),		(2,7) + %[1])
+(source8, ,	"movq\t%[1],-(sp)"
+		setcc(%[1]),		(3,10)+ %[1])
+(nonexist1, ,	"pushal\t%[1]",		(2,7) + %[1])
+(FCONST8 %[num]==0, ,
+		"clrq\t-(sp)",		(2,10))
+(FCONST8, ,	"movd\t%[1],-(sp)",	(3,10) + %[1])
+(aind1, ,	"pushab\t%[1]",		(2,7) + %[1])
+(aind2, ,	"pushaw\t%[1]",		(2,7) + %[1])
+(aind4, ,	"pushal\t%[1]",		(2,7) + %[1])
+(aind8, ,	"pushaq\t%[1]",		(2,7) + %[1])