;/*
   failat 20
   sc gst=include:all.gst parms=register nostackcheck IRA.c
   slink lib:c.o IRA.o IRA20_1.o IRA_2.o to IRA sc sd nd lib lib:sc.lib

   QUIT
   Author   : Tim Ruehsen
   Project  : IRA  -  68000/10/20/30/40 Interactive ReAssembler
   Part     : IRA.c
   Purpose  : Contains most routines and main program
   Version  : $VER: IRA.c V1.05
   Date     : 16.05.1995
   Copyright: (C)1993-1995 Tim Ruehsen
*/



#include "IRA.h"

#if BETA == 0
  UBYTE version[]="$VER: IRA V" VERSION "." REVISION " "__AMIGADATE__" (c)1993-95 Tim Ruehsen (SiliconSurfer/PHANTASM)\n\n";
#else
  UBYTE version[]="$VER: IRA V" VERSION "." REVISION "beta "__AMIGADATE__" (c)1993-95 Tim Ruehsen (SiliconSurfer/PHANTASM)\n\n";
#endif




extern
char  opcode[][8],
      bitshift[][4],
      condcode[][3],
      extension[][3],
      caches[][3],
      bitop[][4],
      memtypename[][7],
      modname[][5],
      bitfield[][5],
      cregname[][6];

extern
UWORD cregflag[18];

extern
UWORD  result[],sourceadr[],destadr[],maske[];
extern
UBYTE  flags[],cputype[];
extern
struct x_adr x_adrs[];
extern
UBYTE  mnebuf[],adrbuf[],dtabuf[];

extern char cpuname[][8];
UWORD CPUTYPE=M68000;

UWORD  opcstart[16];
UWORD  opccount[16];
UWORD  opcnumber;
UWORD  SIZEOF_RESULT;
ULONG  ADRCOUNT;

UWORD reg1,reg2,adrmode,adrmode2,extens;
ULONG displace;
UWORD sigw,*buffer;
UWORD extra;
WORD  PASS=-1;


UWORD *DRelocBuffer;
ULONG *RelocBuffer,RelocNumber;
ULONG  LastModul,FirstModul;
ULONG *LabelAdr;                  /* uncorrected addresses for labels */
ULONG *LabelAdr2;                 /*   corrected addresses for labels */
ULONG  LabelMax=1024;
ULONG  labcount;
ULONG *LabelNum;
ULONG *XRefListe,XRefCount;
ULONG  p2labind;
ULONG  LabX_len=400;
ULONG *RelocAdr,*RelocVal,*RelocMod,relocount;
ULONG  relocmax=1024;
LONG  *RelocOff;
ULONG nextreloc;
UWORD *memtype;

/* needed for the -BASEREG option */
UWORD  basereg= 4;
ULONG  basesec=-1;
LONG   baseadr;

/* needed for symbol hunks */
ULONG   SymbolCount, SymbolMax=16;
ULONG  *SymbolValue;
UBYTE **SymbolName;

/* needed for finding data/code in code sections */
ULONG  CodeAreas, CodeAreaMax=16;
ULONG *CodeArea1, *CodeArea2, CodeAreaEnd;
ULONG  CNFAreas, CNFAreaMax=16;
ULONG *CNFArea1, *CNFArea2;
ULONG  CodeAdrs, CodeAdrMax=16;
ULONG *CodeAdr;

LONG   LabAdr;
UWORD  LabAdrFlag;

UWORD  NearFlag;

unsigned int
       sourcetype;
UWORD  textmethod;
ULONG  prglen,prgcount,labc1;
ULONG  prgstart,prgende;
ULONG  codeentry;
ULONG  pc;
ULONG *labelbuf;

char   configname[32];
char   sourcename[128],targetname[128],tsname[128];
char   binname[32],labname[32],xrefname[128];

ULONG  modulcount,modulcnt;
ULONG *modultab,**modulstrt,*modultype,*moduloffs;

ULONG  pflags;
LONG   adrlen;

FILE  *sourcefile,
      *binfile,
      *targetfile,
      *labfile,
      *configfile;

struct List  list;
struct Node *node;

UBYTE  StdName[STDNAMELENGTH];

struct DosBase *DosBase;
struct IntuitionBase *IntuitionBase;



extern int
    GetSymbol(ULONG),
    _abort(void);

extern void
      *GetPMem(ULONG),
      *GetNewVarBuffer(void *,ULONG),
       GetLabel(LONG,UWORD),
       GetXref(ULONG),
       GetExtName(ULONG),
       InsertXref(ULONG),
       InsertLabel(LONG),
       InsertReloc(ULONG,ULONG,LONG,ULONG),
       InitOpcode(void),
       ExamineHunks(void),
       SearchRomTag(void),
       WriteTarget(void *,ULONG);


void
       main(int,char *[]),
       Init(void),
       ExitPrg(char *, ...),
       GetOpcode(void),
       CheckPhase(ULONG adr),
       Ausgabe(void),
       WriteLabel1(ULONG),
       WriteLabel2(ULONG),
       ReadExecutable(void),
       ReadObject(void),
       ReadBinary(void),
       SectionToArea(void),
       InsertCodeAdr(ULONG),
       InsertCodeArea(ULONG,ULONG),
       InsertSymbol(UBYTE *,ULONG),
       chkabort(void),
       DPass0(void),
       DPass1(void),
       DPass2(void);

int
       DoAdress2(UWORD),
       DoAdress1(UWORD),
       P2WriteReloc(void),
       P1WriteReloc(void),
       AutoScan(void);

extern ULONG
       FileLength(UBYTE *),
       ReadSymbol(FILE *,ULONG *,UBYTE *);

int   ARGC;
char **ARGV;


void Freemem(void *ptr,ULONG cnt)
{
	/* printf("Free: %08X  %8ld\n",ptr,cnt); */
	FreeMem(ptr,cnt);
}

void GetOpcode()
{
UWORD i;

	/* set the number of the opcode to the maximum (DC.W) as default. */
	opcnumber=SIZEOF_RESULT/sizeof(UWORD)-1;
	for(i=opcstart[sigw>>12];i<opcstart[sigw>>12]+opccount[sigw>>12];i++) {
		if ((sigw&maske[i])==result[i]) {
			if (cputype[i]&CPUTYPE) {
				opcnumber=i;
				break;
			}
		}
	}

	/* split up the opcode */
	reg1=(sigw&0x0e00)>>9;
	reg2=(sigw&0x0007);
	adrmode=(sigw&0x003f);
	if (adrmode<0x38) adrmode=(adrmode>>3);
	else adrmode=7+reg2;
	if (flags[opcnumber]&0x80) extens=flags[opcnumber]&0x03;
	else extens=(sigw&0x00c0)>>6;

}

void SearchCode(void)
{
ULONG i,j,end;
ULONG ptr;

	end=(prgende-prgstart)/2;

	for(i=0;i<end;i++) {
		if ((buffer[i]==0x4EF9) || (buffer[i]==0x4EB9)) {
			/* Find JSR/JMP Abs.L */
			if ((i+2)<end) {
				ptr=(buffer[i+1]<<16)+buffer[i+2];
				if (ptr>=prgstart && ptr<prgende) {
					InsertCodeAdr(ptr);
					InsertCodeAdr(i*2+prgstart);
					i=i+2;
				}
			}
		} else if ((buffer[i]==0x4EFA) || (buffer[i]==0x4EBA)) {
			/* Find JSR/JMP lab(PC) */
			if ((i+1)<end) {
				ptr=(prgstart+(i+1)*2)+(LONG)buffer[i+1];
				if (ptr>=prgstart && ptr<prgende) {
					InsertCodeAdr(ptr);
					InsertCodeAdr(i*2+prgstart);
					i=i+1;
				}
			}
		}
	}

/*
	for(i=0,j=0;j<modulcount;j++) {
		end=(moduloffs[j]+modultab[j])/2;
		while(i<end) {
			chkabort();
			if ((buffer[i]==0x6000) || (buffer[i]==0x6100)) {
				if ((i+1)<end) {
					ptr=((i+1)*2)+(WORD)buffer[i+1];
					if (ptr>=moduloffs[j] && ptr<end*2) {
						InsertCodeAdr(ptr+prgstart);
						InsertCodeAdr(i*2+prgstart);
						i=i+1;
					}
				}
			}
			i++;
		}
	}
*/
}

void PrintAreas(void)
{
ULONG i;

/*	return; */

	printf("CodeAdrs: %lu   CodeAdrMax: %lu\n",CodeAdrs,CodeAdrMax);

	for(i=0;i<CodeAreas;i++)
		printf("CodeArea[%lu]: %08x - %08x\n",i,CodeArea1[i],CodeArea2[i]);

	printf("\n\n");

}
void CNFAreaToCodeArea(void)
{
ULONG i;

	for(i=0;i<CNFAreas;i++)
		InsertCodeArea(CNFArea1[i],CNFArea2[i]);

}

void InsertCNFArea(ULONG adr1, ULONG adr2)
{
ULONG i;

	if (CNFAreas == 0) {
		CNFArea1[0] = adr1;
		CNFArea2[0] = adr2;
		CNFAreas++;
	}
	else {
		i=0;
		while(adr1 > CNFArea2[i] && i<CNFAreas) i++;
		if (adr1 == CNFArea2[i]) {
			CNFArea2[i] = adr2;
			while (((i+1) < CNFAreas) && (CNFArea2[i] >= CNFArea1[i+1])) {
				CNFArea2[i] = CNFArea2[i+1];
				lmovmem(&CNFArea1[i+2],&CNFArea1[i+1],CNFAreas-i-1);
				lmovmem(&CNFArea2[i+2],&CNFArea2[i+1],CNFAreas-i-1);
				CNFAreas--;
				i++;
			}
		}
		else if ((i != CNFAreas) && (adr2 >= CNFArea1[i]))
			CNFArea1[i] = adr1;
		else {
			lmovmem(&CNFArea1[i],&CNFArea1[i+1],CNFAreas-i);
			lmovmem(&CNFArea2[i],&CNFArea2[i+1],CNFAreas-i);
			CNFArea1[i] = adr1;
			CNFArea2[i] = adr2;
			CNFAreas++;
			if (CNFAreas == CNFAreaMax) {
				CNFArea1 = GetNewVarBuffer(CNFArea1,CNFAreaMax);
				CNFArea2 = GetNewVarBuffer(CNFArea2,CNFAreaMax);
				CNFAreaMax *= 2;
			}
		}
	}
}

void CreateConfig(void)
{
ULONG  i;
FILE  *file;
ULONG  machine;

/*
	while(file=fopen(configname,"r")) {
		fclose(file);
		strcat(configname,"1");
	}
*/

	if (!(configfile=fopen(configname,"w")))
		ExitPrg("Can't open %s",configname);

	/* Specify processor */
	if (CPUTYPE==M68000) machine=68000;
	if (CPUTYPE==M68010) machine=68010;
	if (CPUTYPE==M68020) machine=68020;
	if (CPUTYPE==M68030) machine=68030;
	if (CPUTYPE==M68040) machine=68040;
	if (CPUTYPE==M68060) machine=68060;
	fprintf(configfile,"MACHINE %lu\n",machine);
	if (CPUTYPE==M68881) machine=68881;
	fprintf(configfile,"MACHINE %lu\n",machine);
	if (CPUTYPE==M68851) machine=68851;
	fprintf(configfile,"MACHINE %lu\n",machine);

	fprintf(configfile,"ENTRY $%08X\n",codeentry);

	fprintf(configfile,"OFFSET $%08X\n",prgstart);

	if (pflags&BASEREG2) {
		fprintf(configfile,"BASEREG %u\n",basereg);
		fprintf(configfile,"BASEADR $%lX\n",baseadr);
		fprintf(configfile,"BASESEC %lu\n",basesec);
	}

	for(i=0;i<SymbolCount;i++)
		fprintf(configfile,"SYMBOL %s $%08X\n",SymbolName[i],SymbolValue[i]);

	for(i=0;i<CodeAreas;i++)
		fprintf(configfile,"CODE $%08X - $%08X\n",CodeArea1[i],CodeArea2[i]);

	fputs("END\n",configfile);

	fclose(configfile);configfile=0;
}

void ReadConfig(void)
{
ULONG area1,area2;
UBYTE buffer[256],*ptr1,*ptr2;
UBYTE symbol[256];
ULONG value;
UWORD i,j;
ULONG machine;

	if (!(configfile=fopen(configname,"r"))) {
		if (pflags&PREPROC) {
			printf("WARNING: Can't find %s\n",configname);
			return;
		}
		else
			ExitPrg("Can't open %s",configname);
	}

	do {
		if (!(fgets(buffer,255,configfile))) break;
		if (!strnicmp(buffer,"CODE",4)) {
			if (ptr1 = strchr(buffer,'$')) stch_l(ptr1+1,(long *)&area1);
			area2 = area1;
			if (ptr2 = strchr(ptr1+1,'$')) stch_l(ptr2+1,(long *)&area2);
			if (ptr1) {
				if (area1 < prgstart || area1 > prgende)
					ExitPrg("ERROR: %08x out of range.\n",area1);
				if (ptr2) {
					if (area2 < prgstart || area2 > prgende)
						ExitPrg("ERROR: %08x out of range (%08x-%08x).\n",area2,prgstart,prgende);
					if (area1 > area2) {
						ExitPrg("ERROR: %08x > %08x.\n",area1,area2);
					}
					else
						InsertCNFArea(area1,area2);
					if (area1 < area2) InsertCodeAdr(area1);
				}
				else
					if (area1 < prgende) InsertCodeAdr(area1);
			}
		}
		else if(!strnicmp(buffer,"SYMBOL",6)) {
			for(i=6;isspace(buffer[i]);i++);
			for(j=0;isgraph(buffer[i]);) symbol[j++]=buffer[i++];
			symbol[j]=0;
			while(isspace(buffer[i])) i++;
			if (buffer[i]=='$') stch_l(&buffer[i+1],(long *)&value);
			else value = atoi(&buffer[i+1]);
			if (value < prgstart || value >= prgende)
				ExitPrg("%sERROR: %s=%lu but must be within [%lu,%lu[.\n",buffer,value,prgstart,prgende);
			InsertSymbol(symbol,value);
		}
		else if(!strnicmp(buffer,"MACHINE",7)) {
			machine=atoi(&buffer[7]);
			CPUTYPE=0;
			if (machine==68000) CPUTYPE|=M68000;
			if (machine==68010) CPUTYPE|=M68010;
			if (machine==68020) CPUTYPE|=M68020;
			if (machine==68030) CPUTYPE|=M68030;
			if (machine==68040) CPUTYPE|=M68040;
			if (machine==68060) CPUTYPE|=M68060;
			if (machine==68851) CPUTYPE|=M68851;
			if (machine==68881) CPUTYPE|=M68881;
			if (CPUTYPE==0)
				ExitPrg("%sERROR: unknown processor.\n",buffer);
		}
		else if(!strnicmp(buffer,"OFFSET",6)) {
			if (ptr1 = strchr(buffer,'$')) stch_l(ptr1+1,(long *)&prgstart);
			else prgstart=atoi(&buffer[6]);
		}
		else if(!strnicmp(buffer,"ENTRY",5)) {
			if (ptr1 = strchr(buffer,'$')) stch_l(ptr1+1,(long *)&codeentry);
			else prgstart=atoi(&buffer[5]);
		}
		else if(!strnicmp(buffer,"BASEREG",7)) {
			if (ptr1 = strchr(&buffer[7],'a'))
				basereg=atoi(ptr1+1);
			else if (ptr1 = strchr(&buffer[7],'A'))
				basereg=atoi(ptr1+1);
			else
				basereg=atoi(&buffer[7]);
			if (basereg > 7 )
				ExitPrg("%sERROR: unknown address register.\n",buffer);
			if (!(pflags&BASEREG2)) pflags |= BASEREG1;
		}
		else if(!strnicmp(buffer,"BASEADR",7)) {
			if (ptr1 = strchr(buffer,'$')) stch_l(ptr1+1,(long *)&baseadr);
			else baseadr=atoi(&buffer[7]);
			pflags &= (~BASEREG1);
			pflags |= BASEREG2;
		}
		else if(!strnicmp(buffer,"BASESEC",7)) {
			basesec=atoi(&buffer[7]);
			if (basesec >= modulcount)
				ExitPrg("%sERROR: there aren't so many sections.\n",buffer);
			pflags &= (~BASEREG1);
			pflags |= BASEREG2;
		}
	} while (strnicmp(buffer,"END",3));

	fclose(configfile);configfile=0;
}

void InsertSymbol(UBYTE *name, ULONG value)
{
ULONG i;

	// printf("SYMBOL %s = %08X\n",name,value);

	for(i=0;i<SymbolCount;i++)
		if (SymbolValue[i] == value) return;

	SymbolValue[SymbolCount] = value;
	SymbolName[SymbolCount]  = GetPMem(strlen(name)+1);
	strcpy(SymbolName[SymbolCount++], name);

	if (SymbolCount == SymbolMax) {
		SymbolName  = GetNewVarBuffer(SymbolName,  SymbolMax);
		SymbolValue = GetNewVarBuffer(SymbolValue, SymbolMax);
		SymbolMax  *= 2;
	}
}

ULONG GetCodeAdr(ULONG *ptr)
{
	if (CodeAdrs) {
		*ptr = CodeAdr[0];
		lmovmem(&CodeAdr[1],&CodeAdr[0],CodeAdrs-1);
		CodeAdrs--;
		return(1);
	}
	return(0);
}

void InsertCodeAdr(ULONG adr)
{
ULONG l=0,m,r=CodeAdrs,i;

	/* printf("CODEADR %08X\n",adr); */

	if (!(pflags&PREPROC)) return;

	/* check if label points into an earlier processed code area */
	for(i=0;i<CodeAreas;i++) {
		if ((adr >= CodeArea1[i]) && (adr < CodeArea2[i])) {
			return;
		}
	}

	/* this case occurs pretty often */
	if ((adr > CodeAdr[CodeAdrs-1]) && CodeAdrs) {
		CodeAdr[CodeAdrs++] = adr;
	}
	else {
		/* Binaeres Suchen von adr */
		while (l<r) {
			m=(l+r)/2;
			if (CodeAdr[m] < adr) l=m+1;
			else                  r=m;
		}
		if ((CodeAdr[r] != adr) || (r == CodeAdrs)) {
			lmovmem(&CodeAdr[r],&CodeAdr[r+1],CodeAdrs-r);
			CodeAdr[r] = adr;
			CodeAdrs++;
		}
	}
	if (CodeAdrs == CodeAdrMax) {
		CodeAdr     = GetNewVarBuffer(CodeAdr,CodeAdrMax);
		CodeAdrMax *= 2;
	}
}

void InsertCodeArea(ULONG adr1, ULONG adr2)
{
ULONG i,j;

	/* printf("ICA: %08X - %08X\n",adr1,adr2); */

	if (CodeAreas == 0) {
		CodeArea1[0] = adr1;
		CodeArea2[0] = adr2;
		CodeAreas++;
	}
	else {
		i=0;
		while(adr1 > CodeArea2[i] && i<CodeAreas) i++;
		if (adr1 == CodeArea2[i]) {
			CodeArea2[i] = adr2;
			while (((i+1) < CodeAreas) && (CodeArea2[i] >= CodeArea1[i+1])) {
				CodeArea2[i] = CodeArea2[i+1];
				lmovmem(&CodeArea1[i+2],&CodeArea1[i+1],CodeAreas-i-1);
				lmovmem(&CodeArea2[i+2],&CodeArea2[i+1],CodeAreas-i-1);
				CodeAreas--;
				i++;
			}
		}
		else if ((i != CodeAreas) && (adr2 >= CodeArea1[i]))
			CodeArea1[i] = adr1;
		else {
			lmovmem(&CodeArea1[i],&CodeArea1[i+1],CodeAreas-i);
			lmovmem(&CodeArea2[i],&CodeArea2[i+1],CodeAreas-i);
			CodeArea1[i] = adr1;
			CodeArea2[i] = adr2;
			CodeAreas++;
			if (CodeAreas == CodeAreaMax) {
				CodeArea1 = GetNewVarBuffer(CodeArea1,CodeAreaMax);
				CodeArea2 = GetNewVarBuffer(CodeArea2,CodeAreaMax);
				CodeAreaMax *= 2;
			}
		}
	}

	fprintf(stderr,"Areas: %4lu  \r",CodeAreas);
	fflush(stderr);

	/* remove all labels that point within a earlier processed code area */
	for(j=0;j<CodeAreas;j++) {
		for(i=0;i<CodeAdrs;) {
			if ((CodeAdr[i] >= CodeArea1[j]) && (CodeAdr[i] < CodeArea2[j])) {
				lmovmem(&CodeAdr[i+1],&CodeAdr[i],CodeAdrs-i-1);
				CodeAdrs--;
			}
			else i++;
		}
	}
/*
	printf("adr1=%08X  adr2=%08X\n",adr1,adr2);
	printf("--------\n");
	PrintAreas();
*/
}

void SectionToArea(void)
{
ULONG i,j,ptr1;

	if (!(pflags&PREPROC)) {
		for(i=0;i<modulcount;i++) {
			if (modultype[i] == 0x03E9) {
				if (i==0) {
					InsertCodeArea(codeentry,moduloffs[i]+modultab[i]);
				}
				else {
					InsertCodeArea(moduloffs[i],moduloffs[i]+modultab[i]);
				}
			}
		}
	}

	/* need at least one code area for the following algorythm */
	if (CodeAreas == 0) CodeAreas = 1;

	/* splitting code areas where sections begin or end */
	for(i=0;i<modulcount;i++) {
		if (modultab[i] == 0) continue;
		ptr1 = moduloffs[i]+modultab[i];
		if (ptr1 <= CodeArea2[CodeAreas-1]) {
			for(j=0;j<CodeAreas;j++) {
				if (ptr1 < CodeArea2[j]) {
					if (ptr1 == CodeArea1[j]) break;
					lmovmem(&CodeArea1[j],&CodeArea1[j+1],CodeAreas-j);
					lmovmem(&CodeArea2[j],&CodeArea2[j+1],CodeAreas-j);
					if (ptr1 < CodeArea1[j])
						CodeArea1[j] = CodeArea2[j] = ptr1;
					else if (ptr1 > CodeArea1[j])
						CodeArea2[j] = CodeArea1[j+1] = ptr1;
					CodeAreas++;
					if (CodeAreas == CodeAreaMax) {
						CodeArea1 = GetNewVarBuffer(CodeArea1,CodeAreaMax);
						CodeArea2 = GetNewVarBuffer(CodeArea2,CodeAreaMax);
						CodeAreaMax *= 2;
					}
				break;
				}
			}
		}
		else {
			CodeArea2[CodeAreas] = CodeArea1[CodeAreas] = ptr1;
			CodeAreas++;
			if (CodeAreas == CodeAreaMax) {
				CodeArea1 = GetNewVarBuffer(CodeArea1,CodeAreaMax);
				CodeArea2 = GetNewVarBuffer(CodeArea2,CodeAreaMax);
				CodeAreaMax *= 2;
			}
		}
	}

	if (CodeArea1[0] != prgstart) InsertCodeArea(prgstart,prgstart);
}

void DPass0(void)
{
UWORD  dummy;
UWORD  EndFlag=0;
ULONG  ptr1,ptr2,i;

	PASS = 0;
	ptr2 = (prgende-prgstart)/2;
	if (!(pflags&ROMTAGatZERO) && !(pflags&CONFIG)) InsertCodeAdr(codeentry);
	fprintf(stderr,"Pass 0: scanning for data in code\n");

/*
	for(nextreloc=0;nextreloc<relocount;nextreloc++)
		if (RelocAdr[nextreloc] >= ptr1)
			break;
*/

	while(GetCodeAdr(&ptr1)) {

		prgcount = (ptr1 - prgstart)/2;

		/* find out in which section we are */
		for(modulcnt=0;modulcnt<modulcount;modulcnt++) {
			if ((ptr1 >= moduloffs[modulcnt]) &&
				 (ptr1 <  (moduloffs[modulcnt]+modultab[modulcnt]))) {
				CodeAreaEnd = (moduloffs[modulcnt]+modultab[modulcnt]-prgstart)/2;
				break;
			}
		}

		/* find the first relocation in this code area */
		for(nextreloc=0;nextreloc<relocount;nextreloc++)
			if (RelocAdr[nextreloc] >= ptr1)
				break;

		EndFlag = 0;
		while(EndFlag == 0) {

			if (RelocAdr[nextreloc] == (prgcount*2 + prgstart)) {
				nextreloc++;
				prgcount += 2;
				continue;
			}
			pc = prgcount;
			sigw=(UWORD)buffer[prgcount++];


			GetOpcode();
			if (flags[opcnumber]&0x20) {
				extra=buffer[prgcount];
				if (P1WriteReloc()) continue;
			}

			if (opcnumber == OPC_CMPI) {
				if (CPUTYPE&M020UP) destadr[opcnumber]=0x0bfe;
				else destadr[opcnumber]=0x0bf8;
			} else if (opcnumber==OPC_TST) {
				if (CPUTYPE&M020UP) sourceadr[opcnumber]=0x0fff;
				else sourceadr[opcnumber]=0x0bf8;
			} else if (opcnumber==OPC_BITFIELD) {
				dummy=(sigw&0x0700)>>8;
				if (dummy==2 || dummy==4 || dummy==6 || dummy==7) sourceadr[opcnumber]=0x0a78;
				else sourceadr[opcnumber]=0x0a7e;
			} else if (opcnumber==OPC_C2) {
				if (extra&0x07ff) adrmode=NOADRMODE;
				else {
					reg1=(extra&0x7000)>>12;
					if (extra&0x8000) destadr[opcnumber]=0xa001;
					else destadr[opcnumber]=0xa000;
				}
			} else if (opcnumber==OPC_MOVE162) {
				switch ((buffer[prgcount]&0x0018)>>3) {
					case 0: /* (An)+,(xxx).L */
						sourceadr[opcnumber]=0x8003;
						destadr[opcnumber]  =0x8008;
						break;
					case 1: /* (xxx).L,(An)+ */
						sourceadr[opcnumber]=0x8008;
						destadr[opcnumber]  =0x8003;
						break;
					case 2: /* (An) ,(xxx).L */
						sourceadr[opcnumber]=0x8002;
						destadr[opcnumber]  =0x8008;
						break;
					case 3: /* (xxx).L, (An) */
						sourceadr[opcnumber]=0x8008;
						destadr[opcnumber]  =0x8002;
						break;
				}
			} else if (opcnumber==OPC_MOVES) {
				if (extra&0x0800) {
					sourceadr[opcnumber]=0x8022;
					destadr[opcnumber]  =0x03f8;
				}
				else {
					sourceadr[opcnumber]=0x03f8;
					destadr[opcnumber]  =0x8022;
				}
			}

			if ((flags[opcnumber]&0x40) && extens==3) adrmode=NOADRMODE;

			if (sourceadr[opcnumber])
				if (DoAdress1(sourceadr[opcnumber])) continue;
			if (destadr[opcnumber]) {
				if (opcnumber==OPC_MOVEB || opcnumber==OPC_MOVEW || opcnumber==OPC_MOVEL) {
					adrmode=((sigw&0x01c0)>>3)|reg1;
					if (adrmode<0x38) adrmode=(adrmode>>3);
					else adrmode=7+reg1;
					reg2=reg1;
				}
				if (DoAdress1(destadr[opcnumber])) continue;
				else {
					if (opcnumber==OPC_LEA || opcnumber==OPC_MOVEAL) {
						if (pflags&BASEREG1) {
							if (adrmode2==1 && reg1==basereg)
								printf("BASEREG\t%08X: A%hd\n",pc*2+prgstart,basereg);
						}
					}
				}
			}

			/* Check for data in code */
			/**************************/

/*			printf("adr=%08x  opc=%lu  adrflag=%lu\n",LabAdr,opcnumber,LabAdrFlag); */
			if (LabAdrFlag == 1) {
				if (opcnumber == OPC_BCC  ||
					 opcnumber == OPC_JSR  ||
					 opcnumber == OPC_DBCC ||
					 opcnumber == OPC_JMP  ||
					 opcnumber == OPC_CALLM)
					if ((LabAdr < ptr1) || (LabAdr > (prgcount*2+prgstart)))
						InsertCodeAdr(LabAdr);
				LabAdrFlag = 0;
			}
			if ((((opcnumber == OPC_BCC) && (sigw&0xFF00) == 0x6000)) ||
				opcnumber == OPC_JMP ||
				opcnumber == OPC_RTS ||
				opcnumber == OPC_RTE ||
				opcnumber == OPC_RTR ||
				opcnumber == OPC_RTD ||
				opcnumber == OPC_RTM)
			{
				EndFlag = 1;
				for(i=0;i<CNFAreas;i++) {
					if ((CNFArea1[i] < (prgcount*2+prgstart)) &&
						 (CNFArea2[i] > (prgcount*2+prgstart))) {
						EndFlag = 0;
						break;
					}
				}
				if (EndFlag == 1)
					InsertCodeArea(ptr1, prgcount*2+prgstart);
			}
			if (prgcount == ptr2) {
				InsertCodeArea(ptr1, prgcount*2+prgstart);
				EndFlag = 1;
			}
			if (prgcount > ptr2)
				printf("Watch out: prgcount*2(=%08x) > (prgende-prgstart)(=%08x)\n",prgcount*2,prgende-prgstart);

		}

		/* Speeding up (takes out reduncies in code checking) */
		for(i=0;i<CNFAreas;i++) {
			if (CNFArea2[i] == (prgcount*2+prgstart)) {
				if (CNFArea1[i] <= ptr1) {
					CNFArea2[i] = ptr1;
					break;
				}
			}
		}
	}

	fprintf(stderr,"\n");

/*
	PrintAreas();
*/
	/* preparing sections to be area aligned */
	SectionToArea();

/*	printf("CodeAdrs: %lu   CodeAdrMax: %lu\n",CodeAdrs,CodeAdrMax); */
/*	PrintAreas(); */
}

void main(int argc,char **argv)
{
	ARGC = argc;
	ARGV = argv;

	Init();
	InitOpcode();
	SearchRomTag();
	if (pflags&PREPROC) {
		/* SearchCode(); */
		DPass0();
		CreateConfig();
	} else if (pflags&CONFIG) {
		CNFAreaToCodeArea();
	} else {
		SectionToArea();
	}
	PrintAreas();
	DPass1();
	DPass2();
	ExitPrg("\n");
}

void DPass2()
{
ULONG  modtype;
UWORD  tflag,text,dummy,flag;
UWORD  longs_per_line;
LONG   dummy1;
ULONG  dummy2;
ULONG  i,j,k,l,m,r,rel,zero,alpha;
UBYTE *buf,*tptr;
ULONG  ptr1,ptr2,end,area;

	PASS = 2;
	LabelAdr2  = GetPMem(LabelMax*4+4);

	if (labcount) { /* Wenn ueberhaupt Labels vorhanden sind */
		fprintf(stderr,"Pass 2: correcting labels\n");
		if (!(labfile = fopen(labname,"r")))
			ExitPrg("Can't open %s\n",labname);

		labelbuf = GetPMem(labc1*sizeof(ULONG));
		fread(labelbuf,4,labc1,labfile);
		fclose(labfile);labfile=0; 
		remove(labname);
		for(i=0;i<labcount;i++) {
			dummy1 = LabelAdr2[i] = LabelAdr[i];
			if (dummy1 < (LONG)prgstart) LabelAdr2[i]=prgstart;
			for(j=0;j<CodeAreas;j++) {
				if ((dummy1>=CodeArea1[j]) && (dummy1<CodeArea2[j])) {

					/* Binaeres Suchen von dummy1 */
					l=0;r=labc1;
					while (l<r) {
						m=(l+r)/2;
						if ((long)labelbuf[m]<dummy1) l=m+1;
						else                          r=m;
					}
					if (labelbuf[r]!=dummy1 || r==labc1) {
						if (r>0) LabelAdr2[i] = labelbuf[r-1];
						else LabelAdr2[i] = 0;
					}
					break;
				}
			}
		}
		/* Don't free mem, or phase checking won't work !!! */
		/* Freemem(labelbuf,labc1*sizeof(ULONG));labelbuf=0; */
	} /* Ende der Labelbearbeitung */


	if (textmethod) {
		fprintf(stderr,"Pass 2: searching for text\n");

		for(modulcnt=0;modulcnt<modulcount;modulcnt++) {
			modtype = modultype[modulcnt];
			/* BSS hunk --> there is no text */
			if (modtype == 0x03EB) continue;
			if (!modultab[modulcnt]) continue;
			buf=(UBYTE *)buffer+moduloffs[modulcnt];

			for(rel=0,i=0;i<modultab[modulcnt]-1;i++) {
				k=i;text=1;alpha=0;
				while (isprint(buf[k]) || isspace(buf[k])) {
					if (buf[k]>127) {text=0;break;}
					if (isalpha(buf[k]) && isalpha(buf[k+1])) alpha++;
					else if (alpha < 4) alpha=0;
					k++;
				}

				/* there must be more than 4 letters concatenated */
				if (alpha < 4) {i=k;continue;}

				/* text should be null terminated */
				if (buf[k]!=0) {i=k;continue;}

				/* a text must have a minimum length */
				if ((k-i)<=5) {i=k;continue;}

				/* relocations don't have to be in a text */
				while(RelocAdr[rel]<=(i+moduloffs[modulcnt]-4) && rel<relocount) rel++;
				if (rel<relocount) {
					if (RelocAdr[rel]<=(k+moduloffs[modulcnt])) {
						i=k;continue;
					}
				}

				if (text) {

					/* RTS --> seems to be code */
					if (buf[k-2]!=0x4E && buf[k-1]!=0x75) {
					printf("TEXT\t%08x:\n",moduloffs[modulcnt]-prgstart+i);
					printf("\tDC.B\t");
					for(tflag=0,j=i;j<=k;j++) {
						if (isprint(buf[j]) && buf[j]!='\"') {
							if (tflag==0) printf("\"%c",buf[j]);
							if (tflag==1) printf("%c",buf[j]);
							if (tflag==2) printf(",\"%c",buf[j]);
							tflag=1;
						} else {
							if (tflag==0) printf("%d",(int)buf[j]);
							if (tflag==1) printf("\",%d",(int)buf[j]);
							if (tflag==2) printf(",%d",(int)buf[j]);
							tflag=2;
						}
					}
					if (tflag==1) printf("\"\n");
					if (tflag==2) printf("\n");
					}
				}
				i=k;
			}
		}
	}

	fprintf(stderr,"Pass 2: writing mnemonics\n");


	if (!(targetfile = fopen(targetname,"w")))
		ExitPrg("Can't open %s\n",targetname);

	fprintf(targetfile,IDSTRING2,VERSION,REVISION);
	
	/* Write EQU's */
	if (XRefCount) {
		for(i=0;i<XRefCount;i++) {
			adrbuf[0]=0;
			GetExtName(i);
			if (strlen(adrbuf)<8) adrcat("\t");
			fprintf(targetfile,"%s\tEQU\t$%X\n",adrbuf,XRefListe[i]);
		}
		adrbuf[0]=0;
		fprintf(targetfile,"\n\n");
	}

	/* Specify processor */
	if (CPUTYPE&M68000) dummy2=68000;
	if (CPUTYPE&M68010) dummy2=68010;
	if (CPUTYPE&M68020) dummy2=68020;
	if (CPUTYPE&M68030) dummy2=68030;
	if (CPUTYPE&M68040) dummy2=68040;
	if (CPUTYPE&M68060) dummy2=68060;
	if (dummy2 != 68000) {
		fprintf(targetfile,"\tMACHINE\t%ld\n",dummy2);
	}
	if (CPUTYPE&M68881 && !CPUTYPE&(M68040|M68060))
		fprintf(targetfile,"\tFPU\n");
	if (dummy2==68020 && CPUTYPE&M68851)
		fprintf(targetfile,"\tPMMU\n");
	fprintf(targetfile,"\n");

	if (pflags&BASEREG2) {
		fprintf(targetfile,"\tNEAR\tA%hu,%ld\n\n",basereg,basesec);
	}


	/* If splitted, write INCLUDE directives */
	if (pflags&SPLITFILE) {
		for(modulcnt=0;modulcnt<modulcount;modulcnt++) {
			if (!modultab[modulcnt])
				if (!(pflags&KEEP_ZEROHUNKS)) continue;
			fprintf(targetfile,"\tINCLUDE\t\"%s.S%s\"\n",targetname,itoa(modulcnt));
		}
		fprintf(targetfile,"\tEND\n");
		fclose(targetfile);targetfile=0;
	}


	prgcount = 0;
	nextreloc= 0;
	modulcnt = 0xFFFFFFFF;

	for(area=0;area<CodeAreas;area++) {

		while ((moduloffs[modulcnt+1] == CodeArea1[area]) && ((modulcnt+1) < modulcount)) {
			modulcnt++;
			modtype = modultype[modulcnt];
			if (pflags&SPLITFILE) {
				if (targetfile) {
					fclose(targetfile);
				}
				strcpy(tsname,targetname);
				strcat(tsname,".S");
				strcat(tsname,itoa(modulcnt));
				if (!(targetfile = fopen(tsname,"w")))
					ExitPrg("Can't open %s\n",tsname);
			}

			if ((modultab[modulcnt] != 0) || (pflags&KEEP_ZEROHUNKS)) {
				if (memtype[modulcnt])
					fprintf(targetfile,"\n\n\tSECTION S_%ld,%s,%s\n\n",modulcnt,modname[modtype-0x03E9],memtypename[memtype[modulcnt]]);
				else
					fprintf(targetfile,"\n\n\tSECTION S_%ld,%s\n\n",modulcnt,modname[modtype-0x03E9]);
				flag = 1;
				while(LabelAdr2[p2labind]==moduloffs[modulcnt] && p2labind<labcount) {
					if (GetSymbol(LabelAdr[p2labind])) {
						fprintf(targetfile,"%s:\n",adrbuf);
						adrbuf[0]=0;
					}
					else flag = 0;
					p2labind++;
				}
				if (flag == 0)
					fprintf(targetfile,"SECSTRT_%ld:\n",modulcnt);
			}
		}

		dtabuf[0]=0;
		adrbuf[0]=0;
		mnebuf[0]=0;

		/* HERE BEGINS THE CODE PART OF PASS 2 */
		/***************************************/

		CodeAreaEnd = (CodeArea2[area]-prgstart)/2;

		CheckPhase (-1); /* Phasenangleich */ 

		while(prgcount < CodeAreaEnd) {

			CheckPhase(prgcount*2+prgstart);

			WriteLabel2(prgstart+prgcount*2);

			dtacat(itohex(prgstart+prgcount*2,adrlen));
			dtacat(": ");
			if (RelocAdr[nextreloc] == (prgcount*2 + prgstart)) {
				mnecat("DC.L");
				dtacat(itohex(buffer[prgcount],4));
				dtacat(itohex(buffer[prgcount+1],4));
				GetLabel(RelocVal[nextreloc],9999);
				nextreloc++;
				Ausgabe();
				prgcount += 2;
				continue;
			}
			pc = prgcount;
			sigw=buffer[prgcount++];
			dtacat(itohex(sigw,4));


			GetOpcode();
			mnecat(&opcode[opcnumber][0]);
			if (flags[opcnumber]&0x20) {
				extra=buffer[prgcount];
				if (P2WriteReloc()) continue;
			}
			if (flags[opcnumber]&0x10) {
				dummy=(sigw&0x0f00)>>8;
				if (opcnumber==OPC_BCC && dummy<2) dummy+=16;
				mnecat(condcode[dummy]);
			}


			if (opcnumber == OPC_CMPI) {
				if (CPUTYPE&M020UP) destadr[opcnumber]=0x0bfe;
				else destadr[opcnumber]=0x0bf8;
			} else if (opcnumber == OPC_BITSHIFT1) {
				/* SHIFT & ROTATE memory */
				mnecat(bitshift[(sigw>>9)&0x0003]);
				if (sigw&0x0100) mnecat("L");
				else mnecat("R");
			} else if (opcnumber == OPC_BITSHIFT2) {
				/* SHIFT & ROTATE Data Register */
				mnecat(bitshift[(sigw>>3)&0x0003]);
				if (sigw&0x0100) mnecat("L");
				else mnecat("R");
				if (sigw&0x0020) adrcat("D");
				else {
					adrcat("#");
					if (!reg1) reg1=8;
				}
				adrcat(itohex(reg1,1));
				adrcat(",");
			} else if (opcnumber==OPC_TST) {
				if (CPUTYPE&M020UP) sourceadr[opcnumber]=0x0fff;
				else sourceadr[opcnumber]=0x0bf8;
			} else if (opcnumber==OPC_BITFIELD) {
				dummy=(sigw&0x0700)>>8;
				mnecat(bitfield[dummy]);
				if (dummy==2 || dummy==4 || dummy==6 || dummy==7) sourceadr[opcnumber]=0x0a78;
				else sourceadr[opcnumber]=0x0a7e;
			} else if (opcnumber==OPC_C2) {
				if (extra&0x07ff) adrmode=NOADRMODE;
				else {
					if (extra&0x0800) mnecat("HK2");
					else mnecat("MP2");
					reg1=(extra&0x7000)>>12;
					if (extra&0x8000) destadr[opcnumber]=0xa001;
					else destadr[opcnumber]=0xa000;
				}
			} else if (opcnumber==OPC_MOVE162) {
				switch ((buffer[prgcount]&0x0018)>>3) {
					case 0: /* (An)+,(xxx).L */
						sourceadr[opcnumber]=0x8003;
						destadr[opcnumber]  =0x8008;
						break;
					case 1: /* (xxx).L,(An)+ */
						sourceadr[opcnumber]=0x8008;
						destadr[opcnumber]  =0x8003;
						break;
					case 2: /* (An) ,(xxx).L */
						sourceadr[opcnumber]=0x8002;
						destadr[opcnumber]  =0x8008;
						break;
					case 3: /* (xxx).L, (An) */
						sourceadr[opcnumber]=0x8008;
						destadr[opcnumber]  =0x8002;
						break;
				}
			} else if (opcnumber==OPC_MOVES) {
				if (extra&0x0800) {
					sourceadr[opcnumber]=0x8022;
					destadr[opcnumber]  =0x03f8;
				}
				else {
					sourceadr[opcnumber]=0x03f8;
					destadr[opcnumber]  =0x8022;
				}
			}

			if (flags[opcnumber]&0x40) {
				if (extens!=3)
					mnecat(extension[extens]);
				else
					adrmode=NOADRMODE;
			}

			if (sourceadr[opcnumber]) {
				if (DoAdress2(sourceadr[opcnumber])) continue;
				if (opcnumber!=OPC_BITFIELD)
					if (destadr[opcnumber]) adrcat(",");
			}
			if (destadr[opcnumber]) {
				if (opcnumber==OPC_MOVEB || opcnumber==OPC_MOVEW || opcnumber==OPC_MOVEL) {
					adrmode=((sigw&0x01c0)>>3)|reg1;
					if (adrmode<0x38) adrmode=(adrmode>>3);
					else adrmode=7+reg1;
					reg2=reg1;
				}
				if (DoAdress2(destadr[opcnumber])) continue;
				if (opcnumber==OPC_PACK1 || opcnumber==OPC_PACK2 ||
					 opcnumber==OPC_UNPK1 || opcnumber==OPC_UNPK2) {
					adrcat(",#$");
					adrcat(itohex(extra,4));
				}
			}

			if (NearFlag == 1) WriteTarget("\tFAR\n",5);
			Ausgabe();
			if (NearFlag == 1) {WriteTarget("\tNEAR\n",6);NearFlag=0;};

			if (prgcount > CodeAreaEnd)
				printf("P2 Watch out: prgcount*2(=%08x) > (prgende-prgstart)(=%08x)\n",prgcount*2,prgende-prgstart);

		}


		while ((moduloffs[modulcnt+1] == CodeArea2[area]) && ((modulcnt+1) < modulcount)) {
			modulcnt++;
			modtype = modultype[modulcnt];
			if (pflags&SPLITFILE) {
				if (targetfile) {
					fclose(targetfile);
				}
				strcpy(tsname,targetname);
				strcat(tsname,".S");
				strcat(tsname,itoa(modulcnt));
				if (!(targetfile = fopen(tsname,"w")))
					ExitPrg("Can't open %s\n",tsname);
			}
			if ((modultab[modulcnt] != 0) || (pflags&KEEP_ZEROHUNKS)) {
				if (memtype[modulcnt])
					fprintf(targetfile,"\n\n\tSECTION S_%ld,%s,%s\n\n",modulcnt,modname[modtype-0x03E9],memtypename[memtype[modulcnt]]);
				else
					fprintf(targetfile,"\n\n\tSECTION S_%ld,%s\n\n",modulcnt,modname[modtype-0x03E9]);
				flag = 1;
				while(LabelAdr2[p2labind]==moduloffs[modulcnt] && p2labind<labcount) {
					if (GetSymbol(LabelAdr[p2labind])) {
						fprintf(targetfile,"%s:\n",adrbuf);
						adrbuf[0]=0;
					}
					else flag=0;
					p2labind++;
				}
				if (flag == 0)
					fprintf(targetfile,"SECSTRT_%ld:\n",modulcnt);
			}
		}

		/* HERE BEGINS THE DATA PART OF PASS 2 */
		/***************************************/


		ptr1=CodeArea2[area];
		if ((area+1)<CodeAreas) 
			end = CodeArea1[area+1];
		else
			end = prgende;

		while (ptr1 < end) {

			text=0;

			/* write label and/or relocation */
			WriteLabel2(ptr1);
			if (RelocAdr[nextreloc] == ptr1) {
				dtacat(itohex(ptr1,adrlen));
				dtacat(": ");
				dtacat(itohex(buffer[(ptr1-prgstart)/2],4));
				dtacat(itohex(buffer[(ptr1-prgstart+2)/2],4));
				ptr1 += 4;
				ptr2  = ptr1;
				mnecat("DC.L");
				GetLabel(RelocVal[nextreloc],9999);
				nextreloc++;
				Ausgabe();
				continue;
			}

			/* initialize upper textbound */
			ptr2=end;
			if (p2labind < labcount) ptr2=LabelAdr2[p2labind];
			if (nextreloc < relocount && RelocAdr[nextreloc] < ptr2)
				ptr2=RelocAdr[nextreloc];
			if (end < ptr2) ptr2=end;


			buf=(UBYTE *)((ULONG)buffer+ptr1-prgstart);

			/* a text must have a minimum length */
			if ((ptr2-ptr1) > 4) {

				/* I think a text shouldn't begin with a zero-byte */ 
				if (buf[0]!=0) {

				for(j=0,zero=0,text=1;j<(ptr2-ptr1);j++) {
/*					if (buf[j]>127) {text=0;break;} */
					if (buf[j]==0) {
						if ((j+1)<(ptr2-ptr1)) {
							if (buf[j+1]==0) {
								zero++;
								if (zero > 4) {text=0;break;}
							}
							else {
								if (text < 4) text=0;
							}
						}
					} else {
						if (!isprint(buf[j]) &&
							 !isspace(buf[j]) &&
							 buf[j] != 0x1b   &&
							 buf[j] != 0x9b)
							{text=0;break;}
						else {
							text++;
							zero=0;
						}
					}
				}
				if ((buf[j-1] != 0) && (text<6)) text=0;
				if (text < 4) text=0;
				if (zero > 4) text=0;
				if (text) {

					/* write buffer to file */
					if (pflags&ADR_OUTPUT) {
						mnecat(";");
						mnecat(itohex(ptr1,adrlen));
						Ausgabe();
					}


					if ((ptr2-ptr1) > 10000) {
						printf("ptr1=%08x  ptr2=%08x  end=%08x\n",ptr1,ptr2,prgende);
					}

					/* get buffer for string */
					tptr=GetPMem((ptr2-ptr1)*5+6);

					if (pflags&ADR_OUTPUT) {
						for(i=0;i<((ptr2-ptr1-1)/16+1);i++) {
							strcpy(tptr,"\t;DC.B\t");k=7;
							strcpy(&tptr[k++],"$");
							strcpy(&tptr[k],itohex((ULONG)buf[i*16],2));k+=2;
							for(j=i*16+1;j<(ptr2-ptr1) && j<((i+1)*16);j++) {
								strcpy(&tptr[k],",$");k+=2;
								strcpy(&tptr[k],itohex((ULONG)buf[j],2));k+=2;
							}
							tptr[k++]='\n';
							WriteTarget(tptr,k);
						}
					}

					/* create string */
					for(tflag=0,j=0,k=0;j<(ptr2-ptr1);j++) {
						if ((j==0) ||
							 (j>0 && buf[j-1]==0  && buf[j]!=0) ||
							 (j>0 && buf[j-1]==10 && buf[j]!=0 && buf[j]!=10)) {
							if (tflag != 0) tptr[k++]='\n';
							strcpy(&tptr[k],"\tDC.B\t");k+=6;
							tflag=0;
						}
						if (isprint(buf[j])) {
							if (tflag==0) tptr[k++]='\"';
							if (tflag==2) {tptr[k++]=',';tptr[k++]='\"';}
							if (buf[j]=='\"' || buf[j]=='\'') tptr[k++]='\\';
							tptr[k++]=buf[j];
							tflag=1;
						} else {
							if (tflag==1) {tptr[k++]='\"';tptr[k++]=',';}
							if (tflag==2) tptr[k++]=',';
							strcpy(&tptr[k],itoa((ULONG)buf[j]));
							if (buf[j]>99) k+=3;
							else if (buf[j]>9) k+=2;
							else k++;
							tflag=2;
						}
					}
					if (tflag==1) tptr[k++]='\"';
					tptr[k++]='\n';

					/* write string */
					WriteTarget(tptr,k);

					/* free stringbuffer */
					FreeMem(tptr,(ptr2-ptr1)*5+6);

				}
				}
			}
			if (text == 0) {
				dtacat(itohex(ptr1,adrlen));

				if (((ULONG)buf)&1) {
					if ((*buf)==0) {
						mnecat("DS.B");
						adrcat("1");
					} else {
						mnecat("DC.B");
						adrcat("$");
						adrcat(itohex(*buf,2));
					}
					buf++;
					ptr1++;
					Ausgabe();
				}
				longs_per_line=0;
				while((ptr2-ptr1)>=4) {
					if ((*((ULONG *)buf))==0) {
						if (longs_per_line) Ausgabe();
						longs_per_line=0;
						for(i=0;(ptr2-ptr1)>=4 && (*((ULONG *)buf))==0;ptr1+=4,buf+=4) i++;
						mnecat("DS.L");
						adrcat(itoa(i));
						Ausgabe();
					}
					else {
						if (longs_per_line == 0) {
							mnecat("DC.L");
							adrcat("$");
						} else {
							adrcat(",$");
						}
						adrcat(itohex(*((ULONG *)buf),8));
						longs_per_line++;
						buf+=4;
						ptr1+=4;
						if (longs_per_line == 4) {
							longs_per_line=0;
							Ausgabe();
						}
					}
				}
				if (longs_per_line) Ausgabe();
				if ((ptr2-ptr1) > 1) {
					if ((*((UWORD *)buf))==0) {
						mnecat("DS.W");
						adrcat("1");
					} else {
						mnecat("DC.W");
						adrcat("$");
						adrcat(itohex(*((UWORD *)buf),4));
					}
					buf+=2;
					ptr1+=2;
					Ausgabe();
				}
				if (ptr2-ptr1) {
					if ((*buf)==0) {
						mnecat("DS.B");
						adrcat("1");
					} else {
						mnecat("DC.B");
						adrcat("$");
						adrcat(itohex(*buf,2));
					}
					buf++;
					ptr1++;
					Ausgabe();
				}
			}
			ptr1 = ptr2;
		}

		prgcount = (end-prgstart)/2;


	}

	if (pflags&SPLITFILE) {
		fclose(targetfile);
		targetfile=0;
	}

	/* write last label */
	WriteLabel2(prgstart+prgcount*2);

	if (p2labind != labcount) {
		fprintf(stderr,"labcount=%ld  p2labind=%ld\n",labcount,p2labind);
	}

	if (!(pflags&SPLITFILE))
		WriteTarget("\tEND\n",5);

	fprintf(stderr,"100%%\n\n");
}
void CheckPhase(ULONG adr)
{
static ULONG lc=0;

	if (labcount) {
		if (adr == -1)
			while (labelbuf[lc] < prgcount*2+prgstart) lc++;
		else {
			if (adr != labelbuf[lc++]) printf("PHASE ERROR: adr=%08x  %08x %08x %08x\n",adr,labelbuf[lc-2],labelbuf[lc-1],labelbuf[lc]);
			while (lc<labc1 && labelbuf[lc]==labelbuf[lc-1]) lc++;
		}
	}

}
void WriteLabel2(ULONG adr)
{
ULONG index;
UWORD flag;
static ULONG oldadr=0;

	/* output of percent every 2 kb */
	if ((adr-oldadr) >= 2048) {
		fprintf(stderr,"%3d%%\r",((adr-prgstart)*100)/prglen);
		fflush(stderr);
		oldadr = adr;
	}

	/* Labels fuer aktuelle Adresse schreiben */
	if (LabelAdr2[p2labind]<adr && p2labind<labcount) printf("%x adr=%x This=%x\n",p2labind,adr,LabelAdr2[p2labind]);
	if (LabelAdr2[p2labind]==adr && p2labind<labcount) {
		flag = 1;index=p2labind;
		while(LabelAdr2[p2labind]==adr && p2labind<labcount) {
			if (GetSymbol(LabelAdr[p2labind])) {
				fprintf(targetfile,"%s:\n",adrbuf);
				adrbuf[0]=0;
			}
			else
				flag=0;
			p2labind++;
		}
		if (flag == 0)
			fprintf(targetfile,"LAB_%04lX:\n",index);
	}
}
void Ausgabe(void)
{
WORD i;
	/* Hier findet die Ausgabe statt */
	if (pflags&ADR_OUTPUT) {
		if (dtabuf[0]) {
			i = 3-strlen(adrbuf)/8;
			if (i<=0) adrcat(" ");
			for(;i>0;i--) adrcat("\t");
			fprintf(targetfile,"\t%s\t%s;%s\n",mnebuf,adrbuf,dtabuf);
		}
		else if (adrbuf[0])
			fprintf(targetfile,"\t%s\t%s\n",mnebuf,adrbuf);
		else
			fprintf(targetfile,"\t%s\n",mnebuf);
	}
	else {
		if (adrbuf[0]) fprintf(targetfile,"\t%s\t%s\n",mnebuf,adrbuf);
		else fprintf(targetfile,"\t%s\n",mnebuf);
	}
	dtabuf[0]=0;
	adrbuf[0]=0;
	mnebuf[0]=0;
}
int P2WriteReloc()
{
	if (RelocAdr[nextreloc] == (prgcount*2 + prgstart)) {
		dtabuf[0]=0;
		mnebuf[0]=0;
		adrbuf[0]=0;
		mnecat("DC.W");
		adrcat("$");
		adrcat(itohex(sigw,4));
		dtacat(itohex(pc*2+prgstart,adrlen));
		prgcount=pc+1;
		Ausgabe();
		return(-1);
	}
	else {
		dtacat(itohex(buffer[prgcount++],4));
		return(0);
	}
}
UWORD NewAdrModes2(UWORD mode,UWORD reg)
/* AdrType :  6 --> Baseregister An */
/*           10 --> PC-relative     */
{
UWORD buf=buffer[prgcount];
UWORD scale;
UWORD bdsize;
UWORD odsize;
UWORD iis;
UWORD is;
UWORD operand,square1,square2;
LONG  adr;


	if (P2WriteReloc()) return((UWORD)-1);

	/* Achtung: Ungerade Offsets werden vom A68K nicht angenommen */
	if (CPUTYPE&(M68000|M68010)) {
		if (buf&0x0700) return(NOADRMODE);
		else {
			if (mode==10) {
				adr = ((prgcount-1)*2+prgstart+(BYTE)buf);
				if (adr>=(LONG)(moduloffs[modulcnt]+modultab[modulcnt]) || adr<(LONG)(moduloffs[modulcnt]-8) || (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR)))
					return(NOADRMODE);
			}
			if (pflags&OLDSTYLE) {
				if (mode==10) GetLabel(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
				adrcat("(");
			}
			else {
				adrcat("(");
				if (mode==10) GetLabel(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
				adrcat(",");
			}
			if (mode==6) {
				adrcat("A");
				adrcat(itohex(reg,1));
			}
			else adrcat("PC");
			if (buf&0x8000) adrcat(",A");
			else adrcat(",D");
			adrcat(itohex((buf>>12)&7,1));
			if (buf&0x0800) adrcat(".L");
			/* else adrcat(".W"); */
		}
	}
	else {
		scale =(buf&0x0600)>>9;
		if (buf&0x0100) { /* MC68020 (& up) FULL FORMAT */
			bdsize=(buf&0x0030)>>4;
			odsize=(buf&0x0003);
			iis   =(buf&0x0007);
			is    =(buf&0x0040)>>6;
			operand=square1=square2=0;

			if (mode==10) reg=0;
			if (buf&8)                 return(NOADRMODE);
			if (bdsize==0)             return(NOADRMODE);
			if (is==0 && iis==4)       return(NOADRMODE);
			if (is==1 && iis>=4)       return(NOADRMODE);
/*
			if (is==1 && (buf&0xfe00)) return(NOADRMODE);
			if (buf&0x0080 && reg!=0)  return(NOADRMODE);
*/
			if (bdsize>1)               {operand|=1;square1|=1;}
			if (!(buf&0x0080))          {operand|=2;square1|=2;}
			if (buf&0x0080 && mode==10) {operand|=2;square1|=2;}
			if (is==0 || buf&0xF000) {
				operand|=4;
				if (iis<4) square1|=4;
			}
			if (odsize>1) operand|=8;
			if (iis!=0)   square2=square1;
			else          square1=0;
			operand&=~square1;
			if (!square1) operand|=6;

			adrcat("(");
			if (square1) adrcat("[");
			if ((square1|operand)&1) { /* base displacement */
				if (bdsize==2) {
					if (mode==10 && !(buf&0x0080)) {
						adr = ((prgcount-1)*2+prgstart+(WORD)buffer[prgcount]);
						fprintf(targetfile,"adr=%08x\n",adr);
						if (adr>=(LONG)(moduloffs[modulcnt]+modultab[modulcnt]) || adr<(LONG)(moduloffs[modulcnt]-8) || (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR)))
							return(NOADRMODE);
						if (P2WriteReloc()) return((UWORD)-1);
						GetLabel(adr,mode);
					}
					else {
						if (P2WriteReloc()) return((UWORD)-1);
						adrcat(itoa((WORD)buffer[prgcount-1]));
					}
				}
				if (bdsize==3) {
					if (RelocAdr[nextreloc]==(prgcount*2+prgstart)) {
						GetLabel(RelocVal[nextreloc],9999);
						nextreloc++;
						dtacat(itohex(buffer[prgcount++],4));
						dtacat(itohex(buffer[prgcount++],4));
					}
					else {
						dtacat(itohex(buffer[prgcount++],4));
						if (mode==10 && !(buf&0x0080)) {
							adr = ((prgcount-2)*2+prgstart+(buffer[prgcount-1]<<16)+buffer[prgcount]);
							if (adr>=(LONG)(moduloffs[modulcnt]+modultab[modulcnt]) || adr<(LONG)(moduloffs[modulcnt]-8) || (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR)))
								return(NOADRMODE);
							if (P2WriteReloc()) return((UWORD)-1);
							GetLabel(adr,mode);
							adrcat(".L");
						}
						else {
							if (P2WriteReloc()) return((UWORD)-1);
							adrcat("$");
							adrcat(itohex(buffer[prgcount-2],4));
							adrcat(itohex(buffer[prgcount-1],4));
						}
					}
				}
				square1&=~1;
				operand&=~1;
				if (square2 && !square1) {adrcat("]");square2=0;}
				if (square1 || operand)  adrcat(",");
			}
			/* base register or (Z)PC */
			if ((square1|operand)&2) {
				if (buf&0x0080) adrcat("Z");
				if (mode == 6) {
					adrcat("A");
					adrcat(itohex(reg,1));
				}
				else {
					adrcat("PC");
				}
				square1&=~2;
				operand&=~2;
				if (square2 && !square1) {adrcat("]");square2=0;}
				if (square1 || operand)  adrcat(",");
			}
			/* index register */
			if ((square1|operand)&4) {
				if (is) adrcat("Z");
				if (buf&0x8000) adrcat("A");
				else adrcat("D");
				adrcat(itohex((buf>>12)&7,1));
				if (buf&0x0800) adrcat(".L");
				/* else adrcat(".W"); */
				if (scale) {
					adrcat("*");
					adrcat(itoa(1<<scale));
				}
				square1&=~4;
				operand&=~4;
				if (square2 && !square1) {adrcat("]");square2=0;}
				if (square1 || operand)  adrcat(",");
			}
			/* outer displacement */
			if (operand&8) {
				if (odsize==2) {
					if (P2WriteReloc()) return((UWORD)-1);
					adrcat(itoa((WORD)buffer[prgcount-1]));
				}
				if (odsize==3) {
					if (RelocAdr[nextreloc]==(prgcount*2+prgstart)) {
						GetLabel(RelocVal[nextreloc],9999);
						nextreloc++;
						dtacat(itohex(buffer[prgcount++],4));
						dtacat(itohex(buffer[prgcount++],4));
					}
					else {
						dtacat(itohex(buffer[prgcount++],4));
						if (P2WriteReloc()) return((UWORD)-1);
						adr=(buffer[prgcount-2]<<16)+buffer[prgcount-1];
						adrcat(itoa(adr));
						adrcat(".L");
/*
						adrcat("$");
						adrcat(itohex(buffer[prgcount-2],4));
						adrcat(itohex(buffer[prgcount-1],4));
*/
					}
				}
			}
		}
		else { /* MC68020 (& up) BRIEF FORMAT */
			if (mode==10) {
				adr = ((prgcount-1)*2+prgstart+(BYTE)buf);
				if (adr>=(LONG)(moduloffs[modulcnt]+modultab[modulcnt]) || adr<(LONG)(moduloffs[modulcnt]-8) || (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR)))
					return(NOADRMODE);
			}
			if (pflags&OLDSTYLE) {
				if (mode==10) GetLabel(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
				adrcat("(");
			}
			else {
				adrcat("(");
				if (mode==10) GetLabel(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
				adrcat(",");
			}
			if (mode==6) {
				adrcat("A");
				adrcat(itohex(reg,1));
			}
			else adrcat("PC");
			if (buf&0x8000) adrcat(",A");
			else adrcat(",D");
			adrcat(itohex((buf>>12)&7,1));
			if (buf&0x0800) adrcat(".L");
			/* else adrcat(".W"); */
			if (scale) {
				adrcat("*");
				adrcat(itoa(1<<scale));
			}
		}
	}
	adrcat(")");
	return(mode);
}

int DoAdress2(UWORD adrs)
/* This is for PASS 2 */
{
UWORD i;
UWORD mode=adrmode;
UWORD dummy1;
UWORD buf=buffer[prgcount];
UWORD reg,creg;
LONG  adr;

	if (mode!=NOADRMODE) {
		/* if (mode>0x30) mode=0x07+(mode&0x07); */

		if (adrs&0x2000) reg=reg1;
		else reg=reg2;

		if (adrs&0x8000) mode=adrs&0x00FF;
		else
			if ((adrs&0x0fff)==adrs)
				if (!(adrs&(0x0800>>mode))) mode=NOADRMODE;
	}

	/* Adressierungsart bearbeiten */
	switch (mode) {
		case  0: /* Datenregister direkt */
					adrcat("D");
					adrcat(itohex(reg,1));
					break;
		case  1: /* Adressregister direkt */
					/* Auf Adressregister kann nicht byteweise zugegriffen werden    */
					/* Bei LEA ist extens == 0 (weil ungerade Adressen erlaubt sind) */
					if (extens || opcnumber==OPC_LEA) {
						adrcat("A");
						adrcat(itohex(reg,1));
					}
					else mode=NOADRMODE;
					break;
		case  2: /* Adressregister indirekt */
					adrcat("(A");
					adrcat(itohex(reg,1));
					adrcat(")");
					break;
		case  3: /* (An)+  address register indirect with postincrement */
					adrcat("(A");
					adrcat(itohex(reg,1));
					adrcat(")+");
					break;
		case  4: /* Adressregister indirekt mit Predekrement */
					adrcat("-(A");
					adrcat(itohex(reg,1));
					adrcat(")");
					break;
		case  5: /* (d16,An) Adressregister indirekt mit 16Bit-Offset */
					/* Achtung: Ungerade Offsets werden vom A68K nicht angenommen */
/*
					if (extens && buf&1) mode=NOADRMODE;
					else {
*/
						if (P2WriteReloc()) return(-1);
						dummy1=0;
						if (pflags&BASEREG2 && reg==basereg) {
							adr = prgstart+baseadr+(WORD)buf;
							if (adr>(LONG)(moduloffs[basesec]+modultab[basesec]-2) || adr<(LONG)moduloffs[basesec])
								dummy1=0;
							else dummy1=1;
						}
						if (dummy1) GetLabel(adr,mode);
						else {
							if (pflags&OLDSTYLE) {
								adrcat(itoa((WORD)buf));
								adrcat("(A");
							}
							else {
								adrcat("(");
								adrcat(itoa((WORD)buf));
								adrcat(",A");
							}
							adrcat(itohex(reg,1));
							adrcat(")");
/*						} */
					}
					break;
		case  6: /* (bd,An,Xn.SIZE*SCALE) & ([bd,An,Xn.SIZE*SCALE],od) & ... */
		case 10: /* (bd,PC,Xn.SIZE*SCALE) & ([bd,PC,Xn.SIZE*SCALE],od) & ... */
					if ((mode=NewAdrModes2(mode,reg))==-1) return(-1);
					break;
		case  7: /* Absolute Adresse 16Bit */
					adr = (WORD)buf;
					if (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR || opcnumber==OPC_BITSHIFT1))
						mode=NOADRMODE;
					else {
						if (P2WriteReloc()) return(-1);
						/* adrcat("("); */
						/* PEA  wegen den C-Proggies (Stackuebergabe) */
						if (opcnumber == OPC_PEA)	adrcat(itoa(adr));
						else	{
							if (sourcetype == 1 && prgstart && (adr >= prgstart && adr <= prgende))
								GetLabel(adr,mode);
							else
								GetXref(adr);
						}
						/* adrcat(").W"); */
						adrcat(".W");
					}
					break;
		case  8: /* Absolute Adresse 32Bit */
					adr = ((buf<<16) + buffer[prgcount+1]);
					if (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR || opcnumber==OPC_BITSHIFT1))
						mode=NOADRMODE;
					else {
						if (RelocAdr[nextreloc]==(prgcount*2+prgstart)) {
							if ((pflags&BASEREG2) &&
							    (RelocMod[nextreloc]==basesec))
								GearFlag == 1
							GetLabel(RelocVal[nextreloc],9999);
						nnextreloc++;
						}
						else {
							i}
				}
			}
			if (text == 0) {
										Of (numb$r) strcat( ADR=%08x not found!\n",ad	zero++;
								if (zero > 4) {tePEA)	adrcat(itoa(adr));
						else	{
							if (sourcetype == 1 && prrgstart && (adr >= prgstart && adr  <= prgende))

								GetLabel(adr					else {
				ocVal[nextreloc],9999);
						nextreloc++;
						dtacat(itohex(buffer[prgcount++],4));
						dtrcat(").W"); */9					d) - R --> B					break;
		caDE;
					else {
			&& reg==ba],4)
				adr = ((prgcount-1)*2+prgstart+(BYTE)buf);
				if (adr>=(LONG)(moduloffs[modulcnt]+modultab[modulcnt]) || adr<(LONG)(moduloffs[modulcnt]-8) || (adr&1 && (exten er==OPC_JSR || opcnumber==OPC_BITSHIFT1))
						mode=NOADRMODE;
					elsdummy1) GetLabel(adr,mode);
				if (P2WriteReloc()) return((UWORD|| (1);
							GetLabel(adr,mode);
				adrcat("(A");
					if (P2WriteReloc()) return((UWORD,| (1);
							4));
						dtrcat(").W"); *11					IMMEDIopcn.SIZE*SCALE)F;
	==;
				else
					adrmode=NOAD;
				}
			}

			if (RelocAdr[;
				}
0ile (ptr != 0xFFFFF0;
			}
	er==OPC_JSR || opcnum					if (zero > 4)SHIFT1))
						mode=NOADRMODE;
					elsturn((UWORD#$r) strc");
						adrcat(itohexB");
		d	zero++;
						}f (RelocAdr[;
				}
1ile ro > 4)SHIFT1))
						mode=NOADRMODE;
					elstun((UWORD#$r) strc");
					adrcat(itohexB4);
;
						}f (RelocAdr[;
				}
2ile roode);
								case  8: /* Absolute Adresse 32Bitn.SIZEC_BITSHIFT1))
						mode=NOADRMODE;
					else {
			+2& prrgstart er==OPC_JSR || opcnum					if (zeroC_BITSHIFT1))
						mode=NOADRMODE;
					else {
						if (Relochtung: Uzro ,D");
			adrcat(				adrbuf[0]=0;;
		case  8: /* A retODE;
								elelse {
						if (Relochtung: Uzro ,D");
			{
					adrlR || opcnumber==OPC_B
				iftCbuf[0]!c6(tp er==OPC_JSR || opcnum					if (zeroC_BITSHIs*2+prgstart+(WORmboloc],9999);
						nextre		if (adr>=(LONG)(moduloffs[fer/Pung: UzrCCR,D")adrmode=NOAD;
				}
	ung: UzrSR,D")adrmode=NOAD;
				2				adrcat("(A");mberd=i		bdir[k]t("Dr,mode);
						else {
							i12:Pung: UzrCCR,D")adrmolse {
							i13:Pung: UzrSR,D")adrmolse {
							i14:Pung: UzrUSP,D")adrmolse {
							i1)+  adMODEMDE;
					elsdlse {
*0x38)		/* a text 	adrcat(")");!=3)
					mnecat(extM1
					adrmode=NOADRMODEM3uffer(Ct(bitshif18locAdr[;
	sh(stderlse {}
			}

			if (Relse {}Adress2(U(UWORD#$r) strcinemonics\n")D,D");
			adrc adrcat(itoa(A"); *11					IMMEDIopcn.SIZEiperand&=~2;
	lbuf = GetPMem(002;
0			if (ipe)<9_BI=8'eFAreas;i++)
	S_rg("%sERRr) strcinemonics\n")D,D");
			ad					mn0]S(labfile = fopen(labname,"r")))
			ExitPrg("Can't open %s\n",labname);

		labelbuf = GetPMem(labc1*sizeof(ULONG));
		fread(label
		fread(lab				while(LabelAdr2[p2labind]==moduloffs[modulcnt] && p2labind<labcount) {
					if (GetSymbol(LabelAdr[p2labind])) {
						fprintf(targetfile,"%s:\n",adrbuf);
						adrbuf[0]=0;
					}
					else flag = 0;
		
					}
							adrbuf[ae flag = zuf[0]=0;
					}
zuf[0]=0;
(K[modulcnn] && p2labind<labcount) {
					if (GetSymbol(Label8 {
			if (mode==10) {
	eUV(				lse =NOADRMODEectionToArea(vArea(vArea  wegen c				adrb)s[prgcounFFFFF;
	abcount) {
					if (GetSymbol(Label8 {
RunFFFFF;
	abcou						loc],99IFFF;
	abcor{
RunFF) {

		caDE;
NOFT1!)OPC_BITSHIFT1))
						mode=NOA16MODE;
DFQ,SUBQe);e destadr[opcnumber]=0x0bf8;
			((buf>8mode;
UWORD dummy1;
UWORD buf=buffer[prgcount];
U17RD reBKPTe);e destadr[opcnumbmode;
UWORD dummy1;
UWORD buf=buffer[prgcount];
U18RD reDBcc) {
										Of (numb$r) strcat( ADR=%08x not found!\n",ad	zro++;
								if (zero > 4) {tePEA)	adrcat(it				adrcat(")");RD d adrcat("Z");e)");dd		adrcatBADR=%08x not found!\n",ad	zro+an't (numb$r) strcatCA);
(bufPF;
	abcou						loc],99IFFF;
	(					loc],HncannTSH,*s									if (pflagsunt-1],4));
*/
				;
	a & ROTATE Data Ret ext0 CodeAreaMax) {
				CodeArea1 = GetNeesNlt+p					if (pflagsuntD	if (pflagsupflagsuntCodeArea1 = GetNeesNlt+p					enrgcx;
UWORD dummy
DFQ,Sad(lrcat("PC")7.10: /* (bdif (pf;
						if (pflagsx=rgcount];
;my1) GetLabel(adr,mode);
				if (P2WriteReloc()) abel(adr,mode);
				if (P2WriteReloc()n(adrbuf)/s |uf<<16) + buffer[prgcounrmode=NOAD;
				}
			}de=NOADRMODE;
					else {
						if ber==O1 = GetNeesNlt+p					if00pflagsuntD	if 		euntCodeArea1 = GetNeergcount];
KPTe);ePTe	adrcat(")");!=3)
					mnecat(extM1
					adrmode=NOADRn");
	fprintf84w(lablffs[fert(") adrcat(",D");
			aprgst	else {
			es=0;
				whicd(l\n");


gif (!(tai82tfileLINK , (ad(": ");
				dtacei LEA ist extens == 0 (weil ungunt];
;my1) GetLabel(adr,mode);
				if (P2WriteRer==OPC_JSR || opcnum			onextOPC_JSR |		strm			onextOPC_JSRHL CQe	mode=NOA16Mm			onextOPC_JSR |		strm			onextOPC_JSR0f("          %s = nex"(lablffs[fertR,+modulOP ONLffset))
		/* HERE d nd lr]=0x80)
	Symbol(Label8r]=0x8);
			dtacat(": ");
			if (Rf("     fset)locAdr[nextreloc] == (prgcount*2 + 
      memtson((age B
						dummy1=0;etOpcode();
	uf[ae flag = zufDde=adrmode;
UWORD dummy1;
UWORD buf=buffer[prgcouneRer==OPC_JSR || opcnum			onextOPC_JSR |		strm			onextOPC_JSRHL C(flags[opcnum38
	uft(itohex(buffer[prgF8unt++],4));
				));
					}
				}
				if (bdsize==3ffer[prgE0unt++],4));
				));
					JSRHL CQe	mode=NOA1onextOPC_JSR |		str opcnum0Rf(" Se_g = zufDde=adrmode;Pdrbuf);
r)(buf&0x00FFcat(ito3lx00FFcat(itxtmeOPC (adr   %s = nex"(lablffs[4ertR,STOPadr SR |		strm			onextOPC_JSRHL C(flags[opcnumrcat(itohexB");
		d++;
						}f (RelocAdr[;
			= nex"(lablffs[pcnumb /* (An)RD d adrcat("Z");{ (sigw&0x010) mnecat("sigw&0oc()) return(-1);
						/* adrcat("("); */
						/* PEA jL,"flags[opcnum38
	ufd(itoheel(adr,mode);
PEA j 3?						/*dr,modeelse8WF)0x010) mnecat("sigw&02c()) return(-1);
						/* adrcat("("); */
						/* PEA jL,"flags[opcnum38
	ufd(itoheel(adr,mode);
PEA}bel8 {
			if (				else destadr	if (tflag==
			}FEXTU,	}FEXTS,	}FFFO,	}F(ts			else {
				t("L");
				el	/* adrcat("("); */
						/* P,EA jL,						/*dr,modeels (sigw&0x0100) mnum38
	ufd(itoheel(adr,mon.SIZEC_BITSHIFT1))
						mdeelsF			el	/* adrcat("("); */
		onextOPC_JSR0f("     6    %RTM=0;etOpcode();
	uf[aet])
							adrcat("$"));
							adrcat(itohexx0100) mnum38
	2;
		d++;
						}f (Reloc7dr[;
CASe!EA ist exx*4+4);

	if IonextOPC_/+4)    %RTM=0;etOpcode();
	uf[aet])
							adrcat("$"));+code();
	uf[						adrcaDR=%08x nat("$[M=0;etOpcodeOpcodeOpcode
					d++;
						}f (Rec

		E(Rec

		E%s:\n",E%s:\		adR			}
	B
	E%s:\n",E%s:E%s:xtOPC_JSR0f("     6   bUWORD dummy1;
Ucnt]r0r,mon.SIZEC_BITSHIFT1))
						8*A
					d;, bUWORD dummy1;
Ucnt,r0r,mon.SIZEC_BITSHIFT1))
						8*A
					itoheel(ad1locAdrUWORD dummy1;
Ucnt]r0r,mon.SIZEC_BITSHIFT1))
						8*A
						d;,l(ad1locAdrUWORD dummy1;
Ucnt,IFT	else destadr	if (tflag==drcat(")+");
					br("     6    %(HIFT1))
						8*A
					t("L");
				el	/* UWORD dummy1;
Ucnt):(IFT1))
					adrcat(itohex(buffer[p   6    %(HIFT1))
						8*A
					t("L");
				el	/drcat(i			el	/* UWORD dummy1;
Ucnt = 0;
		
					}
							adrbuf[a28					adrt(itohe38
tOPC_/+4)    %RTM=0;etOpcode();
	uf[aet])
							+code();
	uf[						adrcaDR=%08x nat("$[M=0;etOpcodeOpcodeOpcode
		("L");
	f		E(Rec

		E%s:\n",E%s:\		adR			}
	B
	E%s:\n",E%s:E%s:xtOPC_JSR0f("     6   bUWORD dummy1;
Ucnt,r0r,mon.SIZEC_BITSHIFT1))
						8*A
					itoheel(ad1locAdrUWORD dum				}
							adrbuf[a29					DIVIDE/MULTIPR0frn(NOASIGNED/UNSIGNED38
tlse destadr	if (tfdes(Rec

		E%s:\n",E%s:\		adR			}
mnecat("R");
			} else if (opcnS 6    %(HIFT1))if (opcnUIFT1))
					ad!R");
			} 4							mber==OPC_B
			DIVLt++];
			dtacat(ito"$"))g++];
			dtacat(ito"$")1gcount*		DIVLt++];
			d07);
								adrca					adrlR || opYTEnextreloc],9999);
						nif (o0x0800) adrcat(".Lnif (o0x1GetSiRD 		dtacat(ito"$
							if ((pflag:Dr[prgcount-1]));
				9999);
						nif 
				CodeArea1 = GetNeesNIFT1))
						8*A
				30st	else {
 dumuf[a29			ADR=%08x not found!\n",ad	zro+an't (numb$r) scatCA);
(buf");


gif (!(tai82tfileLINK , (ad(": ");
				dtacei LEA ist extens == 0 (weidummy1=0;etOpcode();
	uf[ae flag = zufDde=adrmode;
UWORD ]));
				999A);
(bufEC_BITSHIFT1))
						8*A
					s&SHOW_;
				 POt])
CREMENT	mode=(aet])
								adrcat("*"));
				e
			!=r,mode);
PEA}bel8 {
			if (				8*A
 rL2Gast ADRMODE;
			}

			if (sourceadr[opcnumber]) {
				if (DoAdress2(sourceadr[opcnumber])) continue;
				if (opcnumber!=OPC_BITFIELD)
					if (destadr[opcnumber]) adrcat(",");
			}
			if (despCINV )))
	SHlsF			el	/* adrcat("("2se if (opcn
	SHer == OPC_BITSHIFT2) {INVer == OPC);
			dtacat(": ");
	if (extra&0==6) {
	c6(tp er==OPC(!reg1) reg1}
			i0:
de);
				if (P2WriteReloc()) r,");
			UP) sourceadptr[k++]='\n';

f[aeloc()) r,");
			UP) source2dptr[k++]='\n';

P[aeloc()) r,");
			UP) source3dptr		el	/* adrcat7					nif (o0x0800) adrcat(".Ln{ntD	if (pflagsupfelAdr2[p2labi);
			dtacat(": ");
					untCodeArea1 = Getx  opc=%lu  adrflaestadr[ostackchtern ULONG
     ]
							adrcat("$"));
33drcat("*"Crbuf);
r)(buf&0x00FFcat(ito3lx00FFcat(itxtmeOP30;
==OPC_BITFIELD)
	dr[opcnu;
		OPC_umber==OPC_B)(bufu;
	if (sis(Rec

		E%s:\n",E%s:\		adR			}
mnecat("tern U1eg1) rercat(".L");
						}
						else {
				R0f("     6    %RTM=0;etOptNeesNIFT1))
						8*A
				my1;
Ucnt,r0r,mon.SIadrPC_B)(bufu;
	if (else 
						=8reloc],9o"     6   FwNx38) adrmode=(adrmode>>a'w8mmy1=0;etOpcode();
	uf[ae flLONG
     ]
						rnt*2at("ter)arget(tptr,k);

			");U1eg1) rercat(".L");
						}
						else {
				R0f("     6    %RTM=0;etOptNeesNIFT1))
						8*Ar));
						else	{
					cat("$"4);
33drcaS("*"C>9)&0x0003]);
				if (sis(Rec

		E%s:\n",E%s:\		adR			}
ito"$"))g++];
			dtacat(ito"$"lse destadr	if (tflag==drct(")+");
					br("     6   rct(")+");
					br("     6   rct(")+");
				E"  i=k;
			}
;
			}

			if (sourcead(Rec

		E%s:\n",Ebuffer[prgc		E%s:\n"et(t=;
				else
strcat(tsname,itoa(modulcnt));
		\n",adrbuf);
				adrg=0;
			p2labind++;
		}
		if (flag == 0)
			fprintf(targetfile,"LAB_%04lX:\n",index);
	}
}
void Ausgabe( 		oid)
{
WORD i;
	/* Hier findet die Auns.\n",bufferid *,Uormat				k	}

}
v(targetfile);
		targ03dr,mode);
PE}/C) {operanduns.\n",bufferi 
4ec


4e,0St && > [D *)bu]adrcoperanduns.\n",bufferiSt &&  n\tSECTnit();
	InitOpcodet;
				pcneAreapathsgabe(vort && .rcoperanduns.\n",bufferiD *)bu n\tSECTnit();
	InitOpcodet;
				pcneAreapathsgabe(vo=4)   .rcoperanduns.\n",bufferiOec


4:rcoperanduns.\n",bufferi\t-buf[x0\t\tx
			,1,2,3,"*";
				pcn	while(isspaceperanduns.\n",bufferi\t-B
		RY\t\tT {

    SymbolCG),
b
strupaceperanduns.\n",bufferi\t-a\t\tAflan[3],
    a(num							c	if (p {
	paceperanduns.\n",bufferi\t-file\t\tPns.\	cafintf((area+1)<CodeAreas) 
			end = CodeArea1[area+1];
		else
			end = prgende;

		while (ptr1 <
			oe prgstar]Nx38) a(,Xn.22			itoheel(adB;reas) 
			end = r]Nx3mbolCE if (opcn
	SHer=OPC_UNPK1e( VAr));
				n
	SHer=OPc/EREG2 a(num							1 <
			oIYufferi\t-aG2 a(num							1 <
			oIYioperanduDlocAdr[;
	o"$
										1 <
									1 <
 m			dultaE;
	}
uldn			if (RrBufRMOognrn(d
	o"$
										1 <
									1 <h								0,:Pung: Uz1 <
						30st	else {Tg: Uz1 <
			if (else 
			   *c;
		else			30st	else {Tg: Uz1 <
				t 
				Co			   t])
							adrcat("$"));
			pcnw(nadpt	oiO			/* Peslf((area+1)<CodeAreas) 
	uld == 0)
			(\tPns.\	cumm0,:Pung: Uz1 1e( VAr)3Nts("END\n",count*2<
		Loads ptr1+1);
	: Uz1 1e( VAr)3Nts("END\n",cptr2)
	f (n  sr]&0x40) && exG",7)) {
 Useful: Uz1 1e( VAr)3Nts("END\n",ce if(f (opcn
	SH\tW1*si[k]>12ptr	CodeArea2of && e: Uz1 1e( VAr)3Nts("END\n",c
			if [oIYu,);
}u,)G",>] Uz1 1e( VAr)3Nts("END\n",",",rintf);
		elsLONG)wei(AMOD Uz1 1e( VAr)3Nts("END\n",",",peran- %RN      ReadObjUTYPE|=M68881;
			if1 1e( VAr)3Nts("END\n",",",aADR %0:prinbjUTYPE|=		if1 1e( VAr)3Nts("END\n",",",G",R %0:pS		(\tPnac		lmovmby)wei(AMOD U	if1 1at(itohex( [D *)bu]a *binfile,
[i] >= CNFAreaMax=16zw Aug("Hunasesec*o]&0x,hsgabe,*]&0x;har *, 000;
ile=) GetLabe ilesgabe()END}
void W
rinw				(&l			(ptr2-ptr!sertULONinf09],memWork);
0)
wird noch*/
				
PEersitetzti]) && (adonmodul(ag;

u)ULONinf0rcat(itohex(*((UWORDj<=k;j++1 {
						if (isprin && (adsertC< 2)drcoperandunsin &ead(labo]&0x=ilehsgdsert,tr1,,"",&00;
ile,&hsgabe	8*Ar))[aeloc()hsgabe
	for(i=xtrel'e':or(i=xtrel'E':or(u\n",basesec);
	o]&0x," if(f!strnicmp(bu\n",	o]&0x[51 > prgende)
			o]&0x[6]r[7]);
			CPUTYPE=0;
			iL");
			tcd
			o]&0x[5]r[7]);
			CPUTYPE=0;
3);
					elstfilCPUTYPE=0C< 0Lptr1)) {
							ifce if(: e if(relocano(ULONneg
		e!text) {

			END}
voi1;n",labname);

		labelbuf = Ge	END}
voi1;nt(ito"$"lse destadr 's':or(i=xtrel'S':or(u\n",ba*((rc);
	o]&0x,"Areas) 
	fprinbasereg=ateAreas) 
(end <  = Ge	END}
voi1;nt(ito"$"lse destadr 'f':or(i=xtrel'F':or(u\n",ba*((rc);
	o]&0x,"OodeEEP
	fprinbasereg=atFOodeEEP
(end <  = Ge	END}
voi1;nt(ito"$"lse destadr 'p':or(i=xtrel'P':or(u\n",ba*((rc);
	o]&0x,"tr2)
		fprinbasereg=atptr2)
	(end <  = Ge	END}
voi1;nt(ito"$"lse destadr 't':or(i=xtrel'T':or(u\n",ba*((rc);
	o]&0x,"			o1	fprin] = LabelA=1(end <  = Ge	END}
voi1;nt(ito"$"lse destadr 'm':or(i=xtrel'M':or(u\n",bases);
	o]&0x,"	30st"prinrtCodeAdr(area1)end <  = Ge	n",bases);
	o]&0x,"	301t"prinrtCodeAdr(are11)end <  = Ge	n",bases);
	o]&0x,"	302t"prinrtCodeAdr(are21)end <  = Ge	n",bases);
	o]&0x,"	303t"prinrtCodeAdr(are31)end <  = Ge	n",bases);
	o]&0x,"	304t"prinrtCodeAdr(are41)end <  = Ge	n",bases);
	o]&0x,"	306t"prinrtCodeAdr(are61)end <  = Ge	n",bases);
	o]&0x,"	3881"prin (buffer[i]=='$'end <  = Ge	n",bases);
	o]&0x,"	3851"prin (buffer[i]==51(end <  = Ge	END}
voi1;nt(ito"$"lse destadr 'a':or(i=xtrel'A':or(u\basereg=at,((adr-prg;nt(ito"$"lse destadr 'O':or(i=xtrel'o':or(u\n",basesc);
	o]&0x,"		if (e"prinilesgabe1(end <  or(u\n",basesec);
	o]&0x,"lCE iftinrnicmp(bu\n",	o]&0x[61 > prgende)
			o]&0x[7]r[7]);
			nsertCodeAdr(i*2);
			tcd
			o]&0x[6]r[7]);
			nsertCod;
3);
					elstfilnsertCodC< 0Lptr1)) {
							ifcolCE i: olCE irelocano(ULONneg
		e!text) {

			END}
voi1;n",labname);}nt(ito"$"lse destadr 'I':or(i=xtrel'i':or(u\n",ba*((rec);
	o]&0x," FOr[7]: unknown proSHOW_RELOCle (;nt(ito"$"lse destadr 'C':or(i=xtrel'c':or(u\n",ba*((rec);
	o]&0x,"unt*2!strnptr1)) {
nknown proount*2;ame);

		labelbuf = Ge	END}
voi1;nt(ito"$"lse destadr 'k':or(i=xtrel'K':or(u\n",ba*((rc);
	o]&0x,"			1 	fpriinbasereg=atsgabe();
			if(end <  or(u\n",ba*((rc);
	o]&0x,"			1 <	fprinbasereg=atsgabe {
	pa(end <  = Ge	END}
voi1;nt(ito"$"lse destadr 'n':or(i=xtrel'N':or(u\n",ba*((rc);
	o]&0x,"	Wif (e"pprinilesgabe2(end <  = Ge	END}
voi1;nt(ito"$"lse destadr 'b':or(i=xtrel'B':or(u\n",ba*((rc);
	o]&0x,"{
	pa	fpriin
					}
		e1(end <  or(u\n",ba*((rc);
	o]&0x,"			if 	fprinbasereg=at
			if 1(end <  or(u\n",ba*((rnc);
	o]&0x,"			if =) srnptr1)) {
PE|=M680o]&0x[7]-'0'
				999A);
&0x= (ptr1 o]&0x,Wri) PEA jL,"flags]&0x[11 > prgende)
			]&0x[2]_l(ptr1+1,(long *)&prgsi*2);
			tcd
			]&0x[11_l(ptr1+1,(long *)&prgs			basereg=atoi(ptr1+1);
		999A);
&0x= (ptr1 	]&0x[11,Wri) PEA jL,"f		tcd
			]&0x[11_l(ptr1+1,U\t$%X\n",a)g++];
			dtacat(it);
	unknown processor.\n",b	=68851) CPUTYPE|=) END}
voi1;n",lab
		labelbuf = Ge	END}
voi1;nt(ito"$"lse ded),
   := Ge	END}
voi1;nt(ito"$"lse dj+1],CodeArEND}
vo",E%srcoperandunsin eloc] == (prgcount*2 + prgstartnknown|=			if (e
       rglcnt])) {
known|= 			if (e
       rglcnt])2 {
knownste			if (e
 
********* rgC< sertU
t(tptr,k)BASEREG op,tr1,[**** rg");

char *nt]-prgstartNons.\n", sr=OPC_Ud!text
 
********* rgC< sertU
t(tptr,k)PUTYPE&M680tr1,[**** rg;

char **Ar))[trsfn)BASEREG op,0,0,PUTYPE&M6800+1],CNFAreas,moduloffs[m.asmxt
 	}
			}
	asesc);
	BASEREer==OPC_PACK1 ||)
	,CNFAreas,moduloffs[m1(tflag==1[trsfn)BASEREG op,0,0,codeentry);0tflCNFAreas-i-1);
				l.cnf(tf==1[trsfn)BASEREG op,0,0,Puntry);0tflCNFAreasPuntry);".Pun(tf&ead(labasesc);
	BASEREer==OPuntry)))
	CNFAreasPuntry);"1(tf==1[trr,krgc;
	ARGVL_"tflCNFAreasgc;
	ARG	}

}
GetPMem(n  Taskf0r	/*9],memN	ARnE))
		Zwisero,uf[0]!=0tr2-ptr!
					}
		) 
					}
				      Writ9],,memFil	}
	 1*sausr) >=ns ||.W");
					}
					br)n char cpunf==1,labelbu  d */
	SectionToArea();tflCs:\		lbu  d */
	Sectio char a();tflCs:\		lbue occu1],memMarke, falILEke	mnes:\	kstar]aubt -i-1g=ns ||.ORD CPUT  d */
	Sectio char a();tflCs:\		mod  d */
	Sectio char a();tflCs:\		r !  d */
	Sectio char a();tflCflags |= BASEREG2ectioodulcount; 
		re(ptr1 < etflEC",7)) {
			basesectioodulcount{
		/* SearchCode() {
					iASEREG2ectio) {
				unt{
		/* SearchCode() {
				2iASEREG2ectio) {
				unt{
		/* SearchCode++;
	}
	eliASEREG2ectio)NF				unt{
		/* SearchCode++;
	}
	2liASEREG2ectio)NF				unt{
		/* SearchCode("CODEADR %08X\n",ectioodeArea(pt{
		/* SearchCode|.W");
					}
					b
				
					}
					b3)%lX\n",base
					
					adrcat(
					
	ARGV = argv;

	Init();
	InitOpcode();
	
					
	ARc,char **arPun
					adrcat(Puntry);"w= argv;

	Init();
	InitOpcode();
OPuntry))cnt));
		\
					}
					br)n,
    _abor);|.W");
					}
					b
)Base *IntuitionB);|.W");
					}
					b3)n int
    Ge);|	else prgstart=atoi(&bufferca	 prgstar!		if (;

	Init();Tnicmp(buffer,"BASEREG",7)) { (			 machiU\t$%X\n",|.W");
					ress2(s_per_;
					ress2;|	elsrPun
					/* s_per_rPun
				;|	Pun
					a
					
					ad W
rind=%l =id
       maPuntry))cn
ar **arPun
					adrcat(Puntry);"r= arg;

	Init();
	InitOpcode();
OPuntry))cntr **argv)
{
	ARGC = argc;
	ARGVw= arg;

	Init();
	InitOpcode();
	SearchRomTagestadr[] %08X\n",ectiotoi(&buffe{
		/* SearchCode( {
						%08X\n",ectioct x_adr{
		/* SearchCode(y(&tptrR %08X\n",ectioind=%l

/*	pgcount*; */
	rchr(&b1,r,*ReloPun
				)	if (ptRelrg;

	Init();
	Init */
ea1[i]&0x!text
 
*/
					tf84w(lablffprintding d	8x)\n",prgcount*2,pgfile,"MACHt
 
*/
					tf84w(lablffprintding d			targ=s						izw Auabcx" (zero > 4)d	8x)\CPUTYPE=02 > prgende) lags&PREPROC) {
EPE=0(=hine=)WOR value;
UWORD!(file=fopen(conf	8x)\CPUTYPE=02< (ptr1 < CoCPUTYPE=0NG  modtypeas-i);
			OpcodeO:de();
	
					
	ARc,chk+1])) altr1 ir:printf("\tDC.B\t");
	8x)\n",prgcsgabe {
	pa];
				if (p {
	pa :de();
OPuntry))cntr **n",prgcount*2,;
				if (pount*2 :de();(configfile,"BASprint(buf[5gs&BASEREG2)== (prgco11	iarg;
				if (p fopen(:de();(copuile		if (tf			if (polCE ir:);
		strcat(configname *)bu]aargetfile,
    END] =   *lab[i]va_l			 ileueg,1(c)1993-9 = Coonmodulf09],memBodul-Trap ausk
		k=ns ||CodeArENDin with 		va_onfig(ileueg,1(,ENDin wi; 		v			if (END] =  ileueg,1(1 1e( VAr)3Nts("END\ (text) {
va_end(ileueg,1(1 1e},|.W");
					ress2(s_per_;
					ress2;|	elsrPun
					/* s_per_rPun
				;|			if (DoAdress2(s_per_line=0;
								}
				
					/* s_per_r			
			onf	8x)\CPereg=atoi )
				basereg=atoi(				}
				ile	en);
		ff	}
rgv)
{
	ARGC = argc;
	ARGV = aX\n",ad_per_r			
			onf	
		CNFAreaToCodeArea(ULONG l=0,!\n",prgcsgabe {
	pa]rca=-1;
LONGn);
		ff	}
rPun
					adrcat(Puntry);"r= aX\n",ad_per_rPun
			onf	
		CNFArePuntry))cntdj+1],CodeArULONG  *SodeArea1 = GetNewVarBuffer(CodeArea1,CodeAreaM  *S	if lose(labfAreaM  *S	if,;

	/* remove al}
		ose(labfAreaM  *S,toi(&buffe{
		/* Search< etf+1],CodeArU> (pr			/* ose(labrU> (pr	  ,toi(&buffe{
		/* Senex"();
[i+1],&CodeAd)/* ose(lab],&CodeAd ,toi(&buffe{
		/* SearchCode(CodeAreaMax);)* ose(lab]AreaMax);,toi(&buffe{
		/* SearchCode(CodeAreaM(opc)* ose(labeAreaM(opc,toi(&buffe{
		/* SearchCode(Codeount = ()* lose(labfile);labfile=0; 
		remove(labn
start || ar)* * lose(labfrchr(&bind=%l

/*					dtrcat("))* lose(labftrcat("), char a(; 
		remove(labn
starts:\		r !)* lose(labts:\		r !, char a(; 
		remove(labn
startORD CPUT)* lose(labtORD CPUT, char a(; 
		remve(labn
startORD C {
)* lose(labtORD C {
, char a(; 
		remove(labn
startestadr[])* lose(labtestadr[],toi(&buffe{
		/* SearchCode(Code,labelbu)* lose(labtestadAt) {
		iMa(; 
		remove(labn
starprintf("PH) lose(labtestadAt)2,onToArea(0) ; 
		remove(labn
starp {
						) lose(labp {
						,ct x_adr{
		/* SearchCode(tartORD CB|| ar)ose(labtORD CB|| ar,ORD CN     {
		/* SearchCode(tartDORD CB|| ar)ose(labtDORD CB|| ar,ORD CN     {
		/* Senex"();
[i+1]) {
					) lose(labea1[j]) break;
					lm{
		/* SearchCode(tart) {
				2) lose(labea1[j]) b2eak;
					lm{
		/* SearchCode(tart+;
	}
	e)* lose(labte(adr1 > CNFArea2[i{
		/* SearchCode(tart+;
	}
	2)* lose(labte(adr1 2 CNFArea2[i{
		/* SearchCode(taroodeArea		/* ose(labr (!(pflags&PREPROC{
		/* SearchCod[7]);
			pflags &eAreabuffer);
			if (!(pflags&BASER7]);
			pflNle		if  ose(labrPUTYPE==M68030 derr);
			pflNle		if ine==68EG2)) pflags |=  ose(labfer[7]);
			if (baseCuffe{
		/* SearchCode(7]);
			pflNle	) lose(labeif(!strnicmp(bufferCuffe; 
		re(ptr1 < etflE} &ead(ladeo			.lh_Tailitoh	if (		itoh N {tex)&l			(
		ose(labfRemH*/
	&l			(, 
		re(		itoh N {tCode|.W");Intui7)) rinb) Cper_Librabor(		itoh Libraboex)Intui7)) rinb)de|.ONinf0rca
			 1. k-2]!:eas == Code=NsiblbjUTYPE|=eOADRMi+2],&Co*/		if (CNFAr1tr1;
					else f (ptr1 	if (Cos,%sparictions to b1;file,"\tMACHINE\t%ld\n",dummy2);
	}
	if (C-1;
1 && !CPUTYPE&(M68040|M68060))
		fprintf(targetfile,"\tFPU\n");
	if (dummy2==68020 && CPUTYPE&M68851)
		fprintf(targetfile,de<0x38) adrmodent] != 0) || (pflags&KEEP_ZEROHUNKS)) {
1			if (memtype[modulcnt])
					fprintf(targetfile,"\n\n\tSECTION S_%ld,%s,%s\n\n",modulcnt,mododulcnt]]);
				else
					fprintf(targetflags&SPLI1me[modtype-0x03E9]);
				flcode\n");

/*
	for(nextreloc=0;nextreloc<relocount;nextreloc++)
		if (RelocAdr[nextreloc] >= ptr1)
			break;
*/

	while(GetCodeAdr(&ptr1)) {

		prgcount = (ptr1 - prgstart)/2;

		/* find out in which section we are */
		for(modulcnt=0;modulcnt<modulcount;modulcnt++) {
			if ((ptr1 >= moduloffs[modulcnt]) &&
				 (ptr1 <  (moduloffs[modulcnt]+modultab[modulcnt]))) {
				CodeAreaEnd = (moduloffs[modulcnt]+modultab[modulcnt]-prgstart)/2;
				break;
			}
		}

		/* find the first relocation in this code area */
		for(nextreloc=0;nextreloc<relocount;nextreloc++)
			if (RelocAdr[nextreloc] >= ptr1)
				break;

		EndFlag = 0;
		while(EndFlag == 0) {

			if (RelocAdr[nextreloc] == (prgcount*2 + prgstart)) {
				nextreloc++;
				prgcount += 2;
				continue;
			}
			pc = prgcount;
			sigw=(UWORD)buffer[prgcount++];


			GetOpcode();
			if (flags[opcnumber]&0x20) {
				extra=buffer[prgcount];
				if (P1WriteReloc()) continue;
			}

			if (opcnumber == OPC_CMPI) {
				if (CPUTYPE&M020UP) destadr[opcnumber]=0x0bfe;
				else destadr[opcnumber]=0x0bf8;
			} else if (opcnumber==OPC_TST) {
				if (CPUTYPE&M020UP) sourceadr[opcnumber]=0x0fff;
				else sourceadr[opcnumber]=0x0bf8;
			} else if (opcnumber==OPC_BITFIELD) {
				dummy=(sigw&0x0700)>>8;
				if (dummy==2 || dummy==4 || dummy==6 || dummy==7) sourceadr[opcnumber]=0x0a78;
				else sourceadr[opcnumber]=0x0a7e;
			} else if (opcnumber==OPC_C2) {
				if (extra&0x07ff) adrmode=NOADRMODE;
				else {
					reg1=(extra&0x7000)>>12;
					if (extra&0x8000) destadr[opcnumber]=0xa001;
					else destadr[opcnumber]=0xa000;
				}
			} else if (opcnumber==OPC_MOVE162) {
				switch ((buffer[prgcount]&0x0018)>>3) {
					case 0: /* (An)+,(xxx).L */
						sourceadr[opcnumber]=0x8003;
						destadr[opcnumber]  =0x8008;
						break;
					case 1: /* (xxx).L,(An)+ */
						sourceadr[opcnumber]=0x8008;
						destadr[opcnumber]  =0x8003;
						break;
					case 2: /* (An) ,(xxx).L */
						sourceadr[opcnumber]=0x8002;
						destadr[opcnumber]  =0x8008;
						break;
					case 3: /* (xxx).L, (An) */
						sourceadr[opcnumber]=0x8008;
						destadr[opcnumber]  =0x8002;
						break;
				}
			} else if (opcnumber==OPC_MOVES) {
				if (extra&0x0800) {
					sourceadr[opcnumber]=0x8022;
					destadr[opcnumber]  =0x03f8;
				}
				else {
					sourceadr[opcnumber]=0x03f8;
					destadr[opcnumber]  =0x8022;
				}
			}

			ifnumber!=OPC_BITFIELD)
					if (destadr[opcnumb1r]) adrcat(",");
			}
			if (destadr[opcnumber]) {
				if (opcnumber==OPC_MOVEB || opcnumber==OPC_MOVEW || opcnumber==OPC_MOVEL) {
					adrmod& CPUTYPE&M68851)
		fprintf(targetfile,de<0x38) adrmodenopen %s\n",tsname);
			}
			if ((modulta1			if (memtype[modulcnt])
					fprintf(targetfil
					fprintf(targetfile,"\n\n\tSECTION S_%ld,%s,%s\n\n",modulcnt,modname[modtype-0xuffer)mtype[modulcnt])i<odt(CodeArea1,n %flags&SPLI1midulcnt]+modul\n");

/*
	for(nextreloi;nextreloc++)
		i duloffs[mrelo3== CodeAdrMax4;
						ptr1+=4;
						if (lcode */
					if (buf[k-2]!0ff*)buf),EVISION);r1=CodeAreif oc++)
		iG adr)
{
sr1=CodeArif (D%ld\n",dum 1)
			r1=CodeAr,oc++)
		iG;

	} else if (pflags&CONFIG)

	if (pflags&SPLI1;
					ptr1+=2;
					A) {
;
		eodeAri2) con==(prozg,1aduns.\s ||.W");
		eodeAr++2labin0;next */
					if (buf[k-2]!0fftf(stderr,"labcount=%ld  p2labind=%ld\n",labcount,p2labind)
		eodeAri0f+1],CodeAr(f	}
		(&GetL4,eateConfigeif 1arg;

	Init();]) && 2laRMi!text) {ile=0++			}
			e1se
				flag=0;
			p2labind++;
		}
		if (flag == 0)
			fprintf(targetf		i = 3-strlen(adrbui<=0) adrcat(" ");
			forunt = (ptrtargetfile,"\t%s\t%s;%s\n",mnebuf,adr1uf,dtabuf);
 		}
		else if (adrbuf[0])
			fprintf(targetfile,"\t%s\t%s\n",mnebuf,adrbuf);
		else
			fprintf(targetfile,"\t%s\n",mnebuf);
	f (adrbuf[0]) fprintf(targetfile,"\t%s\t%s\n",mnebuf,adrbuf);
		else fprintf(targetfil<modulcount;modulcnt+
	dtabuf[0]=0;
	adrbuf[0]=0;
	mnebuf[0]=0;
}
int P2WriteReloc()
{
	if (RelocAdr[nextreloc] == (prgcount*2 + prgstart)) {
		dtabuf[0]=0;
		mnebuf[0]=0;
		adrbuf[0]=0;
		mnecat("DC.W");
		adrcat("$");
		adrcat(itohex(sigw,4));
		dtacat(itohex(pc*2+prgstart,adrlen));
		prgcount=pc+1;
		Ausgabe();
		return(-1);
	}
	else {
		dtacat(itohex(buffer[prgcount++],4));
		return(0);
	}
}
UWORD NewAdrModes2(UWORD mode,UWORD reg) OPC_CALLM);my1) Get;square2=0nue;
	=Get continue;
				eunf=cnt]+m}t]+modultab[modulcfs[modulcnt]-8) || (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR)))
					return(NOADRMODE);
			}
			if (pflags&OLDSTYLE) {
				if (mode==10) GetLabel(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
				adrcat("(");
			}
			else {
				adrcat("(");
				if (mode==10) GetLabel(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
				adrcat(",");
			}
			if (mode==6) {
				adrcat("A");
				adrcat(itohex(reg,1));
			}
			else adrcat("PC");
			if (buf&0x8000) adrcat(",A");
			else adrcat(",D");
			adrcat(itohex((buf>>12)&7,1));
			if (buf&0x0800) adrcat(".L");
			/* else adrcat(".W"); */
		}
	}
	else {
		scale =(buf&0x0600)>>9;
		if (buf&0x0100) { /* MC68020 (& up) FULL FORMAT */
			bdsize=(buf&0x0030)>>4;
			odsize=(buf&0x0003);
			iis   =(buf&0x0007);
			is    =(buf&0x0040)>>6;
			operand=square1=square2=0;

			if (mode==10) reg=0;
			ifreturn(NOADRMODE);
			if (is==n(NOADRMODE);
			if (is==1 && iis>=4)       return(NOADRMODE);
/*
			if (is==1 && (buf&0xfe00)) return(NOADRMODE);
			if (buf&0xitohex(pc*2+prgstart,adrlen));
		prgcount=pc+1;
		Ausgabe();
		return(-1);
	}
	else {
		dtacat(itohex(buffer[prgcount++],4));
		return(0);
	}
}
UWORD NewAdrModes2(UWOWORD mode,UWORD reg)(prgcount*2+prgstart)) {
	1				GetLabel(RelocVal[nextreloc],999OPC_CALLM);my1) Get;sq0]=0;
(K[modulcnn] && p2labind<la) {
	1				GetLabel(RelocVal[nextreloare1) operand|=6;

			adrcat("(");
			if (square1) adrcat("[");
			if ((square1|operand)&1) { /* bORD#$r) strc");
			unt = (pt=2adrcat("("); */
		onextOPC_unt = (ptrtargoduloffs[modulcnt]+modultab[modulcnt]) || adr<(LONG)(moduloffs[modulcnt]-8) || (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR)))
							return(NOADRMODE);
						if (P2WriteReloc()) return((UWORD)-1);
						GetLabel(adr,mode);
					}
					else {
						if (P2WriteReloc()) return((UWORD)-1);
						adrgstart)) {
	1				GetLabel(RelocVal[nextreloc],999OPC_CALLM);my1) Get;sq0]=0;
(K[moduunt*2+prgstart)) {
	1				GetLabel(RelocVal[nextreloc],999OPC;
				}
			}

	/* {
						dtacat(itohex(buffer[prgcount++],4));
						if (mode==10			if (buf&0cnt]+m}t/*
							if (adr>=(LONG)(moduloffs[mreturn(NOADRMODE);
							if (P2WriteReloc()) return((UWORD)			if (buf&0x00}loc()) return((UWORD)-1);
							ad");
			}
			/* base register or (Z)PC */
			if ((square1|ope			if (buf&0x00}ltohex(reg,1));
				}
				else {
					adrcat("PC");
			1				GetLabel(RelocVal[nextrelo");square2=0;}
				if (square1 || operand)  adrcat(",");
			}
			/* index register */
			ifORD#$r) strc");
			unt = (pt=2adrcat("("); */
		onextOPC_unt = (ptrtargoduloffs	1				GetLabel(RelocVal[nextreloare1) operand|=6;

		if (P2WriteReloc()) return((UWORD)-1);
					adrcat(itoa((WORD)buffer[prgcount-1]));
				}
				if (odsize==3) {
					if (RelocAdr[nextreloc]==(prgcount*2+prgstart)) {
						GetLabel(RelocVal[nextreloc],9999);
						nextreloc++;
						dtacat(itohex(buffer[pr	}
}
UWORD NewAdrModes2(UWORD mode,UWORD reg) OPC_CALLM);my1) Get;square2=0nue;
	=Get continue;
				eunf=cnt]+m}t]+modultmber==OPC_JMP || 	return(NOADRMODE);
1		} opcnumber==O1C_JSR)))
				{ags&OLDSTYLE) {
				if (modl(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
				adrcat("(");
			}
			else {
				adrcat();
				imode==10) GetLabel(adr,mode);
				else adrcat(itoa((char)(buf&0x00FF)));
	mber]  =0			adrcat(",");
			}
			if (mode==6) {
				adrcat("A");
				adrcat(itohex(reg,1));
		mber]  =0			ad	else adrcat("PC");
			if (buf&0x8000) adrcat(",A");
			else adrcat(",D");
		if (scale) {
				adrcat("*");
				adrcat(itoa(1<<scale));
			}
		}
	}
	adrcat(")");
	return(mode);
}

int DoAdress2(UWORD adrs)
/* This is for PASS 2 */
{
UWORD i;
UWORD mode=adrmode;
UWORD dummy1;
UWORD buf=buffer[RMODE) {
		/* if (mode>0x30) mode=0x07+(mode&0x0ht byteweise zugegriffen werden    */
					/* Bei LEA ist extens == 0 (weil ungerade Adressen erlaubt sind) */
					if (extens || opcnumber==OPC_LEA) {
						adrcat("A");
						adrcat(itohex(reg,1));
1) strcat( ADR=%08x not found!\n",ad	zero++;dressregister indirekt */
					adrcat("(A");
					adrcat(itohex(reg,1));
					adrcat(")");
					break;
		case  3: /* (An)+  address register indirect with postincrr[Rdr[ostackchtern ULONG
 CALLM);my1) Get;sq0]=0;
=0nue;
	=Get contiontinue;
				eunf=(buf&0x00ht angenommen */
/*
					if (extens && buf&1)ugegriffen.en  .				ugegrifd weanzfora *			ifreturn(-1);
					D8(ASERE)							adr = prgstart+baseadr+1WORD)buf;
							if (adr>(LONG)(moduloffs[basesec]+modultab[basesec]-2) || adr<(LONG)moduloffU")");
DE;
DFQ,SUBQe);e destadrmmy1=0;
							else dummy1=1;
						}
						if (dummy1) GetLabel(adr,mode);
						else {
							if (pflags&OLDSTYLE) {
								adrcat1itoa((WORD)buf));
													else {
								adrcat("(");
								adrcat(itoa((WORD)buf));
								a!(adr,mode);
							eoAdressl,m,r,onf"));tab[basesec.reatl im ("("ram				emtype[reg,1));
							adrcat(")");
/*						} */
					}
					break;
		case  6: /* (bd,ern ULONG
 CALLM);my1) Get;sq0]=0;
=0nue;
	=Get contiontinue;
				eunf=(buf&0x00t+1]);
					if (adr&CALLM. */
		case 10: /* (bd,PC... */
					if ((mode=NewAdrModes2(mode,reg))==-1) return(-1);
			U")");			break;
		case  7: /* Absolute Adresse 16Bit */
					adr = (WORD)buf;
					if (adr&1 && (extens || opcnumber==OPC_JMP || opcnumber==OPC_JSR || opcnumber==OPC_BITSHIFTAdr/
					if (buf[Rcnu				i, urn(NOADRMODnd)  adrcat(",");
	,}
			/* index register; retu || operand)  adrcat(",");
			}
			/* index register */Adr/
					"3 nd)  adrc			]=hine=  nd)  adrc			]=hine=RMODat(",");
Dat(",");
+1Dnd)  adrcat(",");
	Dnd)  adrcat(",");
RD|| (1);
						nue;
	=Get contiontnue;
				eunf=(buf&0x));
						else	{
							if (sourcetype == 1 && prgstart && (adr >= prgstart && adr <= prgende))
								GetLabe!(adr,mode);
		eg,1));
							adrcat(")");
/*						} */
					}
					break;
		case  6: /* (bd,ern ULONG
  CALLM);my1) Get;sq0]=0;
=00nue;
	=Get contiontitnue;
				eunf=(buf&0x	}unt+1]);
					if (adr&1CALLM. */
		case 10: /*opcn.SIZEiperand&unt = (pt=2adrcat("("); *elocAdr[nextreloc]==(prgcount*2+prgstart)) {
							if ((pflags&BASEREG2) &&
							    (RelocMod[nextreloc]==basesec))
								GearFlag == 1
							GetLabel(RelocVal[nextreloc],9999);
						nnextreloc++;
						}
						else {
							i}
				}
			}
			if (texts&OLDSTYLE) {
								adrcat1itoa((WORD)buf));
													eCALLM);my1) Get;sq0]=0;
nue;
	=Get contionnue;
				eunf=(buf&				else {
				ocVal[next					nextreloc++;
						dtacat(itohex(buffer[prgcount++],4));
						dtrcat(").W"); */9					d) - R --> B					break;
		caDE;
					else {
			&& reg==ba],4)
			1adr = ((prgcount-1)*2+pcnt]+modultab[modulcnt]) || adr<(LONG)(moduloffs[modulcnt]-1adr = ((prgcount-1)*2+pOADRMODE;
					elsdummy1) GetLabel(adr,mode)GetLabel(adr,mode);
				adrcat("(A");
					if (P2WriteReloc()) return((UWORD,| (1);
							4));
						dtrcat(").W"); *11					IMMEDIopcn.SIZE*SCALE)F;Adr/
					"4 nd)  adrc			]=hine=  nd)  adrc			]=hine=RMODat(",");
Dat(",");
+1Dnd)  adrcat(",");
	Dnd)  adrcat(",");
RD|| (1)elsturn((UWORD#$r) strc");
						adrcat(itohAdr[nextreloc] >= p	32Bitn.SIZEC_BITSHIFT1))
						mode=NOADRMODE;
					else {
			+2& 
					else {
						if (Relochtung: Uzro ,D");
			adrcat(			{
RunFF) {

		caDE;
NOFRA,NOF..!)OPC_BITSHIFT1))
						mode=NOA16MODE;
DFQ,SUBQe);e destadr[opcnumber]=0x0bf8;
			((buf>8mode;
UWORD dummy1;
UWORD buf=buffer[prgcount];
U17RD reBKPTe);e destadr[opcnumbmode;
UWORD dummy1;
UWORD buf=buffer1itoa((WORD)buf));
													eCALLM);my1) Get;sq0]=0;
nue;
	=Get contionnue;
				eunf=(buf&				else {
				ocVal[	loc],99IFFF;
	(					loc],HncannTSH,*s									if (pflagsunt-1],4));
*/
				;
	a & ROTATE Data Ret ext0 CodeAreaMax) {
				CodeArea1 = GetNeesNlt+p					if (pflagsuntD	if (pflagsupflagsuntCodeArea1 = GetNees1lt+p					enrgcx;
UWORD duffs[modulcnt]-1adr = ((prgcount-1)*2+pOADRMODE;
					elsdtLabel(adr,mode);
				if (P2WriteReloc()) abel(adr,mode);
				if (P2WriteReloc()n(adrbuf)/s |uf<<16) + buffer[prgcounrmode=NOAD;
				}
			}de=NOADRMODE;
					else {
			1		if ber==O1 = GetNeesNlt+p					if00pflagsuntD	if 		euntCodeArea1 = GetNee	adrcat(")");!=3)
					mnecat(extM1
					adrmode=NOADRn");
	fprintf84w(lablffs[fert(") adrcat(",D");
			aprgst	else {
			es=0;
				whicd(l\n");


gif (!(tai82tfileLINK , (ad(": ");
				dtacei LEA ist extens == 0 (weil ungunt{						eCALLM);my1) Get;sq0]=0;
nue;
	=Get contionnue;
				eunf=(buf&				else {
				ocVal[	riteRer==OP|| opcnum			onextOPC_JSR |		strm			onextOPC_JSRHL CQe	mode1		if ber==O1 = GetNeesNlt+p				},STOPadr SR |		strm			onextOPC_JSRHL C(flags[1		if ber==O1 = GetNeesNlt,+modulOP ONLffset))
		/* HERE d nd lr]=0x80)
	Symbol(Label8r]=0x8);
			dtacat(": nextreloc] == (prgcount*2 + 
      memtson((age B
						dummy1=0;etOpcode();
	uf[ae flag = zufDDde=adrmode;
UWORD dummy1;
UWORD buf=buffer[lcnn] && p2labind<la) {
	1				GetLabel(RelocVal-1;
				));
					}
				}
				if (bdsize==3ffer[prgE0unt++],4));
				));
					JSRHL CQe	mode=NOA1onextOPC_JSR |		str opcnum0Rf(" Se_g = zufDde=x00FFcat(ito3lx00FFcat(itxtmeOPC (adr   %s = nex"(lablffs[4ertR,STOPadr SR |		strm		"Z");{ (sigw&0x010) mneeturn(-1);
						/* adrcat("("); */
						/* PEA jL,"flags[opcnum38
	ufd(itoheel(adr,m}) return(-1);
						/* adrcat("("); */
						/* PEA jL,"flags[opcnum38
	ufd(itoheel(adr,m},	}FEXTS,	}FFFO,	}F(ts			else {
				t("L");
				el	/* adrcat("("); */
						/* P,EA jL,						/*dr,modeels (sigw&0x0100) "("); */
		onextOPC_JSR0f("     6    %RTM=0;etOpcode();
	uf[aet])
							adrcat(" %RTM=0;etOpcode();
	uf[aet])
							adrcat("$"));+code();
	uf[						ad1caDR=%08x nat("$[M=0;etOpcodeOpcodeOpcode
					d++;
						}f (Rec

		E(Rec

		E%s:\n",E%s:\		adR			}
	B
	E%s:\n",E	E%s:\n-=1 bUWORD dummy1;
Ucnt]r0r,mon.SIZEC_BITSHIFT1))
						8*A
			=%08x nat("$[M=0;etOpcode eOpcodeOpcode
		("L");
	f		E(Rec

		E%s:\n",E%s:\		adR			}
	B
	E%s:\n",E%s:E%s:xtOPC_JSE%s:\n-=1 bUWORD dummon.SIZEC_BITSHIFT1))
						8*A
						}
mnecat("R");
			} else if (opcnS 6    %(HIFT1))if (opcnUIFT1))
					ad!R");
			} 4							mber==OPC_B
			DIVLt++];
t(")+");
				E"  i=k;
			}
;
			}
to"$
							if ((pflag:Dr[prgcount-1]));
				9999);
						nif 
				CodeArea1 }cei LEA ist extens == 0 (weidummy1=0;etOpcode();
	uf[ae flag = zufDde=adrmode;
UWORD ]));
				999A);
(bufEC_BITSHIFT1))
						8*A
					s&SHOW_;
				 PO1])
CREMENT	mode=(aet])
		RHL CQe	mode1		if ber==O1 = GetNeesNlt+p				},STOPadr SR |		strm	er]) {
				if (DoAdress2(sourceadr[opcnumber])) continue;
				if (opcnumber!=OPC_BITFIELD)
					if (destadr[RHL CQe	mode1		if ber==O1 = GetNeesNlt+p				},STOPadr SR |		strm	e
	if (extra&0==6) {
	c6(tp 			UP) sourceadptr[k++]='\n';

f[aeloc()) r,");
			UP) source2dptr[k++]='\n';

P[aeloc()) r,");
			UP) source3dptr		el	/* CodeArea1 = Getx  opc=%lu  adrflaestadr[ostackchter	adrcat("$"));
33drcat("*"Crbuf);
r)(buf&0x00FFcat(ito3lx00FFcat(itxtmeumber==OPC_B)(bufu;
	if (sis(Rec

		E%s:1n",E%s:\		adR			}
mnecat("tern U1eg1) rercat(".L");
						}
						else {
				R0f("     6    %RTM=0;etOptNeesNIFT1))
						8*AlLONG
     ]
						rnt*2at("ter)arget(tptr,k);

			");U1eg1) rercat(".L");
{T1))
						mode=NOADRMODE;
					else {
		umber==destadr	if (tflag==drct(")+");
					br("     6   rct(")+");
					brmodulcnt));
		\n",adrbuf);
				adrg=0;
			p2labind++;
		}
		if (flag == 0)
			fprode);
PE}/C) {operaferi 
4ec


4e,0St &&  f0rca
				      Writr1;
				s) 
;
}onf"reas();
*seg1;
					break;cn
ar **ar
					adrcat(
					
	ARGV = argv;
	Init();
	InitOpcode();
	
					
	ARc,c(adr-o				adrrel,					ress-a\tueft(",A"); */
	&reak;L4,earessG;

	} else=atoi(				}
	reak;		l=0;r=F3) || (a			i_HEADERuf,ad*Intuitionuf[0]!=0) = Get1eg1 LoadSeg(
					
	ARflag:Dr[UnLoadSeg(
r]  =0x8r_line == 4)HOW_RELOCle (

				if (te*Intuition (	s)....:);
	
					
	ARc,cha0St &&  f2Area(ULONG l=0,reak;		l=0;3E7) || (a			i_UNITuf,ad
    Guf[0]!=0x8r_line == 4)HOW_RELOCle (

				if (te
    G (	s)........:);
	
					
	ARc,chaferi 
43)cnt));
		\ne == 4)HOW_RELOCle (

				if (te  _abo (	s)........:);
	
					
	ARc,c0St &&  f1[D *)bu]a ,
    _abor.\n",buffbasereg=atsgabe {
	pa(
);
	}
	);
PE}/C1],memNur");M	}
	]!=0xU> (pr	  08X\n",ectio
		/* Senex"();
[,&CodeAd 08X\n",ectio
		/* SearchCode(AreaMax);08X\n",ectio
		/* SearchCode(eLINK , (08X\n",ectio
		/* SearchCode
[,&CodeAde oc =id
       ma
					
	ARc,c0eLINK , (a occuG  modtype;;
					els occuArea2[;| (a			i_EEP_]!=0tr 08LastM	}
	] o b1;f/* oirstM	}
	]		ad W
r[trr,krPuntry);
					
	AR[D *)bu]a ,
  
    nfile,
[i] >= CN.22	,dultaE,i1;
				break;cn
aresek;
					ressL4,SEEK_E itflCs:adf[lc-2]
					ressL0;0tf);
		\ne == 4)HOW_RELOCle (

				if (  unitR %0:pe();
	StdN	AR[D  &ead(lade; */
	&.22	L4,ea
					ress2(2(sourcDDde=M	}
	dty S_%ld,

		lr]=)e==10) GetL(.22	) s0)			b3)n; */
	&dultaEL4,ea
					ress2; adrcatw,r,tskom";
ibf (long	

			&cuAreeeeM68881 &f[aeloc()

		
	for(i=xtreArea2[fu;
	EEP_]!=0r(i=xtreArea2Afu;
		}
		!=0r(i=xtreArea2B: [j])) {tacat(": "	}
	);
PE++; adrcnzahlt;i++M	}
	e +TE *buf,*t; */
	&dultaEL4,ea
					ress2; adrLaultmy1=0+M	}
	sE *buf,*tnf (fn",ectio 
		re(		itoh N {tCodeuf,*tnf (->ln_N	ARFT1),
    )dultaELONG *)bddTail	&l			,nbel(adr,modGetL

			!l=0;r=labccccc,memNur"drc;
			fora


			 *buf,*taresek;
					ressLdultaE*4,SEEK_CUR2; adrLaultmy&& adss-t(",A"at(ito3lx00FFc=xtreAreaF7:| (a			i_DREL32 	!=0r(i=xtreAreaF8:| (a			i_DREL16 	!=0r(i=xtreAreaF9:| (a			i_DREL8  	!=0r(i=xtreAreaEC:| (a			i_RELOC32	!=0r(i=xtreArea2D:| (a			i_RELOC16	!=0r(i=xtreArea2E:| (a			i_RELOC8{tacat(": do
				t("L"); */
en      Rea is no text 				/* P,EA j(; */
	&dultaEL4,ea
					ress2geif 1a ource3dptr		eEA jdultaE) resek;
					ressLjdultaEf(t*4,SEEK_CUR2;Area1 = ad(la jdultaE);"at(ito3lx00FFc=xtreAreaF2:| (a			i_END  	!="at(ito3lx00FFc=xtreAreaE8:| (a			i_NAMEE *buf,*t; */
	&dultaEL4,ea
					ress2;
f,*taresek;
					ressLdultaE*4,SEEK_CUR2;"at(ito3lx00FFc=xtreAreaF1:| (a			i_DEBUGE *buf,*t; */
	&dultaEL4,ea
					ress2;
f,*taresek;
					ressLdultaE*4,SEEK_CUR2;"at(ito3lx00FFc=xtreAreaF0:| (a			i_SYMBOLtacat(": do
				t("LEA j(; */
	&dultaEL4,ea
					ress2geif 1a ource3dptr		eEA jdultaE) resek;
					ressLjdultaEf(t*4,SEEK_CUR2;Area1 = ad(la jdultaE);"at(ito3lx00FFc=xtreAreaEF:| (a			i_EXTtacat(": do
				t("Lptr1 <		el;
			t("LEA j(; */
	&dultaEL4,ea
					ress2geif 1a ource3dptr		e}
				 dultaE>>24DRMODE;
					=dultaELONG *)	dultaE	&cuAreeE&M68881=0;
					}
				 PEA jL,"f		aeloc()ax);)*EA jLx0bfe;
				else EXT_SYMBtacat("number]=0x0fff;
EXT_D-1)tacat("number]=0x2fff;
EXT_ABS)tacat("number]=0x3fff;
EXT_RES)tacat("number]=0x13	else EXT_COMM)
							aaaaaaresek;
					ressLjdultaEf(t*4,SEEK_CUR2;Area1  buf[j]!=
		e=13	)*EA jLx0uf,*t; */
	&dultaEL4,ea
					ress2;
f,*taf,*taresek;
					ressLdultaE*4,SEEK_CUR2;"at(i					adrcat(itohource3at("number]=0x129fff;
EXT_REF32)tacat("number]=0x131fff;
EXT_REF16)tacat("number]=0x132fff;
EXT_REF8 )tacat("number]=0x133fff;
EXT_D-XT32tacat("number]=0x134fff;
EXT_D-XT16tacat("number]=0x135fff;
EXT_D-XT8 taca,*taf,*taresek;
					ressLdultaE*4,SEEK_CUR2;"at(i					; */
	&dultaEL4,ea
					ress2;a,*taf,*taresek;
					ressLdultaE*4,SEEK_CUR2;"at(i					ource3at("nu ded),
   := Ge	drcat(itohex(eUnknm0,a			i_EXTtsub-=
		e%di!tex,=
		2;"at(i					ource3at("nu d	if (p2labind < lad(la	}
				 ;nt(ito"$"lse ded),
   := Ge	t(itohex(e				...:x(*buNOT SUPPORTEDmachi

		 ;nt(ito"$"lse
 < ff;
E			t- Saeloc()e==10< ff;
Naechst=0+M	}
	 e	mss-t(fora
 is n (ben.e==1);
		\ne == 4)HOW_RELOCle (

				if (  M	}
	es0:pedachi(targetfile;
0xU> (pr	  X\n",ectiotoi(&buffe{
		/* Senex"();
[,&CodeAd8X\n",ectiotoi(&buffe{
		/* SearchCode(;
					elX\n",ectiotoi(&buffe{
		/* SearchCc,c0eLINK , (X\n",ectiotoi(&buffe{
		/* SearchCc,c0AreaM  *SX\n",ectiotoi(&buffe{
		/* Search< etfl
ea1 = GetNewVarBuffer(CodeArea1r **arnf (fRemH*/
	&l			 argv;

	Init();Troubh							eInt RemH*/
i!text) {[,&CodeAdei]
			U")");nf (->ln_N	AR;
		ose(labfnf (, 
		re(		itoh N {tCodeu}n
aresek;
					ressL4L,SEEK_E itflCs:adf[lc-2]
					ressL0;0tf)r 08LastM	}
	] =atoi(&buffer-b1;f/* oirstM	}
			ad W
rExam"(l					([D *)bu]a ,
  *Intuitionfile,
[i] >= CNreak;cn
aresek;
					ressL4L,SEEK_E itflC/* Librabo
	AR  fwird ncopel*/
				/* utzt)y&& adss-t(",A"aad(la	}
				=s:adf[lc-2]
					ressL0;0t,;
				if (p  Librabo0:pe();
	StdN	AR[D  	adrcnzahlt;i++M	}
	e e	mss-t(",A"); */
	&toi(&buffeL4,ea
					ress2;1);
		\ne == 4)HOW_RELOCle (

				if (  M	}
	es0:pedachi(targetfile;
0x/* oirstfora8Last e	mss-t(",A"); */
	&oirstM	}
	L4,ea
					ress2;"); */
	&LastM	}
	L4,ea
					ress2;1);
		\oirstM	}
	) 
	Init();
	Inith
			e first(targ	!l=0 !!texe;
0xU> (pr	  X\n",ectiotoi(&buffe{
		/* Senex"();
[,&CodeAd8X\n",ectiotoi(&buffe{
		/* SearchCode(;
					elX\n",ectiotoi(&buffe{
		/* SearchCc,c0eLINK , (X\n",ectiotoi(&buffe{
		/* SearchCc,c0AreaM  *SX\n",ectiotoi(&buffe{
		/* Search< etfl
ede=M	}
	eAdeTarg(M	}
	laultmn) e	mss-t(",A"); */
	,&CodeAdL4,(LastM	}
	-oirstM	}
	f(ta
					ress2 W
rExam"(l					([D  *)FROM1=0B:c.o "iraGUIMain.o"
TO "iraGUIMain"
=0B1=0B:sc.lib1=0B:am"ga.lib
)FROM1=0B:c.o "ira_2.o"
TO "ira_2"
=0B1=0B:sc.lib1=0B:am"ga.lib
)(memtypmemtype[modulcnt])
					fprintf(targetfilde===========================================filde=======Detx ni++(C) Ian Oe,"nco 1994=======filde======= ===================================filde======Detx ni++dr duclabC h				adress======filde======= ===================================fildeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee!=0tr
#nex"(lInititof0oirstID 0
#nex"(lIWin0_Gad0 0
#nex"(lIWin0_Gad1 1
#nex"(lIWin0_Gad2 2
#nex"(lInititof0_Gad3 3
#nex"(lInititof0_Gad4 4
#nex"(lInititof0_Gad5 5
#nex"(lInititof0_Ga