diff --git a/WEGA/contrib/lcc/cmd/c2/c21.c b/WEGA/contrib/lcc/cmd/c2/c21.c
new file mode 100644
index 0000000..43febb8
--- /dev/null
+++ b/WEGA/contrib/lcc/cmd/c2/c21.c
@@ -0,0 +1,1429 @@
+ /*
+ * C object code improver-- second part
+ */
+
+#include "c2.h"
+#define NIL (char *)0
+
+unsigned hexa ();
+rmove()
+{
+	register struct node *p;
+	register char *p1, *p2p;
+	static char p2[100];
+	register int r;
+	register  r1, i;
+
+	if(debug > 1)
+		printf("rmove works\n");
+	for (p=first.forw; p!=0; p = p->forw) {
+
+	if(debug > 2){
+		printf("rmove works on:");
+		dbprint(p);
+	}
+	switch (p->op) {
+
+	case LD:
+	case LDK:
+		dualop(p);
+		if(equstr(regs[RT1],regs[RT2])) {
+			if(debug > 2)
+				puts("elim 1");
+			elim(p);
+			++redunm;
+			break;
+		}
+ld1:
+		if (( r = findrand(regs[RT2],regt[RT2])) >= 0 && regt[r]==regt[RT2])
+			if( r == isreg(regs[RT1]) && regt[r]==regt[RT1]) {
+				elim(p);
+			if(debug > 2)
+				puts("elim 2");
+				++redunm;
+				break;
+			}
+
+		if((r = findrand(regs[RT1],regt[RT1])) >= 0 && regt[r]==regt[RT1])
+			if(r==isreg(regs[RT2]) && regt[r]==regt[RT2]) {
+				if(debug > 2)
+					puts("elim 3");
+				elim(p);
+				++redunm;
+				break;
+			}
+
+clr:
+		if((r=isreg(regs[RT1]))>=0 && regp[r]!=0 && regt[r]==regt[RT1]){
+			if(debug > 2)
+				puts("elim 4");
+			if(!teil(regs[RT1],regs[RT2]))
+				elim(regp[r]);
+			clrr(r,regt[RT1]);
+			if(isreg(ccloc)==(r))
+				clrcc();
+		}
+
+		if ((p->op==CLR||equstr(regs[RT2],"#0")) && p->subop != LONG
+			&& isreg(regs[RT1])>=0) {
+			p->op = XOR;
+			regs[RT2][0] = ',';
+			i = 0;
+			do
+				regs[RT2][i+1] = regs[RT1][i];
+			while(regs[RT1][i++]);
+			p->code = copy(2,regs[RT1],regs[RT2]);
+			nchange++;
+			break;
+		}
+
+		if(p->op==LD && p->subop==LONG && r >= 2 && r < 7 &&
+		   p->forw && (p->forw->op==ADD || p->forw->op==INC)
+		   && p->forw->subop==0 &&
+		   p->forw->forw && p->forw->forw->op==LD) {
+			/* ldl rri,FP; add r(i+1),#ddd; ldx r(x)i,@rri */
+			/* ldl rri,FP; inc r(i+1),#ddd; ldx r(x)i,@rri */
+			i = isreg(regs[RT2]);
+			if(i>=0 && i<=14 && regc=='r') {
+				dualop(p->forw);
+				r1 = isreg(regs[RT1]);
+				if(r1 == (r+1) && regs[RT2][0] == '#') {
+					p2p = p2;
+					*p2p++ = ',';
+					if(i==12)
+						p1 = "FP(";
+					else if(i==14)
+						p1 = "SP(";
+					else if(i==10)
+						p1 = "rr10(";
+					else
+						p1 = "rrx(";
+					while(*p2p++ = *p1++);
+					if(i < 10)
+						*(p2p-3) = i + '0';
+					p2p--;
+					p1 = regs[RT2];
+					while(*p2p++ = *p1++);
+					*(p2p-1) = ')';
+					*p2p = 0;
+					dualop(p->forw->forw);
+					r1 = isreg(regs[RT1]);
+					if(r1==r || r1 == (r+1)){
+						elim(p);
+						elim(p->forw);
+						p = p->forw->forw;
+						p->code = copy(2,regs[RT1],p2);
+						if(debug>2) {
+							printf("neu erzeugt: ");
+							dbprint(p);
+						}
+						nchange++;
+						p = p->back;
+						break;
+					}
+				}
+			}
+		}
+		dualop(p);
+		if(p->op != LDK) {
+			repladdr(p, 0);
+			dualop(p);
+		}
+mfldil:
+		r = isreg(ccloc);
+		r1 = isreg(regs[RT1]);
+		if(r<0 && r1<0 || r==r1 && ccloct==regt[RT1] ||
+		   ccloct=='r' && r==(r1 & ~01) ||
+		   regt[RT1]=='r' && r1==(r & ~01))
+			clrcc();
+		r = isreg(regs[RT2]);
+		dest(regs[RT1],regt[RT1]);
+		if(r1 < 0)
+			source(regs[RT1],regt[RT1]);
+		source(regs[RT2], regt[RT2]);
+		if (r >= 0)
+			if (r1 >= 0)
+				if(r1 < r)
+					savereg(r1,regs[RT2],regt[RT2],p);
+				else
+					savereg(r1, regs[r],regt[r], p);
+			else { if(regs[r][0]==0)
+			       	savereg(r, regs[RT1],regt[RT1], NIL);
+			       else 
+				savereg(r+NREG, regs[RT1],regt[RT1], NIL);
+			}
+		else
+			if (r1 >= 0)
+				savereg(r1, regs[RT2], regt[RT2], p);
+			else
+				setcon(regs[RT2], regs[RT1], regt[RT1]);
+		break;
+
+	case INC:
+	case DEC:
+	case SET:
+	case RES:
+	case SRL:
+	case SLL:
+	case ASR:
+	case ASL:
+		dualop(p);
+		if(p->op==INC && equstr(regs[RT1],"SP") && p->forw
+		&& p->forw->op==PUSH && regs[RT2][0]=='#') {
+			dualop(p->forw);
+			if(regs[RT2][0]!='r' && regs[RT2][0]!='#')
+				goto ende;
+			dualop(p);
+			if(regs[RT2][1]=='%')
+				r1 = hexa(&(regs[RT2][2]));
+			else
+				r1 = hexa(&(regs[RT2][1]));
+			if(p->forw->subop==LONG && r1>3)
+				r1 -= 4;
+			else if(r1>1 && p->forw->subop != LONG)
+				r1 -= 2;
+			else goto ende;
+			if(!r1){
+				if(debug > 2)
+					puts("elim 5");
+				elim(p);
+			}else
+				sprintf(regs[RT2],",#%%%x",r1);
+			p->forw->op = LD;
+			p->code = copy(2,regs[RT1],regs[RT2]);
+			redunm++;
+			break;
+		}
+ende:
+		dualop(p);
+		dest(regs[RT1],regt[RT1]);
+		source(regs[RT2], regt[RT2]);
+		source(regs[RT1], regt[RT1]);
+		if(p->op==SET||p->op==RES||p->op==PUSH||p->op==POP)
+			clrcc();
+		else
+			setcc(regs[RT1],regt[RT1]);
+		break;
+
+	case ADD:
+	case SUB:
+	case OR:
+	case XOR:
+	case MUL:
+	case DIV:
+	case SDA:
+	case SDL:
+	case PUSH:
+	case POP:
+	dble:
+		dualop(p);
+		if(p->op==POP && (r=isreg(regs[RT1]))>=0 && regp[r]!=0) {
+			if(regt[r]==regt[RT1]) {
+				if(debug > 2)
+					puts("elim 6");
+				elim(regp[r]);
+				clrr(r,regt[RT1]);
+				if(isreg(ccloc)==r)
+					clrcc();
+			}
+		}
+		if(p->op==OR && regs[RT2][0]=='#' && p->subop==0) {
+			p1 = regs[RT2] + 1;
+			if(*p1 == '%')
+				++p1;
+			if((i = ispow2a(hexa(p1)))>=0) {
+				p->op = SET;
+				setadr(p,i);
+				clrcc();
+				++nchange;
+				break;
+			}
+		}
+		if(p->op==XOR &&(r=isreg(regs[RT1]))>=0 &&
+		   equstr(regs[RT1],regs[RT2])) {
+			if(regp[r] && regt[r]==regt[RT1]) {
+				if(debug > 2)
+					puts("elim 7");
+				elim(regp[r]);
+				clrr(r,regt[RT1]);
+				if(isreg(ccloc)==r)
+					clrcc();
+			}
+			if(regt[r]==regt[RT1] &&
+				(regt[r]!='h' && equstr(regs[r],"#0") ||
+				 regt[r]=='h' && equstr(regh[r],"#0"))
+			||regt[r]=='l'&&regt[RT1]=='h'&&equstr(regh[r],"#0")
+			||regt[r]=='h'&&regt[RT1]=='l'&&equstr(regs[r],"#0")){
+				if(debug > 2)
+					puts("elim 8");
+				elim(p);
+				++redunm;
+				break;
+			} else if(regt[RT1]=='h') {
+				if(regt[r]!='l')
+					clrr(r,'h');
+				regh[r][0] = '#';
+				regh[r][1] = '0';
+				regh[r][2] = 0;
+				regp[r] = p;
+			} else {
+				savereg(r,"#0",regt[RT1], p);
+			}
+		} else {
+			repladdr(p, 0);
+			dualop(p);
+			dest(regs[RT1],regt[RT1]);
+			source(regs[RT2], regt[RT2]);
+			source(regs[RT1], regt[RT1]);
+		}
+		setcc(regs[RT1],regt[RT1]);
+		break;
+
+	case NEG:
+	case CLR:
+	case COM:
+	case SXT:
+		singop(p);
+		if (p->op==CLR)
+			if ((r = isreg(regs[RT1])) >= 0)
+				goto clr;
+			else
+				setcon("#0", regs[RT1], regt[RT1]);
+		dest(regs[RT1],regt[RT1]);
+		source(regs[RT1],regt[RT1]);
+		if(p->op!=CLR && p->op!=SXT)
+			setcc(regs[RT1], regt[RT1]);
+		break;
+
+	case TST:
+		singop(p);
+tst:
+		repladdr(p, 1);
+		singop(p);
+		if ((ccloct==regt[RT1] && equstr(regs[RT1],ccloc)) ||
+			p->forw && p->forw->op > CBR) {
+			if(debug > 2)
+				puts("elim 9");
+			elim(p);
+			nrtst++;
+		}
+		else
+			setcc(regs[RT1], regt[RT1]);
+		source(regs[RT1], regt[RT1]);
+		break;
+
+	case CMP:
+		if(p->forw->op==CBR && (r = p->forw->subop) < JLO) {
+			dualop(p);
+			if(equstr(regs[RT2],"#0")) {
+				if(r == JLT)
+					p->forw->subop = MI;
+				if(r == JGE)
+					p->forw->subop = PL;
+				if(p->forw->subop < JLE) {
+					p->op = TST;
+					regs[RT2][0] = 0;
+					p->code = copy(1,regs[RT1]);
+					goto tst;
+				}
+			}
+		}
+
+	case BIT:
+		if(p->forw->op > CBR) {
+			if(debug > 2)
+				puts("elim 10");
+			elim(p);
+			break;
+		}
+
+	case AND:
+		dualop(p);
+		if(p->op==AND && regs[RT2][0]=='#' && p->subop==0) {
+			p1 = regs[RT2] + 1;
+			if(*p1 == '%')
+				++p1;
+			if ((i = ispow2a(~hexa(p1)))>=0) {
+				p->op = RES;
+				setadr(p,i);
+				clrcc();
+				++nchange;
+				break;
+			}
+		}
+
+		if(p->op==AND) {
+		     if(equstr(regs[RT2],"#%ffff")||equstr(regs[RT2],"#-%1")){
+				p->op = TST;
+				regs[RT2][0] = 0;
+				regt[RT2] = 0;
+				p->code = copy(1, regs[RT1]);
+				nchange++;
+				nsaddr++;
+				goto tst;
+			} else
+			if(equstr(regs[RT2],"#%0")) {
+				p->op = CLR;
+				regs[RT2][0] = 0;
+				regt[RT2] = 0;
+				p->code = copy(1, regs[RT1]);
+				nchange++;
+				nsaddr++;
+				goto clr;
+			}
+		dest(regs[RT1],regt[RT1]);
+		}
+		if(p->op!=BIT &&(p->op!=CMP || regs[RT2][0]!='#')) {
+			repladdr(p, 1);
+			dualop(p);
+		}
+		if(p->op!=AND)
+			clrcc();
+		else 
+			setcc(regs[RT1], regt[RT1]);
+		source(regs[RT1], regt[RT1]);
+		source(regs[RT2], regt[RT2]);
+		break;
+
+	case CBR:
+
+		if (p->back->op==TST || p->back->op==CMP) {
+			if (p->back->op==TST) {
+				singop(p->back);
+				savereg(RT2, "#0", regt[RT1], p->back);
+			} else
+				dualop(p->back);
+			r = compare(p->subop, findcon(RT1), findcon(RT2));
+			if (r==0) {
+				if(p->forw->op == CBR ) {
+					if(debug > 2)
+						puts("elim 11");
+					elim(p);
+					clrcc();
+				} else {
+					p->back->back->forw = p->forw;
+					p->forw->back = p->back->back;
+					clrcc();
+				}
+				decref(p->ref);
+				p = p->back->back;
+				nchange++;
+			} else if (r>0) {
+				p->op += 2;
+				p->subop = 0;
+				p->back->back->forw = p;
+				p->back = p->back->back;
+				p = p->back;
+				nchange++;
+			}
+		}
+
+	case JMP:
+		redunbr(p);
+		clrp();
+		break;
+
+	case END:
+	case EROU:
+	case CALL:
+		for(r = 0; r<8; ++r)
+			if (regp[r]!=0 && regs[r][0]=='r') {
+				if(debug > 2)
+					puts("elim 12");
+				elim(regp[r]);
+				if(isreg(ccloc)==r)
+					clrcc();
+		}
+
+	default:
+		clearreg();
+	}
+	}
+}
+
+jumpsw()
+{
+	register struct node *p, *p1;
+	register t;
+	register struct node *tp;
+	register nj;
+
+	t = 0;
+	nj = 0;
+	for (p=first.forw; p!=0; p = p->forw)
+		p->refc = ++t;
+	for (p=first.forw; p!=0; p = p1) {
+		if(debug > 2){
+			printf("jumpsw works on:");
+			dbprint(p);
+		}
+		p1 = p->forw;
+		if ((p->op == CBR || p1->op == JMP) && p->ref && p1->ref
+		 && Abs(p->refc - p->ref->refc) > Abs(p1->refc - p1->ref->refc)) {
+			if (p->ref==p1->ref ||p->labno==0 || p1->labno==0)
+				continue;
+			p->subop = revbr[p->subop];
+			tp = p1->ref;
+			p1->ref = p->ref;
+			p->ref = tp;
+			t = p1->labno;
+			p1->labno = p->labno;
+			p->labno = t;
+			nrevbr++;
+			nj++;
+		}
+	}
+	return(nj);
+}
+
+addsob()
+{
+	register struct node *p, *p1;
+
+	for (p = &first; (p1 = p->forw)!=0; p = p1) {
+		if(debug > 2){
+			printf("addsob works on:");
+			dbprint(p);
+		}
+		switch(p->op) {
+			case CLR:
+			case AND:
+			case OR:
+			case BIT:
+			case RES:
+			case SET:
+			case CMP:
+			case TST:
+			case LD:
+			case LDK:
+				p1 = nonlab(p->forw);
+		           	if(p1 && p1->op==p->op
+					 && equstr(p->code,p1->code)){
+					if(debug > 2)
+						puts("elim 13");
+					elim(p);
+					p = p->back;
+					if(!(p1 = p->forw))
+						return;
+				}
+		}
+
+		if(p1 && p1->op == TST) {
+			switch(p->op) {
+			case CLR:
+				if(p1->forw && p1->forw->op == CBR 
+					&& equstr(p->code,p1->code))
+					switch (p1->subop) {
+						case JNE:
+						case JGT:
+						case JHI:
+							if(debug > 2)
+								puts("elim 14");
+							elim(p1->forw);
+							elim(p1);
+							if(!(p1=p->forw))
+								return;
+						case JEQ:
+						case JLOS:
+						case JLE:
+							p=p1->forw;
+							if(debug > 2)
+								puts("elim 15");
+							elim(p1);
+							p->op += 2;
+							p->subop=0;
+							if(!p)
+								return;
+					}
+				else break;
+
+			case COM:
+			case INC:
+			case DEC:
+			case NEG:
+				if(equstr(p->code,p1->code)) {
+					if(debug > 2)
+						puts("elim 16");
+					elim(p1);
+					nrtst++;
+					if((p1 = p1->forw) == 0)
+						return;
+				}
+			}
+		}
+		if (p->op==TST && p1->op > CBR) {
+			if(debug > 2)
+				puts("elim 17");
+			elim(p);
+			nrtst++;
+			continue;
+		}
+
+		if (p->op==DEC && isreg(p->code)>=0
+		 && p1->op==CBR && p1->subop==JNE) {
+			if (p->refc < p1->ref->refc)
+				continue;
+			if (toofar(p1))
+				continue;
+			dualop(p);
+			p->code = copy(1,regs[RT1]);
+			p->labno = p1->labno;
+			p->op = DJNZ;
+			p->subop = 0;
+			p1->forw->back = p;
+			p->forw = p1->forw;
+			nsob++;
+		}
+	}
+}
+
+toofar(ap)
+struct node *ap;
+{
+	register struct node *p, *p1;
+	register len;
+
+	p = ap;
+	for(p1 = first.forw; p1 != p ; p1 = p1->forw)
+		if (p1 == p->ref)
+			break;
+
+	if(p1 == p->ref) {
+		p = p1;
+		p1 = ap;
+	} else
+		p1 = p->ref;
+	len = 0;
+	for (p = p->forw; p && p!=p1; p = p->forw)
+		len += ilen(p);
+	if (len < 256)
+		return(0);
+	return(1);
+}
+
+ilen(p)
+register struct node *p;
+{
+	if (p->op == 0)
+		return(0);
+
+	switch (p->op) {
+	case LABEL:
+	case DLABEL:
+	case CP:
+	case EROU:
+	case EVEN:
+	case CODE:
+	case BSS:
+	case CD:
+	case CMT:
+		return(0);
+
+
+	case SRL:
+	case SLL:
+	case ASR:
+	case ASL:
+	case SDA:
+	case LDI:
+	case LDD:
+		return(4);
+
+	case LDK:
+	case DJNZ:
+		return(2);
+
+	default:
+		dualop(p);
+		switch(p->op) {
+		case BIT:
+		case RES:
+		case SET:
+		case INC:
+		case DEC:
+			return(2 + adrlen(regs[RT1]));
+
+		case LD:
+		case CMP:
+		case ADD:
+		case SUB:
+		case MUL:
+		case DIV:
+			if(p->subop==LONG && regs[RT2][0]=='#')
+				return(6);
+
+		default:
+			return(2 + adrlen(regs[RT1]) + adrlen(regs[RT2]));
+		}
+	}
+}
+
+adrlen(s)
+register char *s;
+{
+	if (*s == 0)
+		return(0);
+	if (*s=='r' || *s=='S' && *(s+1)=='P')
+		return(0);
+	if (*s=='r' || *s=='F' && *(s+1)=='P')
+		return(0);
+	if (*s=='r' || *s=='s' && *(s+1)=='p')
+		return(0);
+	if (*s=='r' || *s=='f' && *(s+1)=='p')
+		return(0);
+	if (*s=='(' && (*(s+1)=='r' || *(s+1)=='F' || *(s+1)=='f'))
+		return(0);
+	if (*s=='@')
+		return(0);
+	if (*s=='|')
+		return(2);
+	return(4);
+}
+
+Abs(x)
+{
+	return(x<0? -x: x);
+}
+
+equop(ap1, p2)
+struct node *ap1;
+register struct node *p2;
+{
+	register char *cp1, *cp2;
+	register struct node *p1;
+
+	p1 = ap1;
+	if (p1->op!=p2->op || p1->subop!=p2->subop)
+		return(0);
+	if (p1->op!=p2->op || p1->subop!=p2->subop)
+		return(0);
+	if (p1->op>0 && p1->op<LD)
+		return(0);
+	cp1 = p1->code;
+	cp2 = p2->code;
+	if (cp1==0 && cp2==0)
+		return(1);
+	if (cp1==0 || cp2==0)
+		return(0);
+	while (*cp1 == *cp2++)
+		if (*cp1++ == 0)
+			return(1);
+	return(0);
+}
+
+decref(p)
+register struct node *p;
+{
+	if(debug > 2){
+		printf("decref works on:");
+		dbprint(p);
+	}
+	if (--p->refc <= 0) {
+		if(debug > 2)
+			puts("elim 18");
+		nrlab++;
+		elim(p);
+	}
+}
+
+struct node *
+nonlab(p)
+register struct node *p;
+{
+	while (p && p->op==LABEL)
+		p = p->forw;
+	return(p);
+}
+
+char *
+alloc(n)
+register n;
+{
+	register char *p;
+
+	n++;
+	n &= ~01;
+	if (lasta+n >= lastr) {
+		if (addrseg == 9) {
+			fprintf(stderr, "lpopt: out of space\n");
+			exit(1);
+		}
+		addrseg++;
+		if(address[addrseg] == (char  *)0) {
+			lasta = (char *)malloc(0xfff8);
+			address[addrseg] = lasta;
+			lastr = lasta +  0xfff8;
+		}
+	}
+	p = lasta;
+	lasta += n;
+	return(p);
+}
+
+clearreg()
+{
+	register int i;
+
+	for (i=0; i<FREG; i++) {
+		regs[i][0] = '\0';
+		regt[i] = 0;
+		regp[i] = 0;
+	}
+	conloc[0] = 0;
+	conloct = 0;
+	conval[0] = 0;
+	convalt = 0;
+	clrcc();
+	for(i = 0; i < 8; i++)
+		regh[i][0] = 0;
+}
+
+savereg(ai, as, at, ap)
+register ai;
+register struct node *ap;
+char *as;
+char at;
+{
+	register char *p, *s, *sp;
+
+	sp = p = regs[ai];
+	s = as;
+	clrr(ai,at);
+	regt[ai] = at;
+	regp[ai] = ap;
+
+	while (*p++ = *s) {
+		if (s[0]=='(' && regnum(s+1) != 14 ) {
+			*sp = 0;
+			return;
+		}
+		if (*s++ == ',')
+			break;
+	}
+	*--p = '\0';
+}
+
+dest(as, at)
+char *as;
+char at;
+{
+	register char *s;
+	register int i, j, j1;
+	char *s1 = "rr10";
+
+	s = as;
+	if ((j = isreg(s)) >= 0) {
+		clregrr(j,at);
+		clrr(j,at);
+		clrr(j+NREG,at);
+		j1 = j & ~1;
+		if(j1 < 10) {
+			s1[2] = j1 + '0';
+			s1[3] = 0;
+		} else {
+			s1[2] = '1';
+			s1[3] = j1 - 10 + '0';
+		}
+	} else
+		s1[3] = '4';
+	for (i = 0; i < FREG; i++) {
+		if(j>=0 && j==isreg(regs[i]))
+			clrr(i,at);
+		else if(equstr(s,regs[i])||equstr(s1,regs[i]))
+			clrr(i,at);
+		else if(teil(s,regs[i])|| teil(s1,regs[i]))
+			clrr(i,at);
+		else if(teil(regs[i],s)|| teil(regs[i],s1))
+			clrr(i,at);
+
+	}
+	if ((i = findrand(s,at)) >= 0)
+		if(regt[i]==at)
+			clrr(i,at);
+	while (*s) {
+		if ((*s=='(' && (*(s+1)!='F' || *(s+2)!='P' || *(s+1)!='f'
+			|| *(s+2)!='p' || *(s+1)!='s')) || *s++=='@') {
+			for (i=0; i<FREG; i++) {
+				if (regs[i][0] != '#' && regs[i][0] != 'r')
+					clrr(i,at);
+				conloc[0] = 0;
+				conloct = 0;
+			}
+			return;
+		}
+	}
+}
+
+source(as, at)
+char *as;
+char at;
+{
+	register char *s;
+	register int i;
+
+	s = as;
+	if ((i = isreg(s)) >= 0) {
+		regp[i] = 0;
+		regp[i+NREG] = 0;
+		if((i & 1) && regt[i-1]=='r') {
+			regp[i-1] = 0;
+			regp[i+NREG-1] = 0;
+		}
+		if(at=='r' || at=='q') {
+			regp[i+1] = 0;
+			regp[i+1 + NREG] = 0;
+		}
+		if(at=='q') {
+			regp[i+2] = 0;
+			regp[i+3] = 0;
+			regp[i+2 + NREG] = 0;
+			regp[i+3 + NREG] = 0;
+		}
+	} else
+	if(*s=='@' && (i = isreg(++s))>=0) {
+		regp[i] = 0;
+		regp[i+NREG] = 0;
+	}
+	else  {
+		while(*s && *s!='(')
+			++s;
+		if(*s && *s=='(' && (i = regnum(++s))>=0) {
+			regp[i] = 0;
+			regp[i+NREG] = 0;
+		}
+	}
+}
+
+singop(ap)
+struct node *ap;
+{
+	register char *p1, *p2;
+
+	p1 = ap->code;
+	p2 = regs[RT1];
+	while (*p2++ = *p1++);
+	settyp(RT1,ap);
+	regs[RT2][0] = 0;
+	regt[RT2] = 0;
+}
+
+
+dualop(ap)
+struct node *ap;
+{
+	register char *p1, *p2;
+	register struct node *p;
+
+	p = ap;
+	p1 = p->code;
+	p2 = regs[RT1];
+	while (*p1 && *p1!=',')
+		*p2++ = *p1++;
+	settyp(RT1,ap);
+	*p2++ = 0;
+	p2 = regs[RT2];
+	*p2 = 0;
+	if (*p1++ !=',') {
+		regt[RT2] = 0;
+		return;
+	}
+	while (*p2++ = *p1++);
+	settyp(RT2,ap);
+}
+
+findrand(as, at)
+char *as;
+char at;
+{
+	register int i, j;
+
+	if(*as==0)
+		return(-1);
+/*
+	if((i = isreg(as))>=0 && (j = isreg(regs[i]))>=0){
+		if(j>i && regt[j]==regt[i])
+			return ( j );
+		else
+			return(-1);
+	}
+*/
+	for (i = 0; i < FREG; i++) {
+		if (equstr(regs[i], as)) {
+			if(regt[i] != at)
+				continue;
+			if((regt[i & ~01] == 'r' && at != 'r') ||
+				(regt[i & ~03] == 'q' && at != 'q'))
+				continue;
+			else
+				return(i);
+		}
+	}
+	return(-1);
+}
+
+isreg(as)
+char *as;
+{
+	register char *s;
+
+	s = as;
+	if(s==0 || (*s)==0)
+		return(-1);
+	return(regnum(s));
+}
+
+check()
+{
+	register struct node *p, *lp;
+
+	lp = &first;
+	for (p=first.forw; p!=0; p = p->forw) {
+		if (p->back != lp)
+			abort();
+		lp = p;
+	}
+}
+
+
+repladdr(p, f)
+register f;
+struct node *p;
+{
+	register r, i;
+	register r1, r2;
+	register char *p1, *p2;
+	static char rt1[50], rt2[50];
+
+	if(debug > 2){
+		printf("repladdr works on:");
+		dbprint(p);
+	}
+	if (f)
+		r = findrand(regs[RT1], regt[RT1]);
+	else
+		r = -1;
+	r1 = findrand(regs[RT2], regt[RT2]);
+	if (r1 >= NREG)
+		r1 -= NREG;
+	if (r >= NREG)
+		r -= NREG;
+	if (r>=0 || r1>=0) {
+		p2 = regs[RT1];
+		for (p1 = rt1; *p1++ = *p2++;);
+		if (regs[RT2][0]) {
+			p1 = rt2;
+			*p1++ = ',';
+			for (p2 = regs[RT2]; *p1++ = *p2++;);
+		} else
+			rt2[0] = 0;
+		if (r>=0 && (regs[r][0]==0 || regt[r]==regt[RT1]) && 
+		((r2 = isreg(regs[RT1]))<0 || r2<r && regt[r2]==regt[RT1])) {
+			rt1[0] = 'r';
+			i = 1;
+			if(regt[RT1] != 0)
+				rt1[i++] = regt[RT1];
+			if( r > 9 ) {
+				rt1[i++] = '1';
+				rt1[i++] = r - 10 + '0';
+			}else
+				rt1[i++] = r + '0';
+			rt1[i] = 0;
+			nsaddr++;
+			nchange++;
+		}
+		if (r1>=0 && (regs[r1][0]==0 || regt[r1]==regt[RT2]) && 
+		((r2 = isreg(regs[RT2]))<0 ||r2<r1 && regt[r2]==regt[RT2])) {
+			rt2[1] = 'r';
+			i = 2;
+			if (regt[RT2] != 0)
+				rt2[i++] = regt[RT2];
+			if ( r1 > 9 ) {
+				rt2[i++] = '1';
+				rt2[i++] = r1 - 10 + '0';
+			} else
+				rt2[i++] = r1 + '0';
+			rt2[i] = 0;
+			nsaddr++;
+			nchange++;
+		}
+		p->code = copy(2, rt1, rt2);
+		if(debug > 2)
+			printf("repladdr liefert '%s'\n",p->code);
+	}
+}
+
+redunbr(p)
+register struct node *p;
+{
+	register struct node *p1;
+	register char *ap1;
+	register char *ap2;
+
+	if ((p1 = p->ref) == 0)
+		return;
+	p1 = nonlab(p1);
+	if (p1->op==TST) {
+		singop(p1);
+		savereg(RT2, "#0", regt[RT1], p1);
+	} else if (p1->op==CMP)
+		dualop(p1);
+	else
+		return;
+	if (p1->forw->op!=CBR)
+		return;
+	ap1 = findcon(RT1);
+	ap2 = findcon(RT2);
+	p1 = p1->forw;
+	if (compare(p1->subop, ap1, ap2)>0 && p1->labno) {
+		nredunj++;
+		nchange++;
+		decref(p->ref);
+		p->ref = p1->ref;
+		p->labno = p1->labno;
+		p->ref->refc++;
+	}
+}
+
+char *
+findcon(i)
+register i;
+{
+	register char *p;
+	register r;
+
+	p = regs[i];
+	if (*p=='#')
+		return(p);
+	if ((r = isreg(p)) >= 0 && regt[r]==regt[i])
+		return(regs[r]);
+	if (equstr(p, conloc) && conloct==regt[i])
+		return(conval);
+	return(p);
+}
+
+compare(oper, cp1, cp2)
+register oper;
+char *cp1, *cp2;
+{
+	register unsigned n1, n2;
+
+	if (*cp1++ != '#' || *cp2++ != '#')
+		return(-1);
+	n2 = hexa(cp2);
+	n1 = hexa(cp1);
+	do {
+		if (*cp1++ != *cp2)
+			return(-1);
+	} while (*cp2++);
+	switch(oper) {
+
+	case JEQ:
+		return(n1 == n2);
+	case JNE:
+		return(n1 != n2);
+	case JLE:
+		return((int)n1 <= (int)n2);
+	case JGE:
+		return((int)n1 >= (int)n2);
+	case JLT:
+		return((int)n1 < (int)n2);
+	case JGT:
+		return((int)n1 > (int)n2);
+	case JLO:
+		return(n1 < n2);
+	case JHI:
+		return(n1 > n2);
+	case JLOS:
+		return(n1 <= n2);
+	case JHIS:
+		return(n1 >= n2);
+	case PL:
+		return((int)n1 >= 0);
+	case MI:
+		return((int)n1 < 0);
+	}
+	return(-1);
+}
+
+setcon(ar1, ar2, t)
+char *ar1, *ar2;
+char t;
+{
+	register char *cl, *cv, *p;
+
+	cl = ar2;
+	cv = ar1;
+	if (*cv != '#')
+		return;
+	if (!natural(cl))
+		return;
+	p = conloc;
+	while (*p++ = *cl++);
+	p = conval;
+	while (*p++ = *cv++);
+	conloct = t;
+	convalt = t;
+}
+
+equstr(ap1, ap2)
+char *ap1, *ap2;
+{
+	register char *p1, *p2;
+
+	p1 = ap1;
+	p2 = ap2;
+	if(!p1) {
+		if(!p2)
+			return 1;
+		else
+			return 0;
+	}
+	if(*p1 == '#' && *p2 == '#') {
+		if(*++p1 =='%')
+			++p1;
+		if(*++p2 =='%')
+			++p2;
+	}
+	do {
+		if (*p1++ != *p2)
+			return(0);
+	} while (*p2++);
+	return(1);
+}
+
+setcc(ap, t)
+char *ap;
+char t;
+{
+	register char *p, *p1;
+
+	p = ap;
+	ccloct = t;
+	if (!natural(p)) {
+		clrcc();
+		return;
+	}
+	p1 = ccloc;
+	while (*p1++ = *p++);
+}
+
+clrcc()
+{
+	ccloc[0] = 0;
+	ccloct = 0;
+}
+
+natural(ap)
+char *ap;
+{
+	register char *p;
+
+	p = ap;
+	if (*p == '@' || *p == '(')
+		return(0);
+	while (*p++);
+	p--;
+	if ( *--p ==')' && *--p != 'P')
+		return(0);
+	return(1);
+}
+
+unsigned
+hexa(cp)
+char *cp;
+{
+	unsigned register n;
+	n = 0;
+	while(*cp >= '0' && *cp <= '9' || *cp >= 'a' && *cp <= 'f') {
+		n <<= 4;
+		if(*cp < 'a')
+			n += *cp++ - '0';
+		else
+			n += *cp++ - 'W';
+	}
+	return(n);
+}
+
+elim(p)
+register struct node *p;
+{
+	if(debug){
+		printf("elim works on:");
+		dbprint(p);
+	}
+	p->back->forw = p->forw;
+	p->forw->back = p->back;
+	nchange++;
+}
+
+regnum(r)
+char *r;
+{
+	if (*r != 'r' && *r != 'F' && *r != 'f' && *r != 'S' && *r!='s')
+		return(-1);
+	regc = 0;
+
+	if (*r =='S' && *(r+1) == 'P' && *(r+2) == 0) {
+		regc = 'r';
+		return(14);
+	}
+
+	if (*r =='s' && *(r+1) == 'p' && *(r+2) == 0)
+		return(15);
+
+	if (*r =='F' && *(r+1) == 'P' && *(r+2) == 0) {
+		regc = 'r';
+		return(12);
+	}
+
+	if (*r =='f' && *(r+1) == 'p' && *(r+2) == 0)
+		return(13);
+
+	if(*r++ != 'r')
+		return(-1);
+	if(*r == 'l' || *r== 'r' || *r == 'h' || *r == 'q')
+		regc = *r++;
+
+	if(*(r+1) >= '0' && *(r+1) <= '5' && *r == '1') {
+		r++;
+		if(*(r+1) == 0)
+			return(10 + *r++ - '0');
+		else
+			return(-1);
+
+		}
+	else if(*r >= '0' && *r <= '9' && *(r+1) == 0)
+			return(*r++ - '0');
+	return(-1);
+
+}
+
+settyp(a,ap)
+register a;
+register struct node *ap;
+{
+	if(regs[a][0] == 'r' && regs[a][1] > '9')
+		regt[a] = regs[a][1];
+	else if (ap->subop==LONG)
+		regt[a] = 'r';
+	else if (ap->subop==BYTE)
+		regt[a] = 'l';
+	else regt[a] = 0;
+}
+
+clrr(i,at)
+register i;
+char at;
+{
+	register j,k;
+	k = i&~01;
+	j = i&~03;
+
+	if((i & 1) && regt[i-1]=='r') {
+		regs[i-1][0] = 0; 
+		regt[i-1]=0;
+		regp[i-1]=0;
+	}
+	if(i < 8 && at!='l')
+		regh[i][0] = 0;
+	if(regt[j]=='q' || at=='q') {
+		regs[j][0] = 0; regt[j] = 0; regp[j] = 0;
+		regs[++j][0] = 0; regt[j] = 0; regp[j] = 0;
+		regs[++j][0] = 0; regt[j] = 0; regp[j] = 0;
+		regs[++j][0] = 0; regt[j] = 0; regp[j] = 0;
+	}
+	else if (regt[k]=='r' || at=='r') {
+		regs[k][0] = 0; regt[k] = 0; regp[k] = 0;
+		regs[++k][0] = 0; regt[k] = 0; regp[k] = 0;
+	}
+	else {
+		regs[i][0] = 0;
+		regt[i] = 0;
+		regp[i] = 0;
+	}
+	regp[i] = 0;
+}
+
+clrp()
+{
+	register i;
+	for( i=0; i<30; i++)
+	regp[i] = 0;
+}
+
+ispow2a(a)
+register unsigned a;
+{
+	register i;
+	if(a>0 && a<=0x8000 && (a&(a-1))==0) {
+		for(i = 0; a >>= 1; i++);
+		return(i);
+	}
+	else
+		return(-1);
+}
+
+setadr(p, i)
+register struct node *p;
+register i;
+{
+	static char rt[5];
+	regt[RT2] = 0;
+	rt[0] = ',';
+	rt[1] = '#';
+	rt[2] = '%';
+	if(i < 10)
+		rt[3] = '0' + i;
+	else
+		rt[3] = 'a' + i - 10;
+	rt[4] = 0;
+	p->code = copy(2, regs[RT1], rt);
+}
+
+/* ist r teilstring in s */
+teil(r,s)
+char *r,*s;
+{
+	static char f[5];
+	char *fp, *sp, *osp = s;
+	int len,i;
+	if(equstr(r,s))
+		return(0);
+	len = strlen(r);
+	while((sp = strchr(osp,*r))!=NULL) {
+		osp = sp + 1;
+		fp = f;
+		for(i=0; i < len; i++)
+			*fp++ = *sp++;
+		*fp = 0;
+		if(equstr(f,r))
+			return(1);
+	}
+	return(0);
+}
+
+clregrr(r, t)
+register r;
+char t;
+{
+	char *s1 = "rr10";
+	int j1, j;
+
+again:
+	j1 = r & ~1;
+	if(j1 < 10) {
+		s1[2] = j1 + '0';
+		s1[3] = 0;
+	} else {
+		s1[2] = '1';
+		s1[3] = j1 - 10 + '0';
+	}
+	for(j = 0; j < NREG; j++)
+		if(teil(s1, regs[j]))
+			clrr(j, regt[j]);
+	if(t == 'q') {
+		t = 0;
+		r += 2;
+		goto again;
+	}
+}