#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <time.h>



#define DELTA
#define DELTA_OP +


/* Pucrunch ©1997-2008 by Pasi 'Albert' Ojala, a1bert@iki.fi */
/* Pucrunch is now under LGPL: see the doc for details. */


/* #define BIG */
/*
    Define BIG for >64k files.
    It will use even more *huge* amounts of memory.

    Note:
    Although this version uses memory proportionally to the file length,
    it is possible to use fixed-size buffers. The LZ77 history buffer
    (and backSkip) needs to be as long as is needed, the other buffers
    minimally need to be about three times the length of the maximum
    LZ77 match. Writing the compressor this way would probably make it a
    little slower, and automatic selection of e.g. escape bits might not be
    practical.

    Adjusting the number of escape bits to adapt to local
    changes in the data would be worth investigating.

    Also, the memory needed for rle/elr tables could probably be reduced
    by using a sparse table implementation. Because of the RLE property
    only the starting and ending points (or lengths) need be saved. The
    speed should not decrease too much, because the tables are used in
    LZ77 string match also.... Wait! Actually no, because the RLE/LZ77
    optimize needs to change the RLE lengths inside RLE's...

    The elr array can be reduced to half by storing only the byte that
    is before a run of bytes if we have the full backSkip table..

    Because the lzlen maximum value is 256, we could reduce the table
    from unsigned short to unsigned char by encoding 0->0, 2->1, .. 256->255.
    lzlen of the value 1 is never used anyway..

 */

#define ENABLE_VERBOSE      /* -v outputs the lz77/rle data to stdout */
#define HASH_STAT	    /* gives statistics about the hash compares */
#define BACKSKIP_FULL       /* full backSkip table - enables RESCAN. If */
                            /* not defined, backSkip only uses max 128kB */
#define RESCAN		    /* rescans LZ77 matches for a closer match. */
#define HASH_COMPARE    /* Use a 3-to-1 hash to skip impossible matches */
/* takes "inbytes" bytes, reduces string compares from 16% to 8% */



const char version[] = "\0$VER: pucrunch 1.14 22-Nov-2008\n";



static int maxGamma = 7, reservedBytes = 2;
static int escBits = 2, escMask = 0xc0;
static int extraLZPosBits = 0, rleUsed = 15;

static int memConfig = 0x37, intConfig = 0x58; /* cli */


/*
-------->
    z..zx.....x						     normal (zz != ee)
    e..e	value(LEN)	value(POSHI+1)	8+b(POSLO)   LZ77
    e..e	0    (2)	0 (2-256)	8b(POSLO)    LZ77
    e..e	100  (3)	111111 111111		     END of FILE
#ifdef DELTA
    e..e	101  (4..)	111111 111111	8b(add) 8b(POSLO)	DLZ
#endif

    e..e010	n..ne.....e				     escape + new esc
    e..e011	value(LEN)	bytecode		     Short RLE  2..
    e..e011	111..111 8b(LENLO) value(LENHI+1) bytecode   Long RLE
		(values 64.. not used (may not be available) in bytecode)


e..e011 0 0			RLE=2, rank 1 (saves 11.. bit)
e..e011 0 10 x			RLE=2, rank 2-3 (saves 9.. bit)
e..e011 0 11 0xx		RLE=2, rank 4-7 (saves 7.. bit)
e..e011 0 11 10xxx		RLE=2, rank 8-15 (saves 5.. bit)
e..e011 0 11 110xxxx xxxx	RLE=2, not ranked


LZ77, len=2 (pos<=256) saves 4 bits (2-bit escape)
LZ77, len=3 saves 10..1 bits (pos 2..15616)
LZ77, len=4 saves 18..9 bits
LZ77, len=5 saves 24..15 bits

RLE, len=2 saves 11..1(..-5) bits (bytecode rank 1..not ranked)
RLE, len=3 saves 15..2 bits
RLE, len=4 saves 23..10 bits
RLE, len=5 saves 29..16 bits

bs: 3505 LZ reference points, 41535 bytes -> 11.85, i.e. 8.4% referenced


 1) Short RLE -> gamma + 1 linear bit -> ivanova.run -29 bytes

 2) ?? .. no
    esc = RLE, with value 1
    e..e01 value(1)	n..ne.....e			     escape + new esc
    e..e01 value(LEN)	bytecode			     Short RLE  2..
    e..e01 111..111 8b(LENLO) value(LENHI+1) bytecode        Long RLE
		(values 64.. not used (may not be available) in bytecode)


*/

/*
Value:

Elias Gamma Code rediscovered, just the prefix bits are reversed, plus
there is a length limit (1 bit gained for each value in the last group)
; 0000000	not possible
; 0000001	0		1			-6 bits
; 000001x	10	x	2-3			-4 bits
; 00001xx	110 	xx	4-7			-2 bits
; 0001xxx	1110 	xxx	8-15			+0 bits
; 001xxxx	11110	xxxx	16-31			+2 bits
; 01xxxxx	111110	xxxxx	32-63			+4 bits
; 1xxxxxx	111111	xxxxxx	64-127			+5 bits

*/


#include "pucrunch.h" /* Include the decompressors */


void ListDecompressors(FILE *fp) {
  struct FixStruct *dc = &fixStruct[0];

  while (dc && dc->code) {
    fprintf(fp, "%s\n", dc->name);
    dc++;
  }
}

struct FixStruct *BestMatch(int type) {
    struct FixStruct *dc = &fixStruct[0], *best = NULL;

    while (dc && dc->code) {
	if ((dc->flags & FIXF_MACHMASK) == (type & FIXF_MACHMASK)) {
	    /* machine is correct */
	    /* Require wrap if necessary, allow wrap if not */
	    /* Require delta matches */
	    if (((dc->flags & type) & FIXF_MUSTMASK) ==
		(type & FIXF_MUSTMASK)) {

		/* Haven't found any match or this is better */
		if (!best ||
		    ((type & FIXF_WRAP) == (dc->flags & FIXF_WRAP) &&
		     (!(type & (FIXF_FAST | FIXF_SHORT)) ||
		      (dc->flags & type & (FIXF_FAST | FIXF_SHORT)))))
		    best = dc;
		/* If requirements match exactly, can return */
		/* Assumes that non-wraps are located before wrap versions */
		if ((type & (FIXF_FAST | FIXF_SHORT)) ==
		    (dc->flags & (FIXF_FAST | FIXF_SHORT))) {
		    return dc;
		}
	    }
	}
	dc++;
    }
    return best;
}


int GetHeaderSize(int type, int *deCall) {
    struct FixStruct *best;
    if (deCall)
	*deCall = 0;
    if ((type & FIXF_MACHMASK) == 0) {
	return 47; /* standalone */
    }
    best = BestMatch(type);
    if (best && deCall) {
	int i;
	for (i=0; best->fixes[i].type != ftEnd; i++) {
	    if (best->fixes[i].type == ftDeCall) {
		*deCall = best->fixes[i].offset;
		break;
	    }
	}
    }
    return best?best->codeSize:0;
}


int SavePack(int type, unsigned char *data, int size, char *target,
	     int start, int exec, int escape, unsigned char *rleValues,
	     int endAddr, int progEnd, int extraLZPosBits, int enable2MHz,
	     int memStart, int memEnd) {
    FILE *fp = NULL;
    struct FixStruct *dc;
    unsigned char *header;
    int i, overlap = 0, stackUsed = 0, ibufferUsed = 0;

    if (!data)
	return 10;
    if (!target)
	fp = stdout;

    if ((type & FIXF_MACHMASK) == 0) {
	/* Save without decompressor */

	if (fp || (fp = fopen(target, "wb"))) {
	    unsigned char head[64];
	    int cnt = 0;

	    head[cnt++] = (endAddr + overlap - size) & 0xff;	/* INPOS */
	    head[cnt++] = ((endAddr + overlap - size) >> 8);

	    head[cnt++] = 'p';
	    head[cnt++] = 'u';

	    head[cnt++] = (endAddr - 0x100) & 0xff;
	    head[cnt++] = ((endAddr - 0x100) >> 8);

	    head[cnt++] = (escape>>(8-escBits));
	    head[cnt++] = (start & 0xff);	/* OUTPOS */
	    head[cnt++] = (start >> 8);
	    head[cnt++] = escBits;
	    /* head[cnt++] = 8-escBits; */

	    head[cnt++] = maxGamma + 1;
	    /* head[cnt++] = (8-maxGamma); */ /* Long RLE */
	    head[cnt++] = (1<<maxGamma); /* Short/Long RLE */
	    /* head[cnt++] = (2<<maxGamma)-1; */ /* EOF (maxGammaValue) */

	    head[cnt++] = extraLZPosBits;

	    head[cnt++] = (exec & 0xff);
	    head[cnt++] = (exec >> 8);

	    head[cnt++] = rleUsed;
	    for(i = 1; i <= rleUsed; i++) {
		head[cnt++] = rleValues[i];
	    }

	    fwrite(head, 1, cnt, fp);
	    fwrite(data, size, 1, fp);
	    if(fp != stdout)
		fclose(fp);
	    return 0;
	}
	fprintf(stderr, "Could not open %s for writing\n", target);
	return 10;
    }
    if ((memStart & 0xff) != 1) {
	fprintf(stderr, "Misaligned basic start 0x%04x\n", memStart);
	return 10;
    } else if (memStart > 9999) {
	/* The basic line only holds 4 digits.. */
	fprintf(stderr, "Too high basic start 0x%04x\n", memStart);
	return 10;
    }

    if (endAddr > memEnd) {
	overlap = endAddr - memEnd;
	endAddr = memEnd;

	/*
	    Make the decrunch code wrap from $ffff to $004b.
	    The decrunch code first copies the data that would exceed
	    $ffff to $004b and then copy the rest of it to end at $ffff.
	 */

	if (overlap > 22) {
	    fprintf(stderr, "Warning: data overlap is %d, but only 22 "
		    "is totally safe!\n", overlap);
	    fprintf(stderr, "The data from $61 to $%02x is overwritten.\n",
		    0x4b + overlap);
	}
    }
    if (overlap) {
	type |= FIXF_WRAP;
    } else {
	type &= ~FIXF_WRAP;
    }
    dc = BestMatch(type);
    if (!dc) {
	fprintf(stderr, "No matching decompressor found\n");
	return 10;
    }
    header = dc->code;

    if (!memStart)
	memStart = 0x801;
#ifndef BIG
    if (memStart + dc->codeSize - 2 + size > 0xfe00) {
	fprintf(stderr, "Packed file's max size is 0x%04x (0x%04x)!\n",
		0xfe00-memStart-(dc->codeSize-2), size);
	return 10;
    }
#endif /* BIG */

    for (i=0; dc->fixes[i].type != ftEnd; i++) {
	switch (dc->fixes[i].type) {
	case ftFastDisable:
	    if (!enable2MHz) {
		header[dc->fixes[i].offset] = 0x2c;
	    }
	    break;
	case ftOverlap:
	    header[dc->fixes[i].offset] = overlap ? (overlap-1) : 0;
	    break;
	case ftOverlapLo:
	    header[dc->fixes[i].offset] =
		(memStart+dc->codeSize-2+rleUsed-15+size - overlap) & 0xff;
	    break;
	case ftOverlapHi:
	    header[dc->fixes[i].offset] =
		(memStart+dc->codeSize-2+rleUsed-15+size - overlap) >> 8;
	    break;
	case ftWrapCount:
	    header[dc->fixes[i].offset] =
		(memEnd>>8) - ((endAddr + overlap - size) >> 8); /* wrap point.. */
	    break;

	case ftSizePages:
	    header[dc->fixes[i].offset] = (size>>8) + 1;
	    break;
	case ftSizeLo:
	    header[dc->fixes[i].offset] =
		(memStart+dc->codeSize-2+rleUsed-15+size-0x100 - overlap) & 0xff;
	    break;
	case ftSizeHi:
	    header[dc->fixes[i].offset] =
		(memStart+dc->codeSize-2+rleUsed-15+size-0x100 - overlap) >> 8;
	    break;
	case ftEndLo:
	    header[dc->fixes[i].offset] = (endAddr - 0x100) & 0xff;
	    break;
	case ftEndHi:
	    header[dc->fixes[i].offset] = ((endAddr - 0x100) >> 8);
	    break;
	case ftEscValue:
	    header[dc->fixes[i].offset] = (escape>>(8-escBits));
	    break;
	case ftOutposLo:
	    header[dc->fixes[i].offset] = (start & 0xff);	/* OUTPOS */
	    break;
	case ftOutposHi:
	    header[dc->fixes[i].offset] = (start >> 8);
	    break;
	case ftEscBits:
	    header[dc->fixes[i].offset] = escBits;
	    break;
	case ftEsc8Bits:
	    header[dc->fixes[i].offset] = 8-escBits;
	    break;
	case ft1MaxGamma:
	    header[dc->fixes[i].offset] = (1<<maxGamma); /* Short/Long RLE */
	    break;
	case ft8MaxGamma:
	    header[dc->fixes[i].offset] = (8-maxGamma); /* Long RLE */
	    break;
	case ft2MaxGamma:
	    header[dc->fixes[i].offset] = (2<<maxGamma)-1; /* EOF (maxGammaValue) */
	    break;
	case ftExtraBits:
	    header[dc->fixes[i].offset] = extraLZPosBits;
	    break;
	case ftMemConfig:
	    header[dc->fixes[i].offset] = memConfig;
	    break;
	case ftCli:
	    header[dc->fixes[i].offset] = intConfig; /* $58/$78 cli/sei; */
	    break;
	case ftExecLo:
	    header[dc->fixes[i].offset] = (exec & 0xff);
	    break;
	case ftExecHi:
	    header[dc->fixes[i].offset] = (exec >> 8);
	    break;
	case ftInposLo:
	    header[dc->fixes[i].offset] = (endAddr + overlap - size) & 0xff;	/* INPOS */
	    break;
	case ftInposHi:
	    header[dc->fixes[i].offset] = ((endAddr + overlap - size) >> 8);
	    break;
	case ftMaxGamma:
	    header[dc->fixes[i].offset] = maxGamma + 1;
	    break;
	case ftReloc:
	    if (header[1] != (memStart>>8)) {
		header[dc->fixes[i].offset] -= (header[1] - (memStart >> 8));
	    }
	    break;

	case ftBEndLo:
	    header[dc->fixes[i].offset] = (progEnd & 0xff);
	    break;
	case ftBEndHi:
	    header[dc->fixes[i].offset] = (progEnd >> 8);
	    break;

	case ftStackSize:
	    stackUsed = header[dc->fixes[i].offset];
	    break;
	case ftIBufferSize:
	    ibufferUsed = header[dc->fixes[i].offset];
	    break;

	default:
	    break;
	}
    }

    for (i=1; i<=15; i++)
	header[dc->codeSize - 15 + i-1] = rleValues[i];

    if (header[1] != (memStart>>8)) {
	header[1] = (memStart>>8);	/* Load address */
	header[3] = (memStart>>8);	/* Line link */

	header[7] = 0x30 + (memStart+12)/1000;
	header[8] = 0x30 + ((memStart+12)/100 % 10);
	header[9] = 0x30 + ((memStart+12)/10 % 10);
	header[10] = 0x30 + ((memStart+12) % 10);
    }

    fprintf(stderr, "Saving %s\n", dc->name);
    if (fp || (fp = fopen(target, "wb"))) {
	fwrite(header, 1, dc->codeSize+rleUsed-15, fp);
	fwrite(data, size, 1, fp);
	if (fp != stdout)
	    fclose(fp);
    } else {
	fprintf(stderr, "Could not open %s for writing\n", target);
	return 10;
    }
    if (dc->flags & FIXF_SHORT) {
	fprintf(stderr, "%s uses the memory $2d-$30, ", target?target:"");
    } else {
	fprintf(stderr, "%s uses the memory $2d/$2e, ", target?target:"");
    }
    if (overlap)
	fprintf(stderr, "$4b-$%02x, ", 0x4b + overlap);
    else if ((dc->flags & FIXF_WRAP))
	fprintf(stderr, "$4b, ");
    if (stackUsed)
	fprintf(stderr, "$f7-$%x, ", 0xf7 + stackUsed);
    if (ibufferUsed)
	fprintf(stderr, "$200-$%x, ", 0x200 + ibufferUsed);
    fprintf(stderr, "and $%04x-$%04x.\n",
	    (start < memStart+1) ? start : memStart+1, endAddr-1);
    return 0;
}



#ifdef ENABLE_VERBOSE
#define F_VERBOSE (1<<0)
#endif
#define F_STATS   (1<<1)
#define F_AUTO    (1<<2)
#define F_NOOPT   (1<<3)
#define F_AUTOEX  (1<<4)
#define F_SKIP    (1<<5)
#define F_2MHZ    (1<<6)
#define F_AVOID   (1<<7)
#define F_DELTA   (1<<8)

#define F_NORLE   (1<<9)

#define F_UNPACK  (1<<14)
#define F_ERROR   (1<<15)

#ifndef min
#define min(a,b) ((a<b)?(a):(b))
#endif


#define LRANGE		(((2<<maxGamma)-3)*256)	/* 0..125, 126 -> 1..127 */
#define MAXLZLEN	(2<<maxGamma)
#define MAXRLELEN	(((2<<maxGamma)-2)*256)	/* 0..126 -> 1..127 */
#define DEFAULT_LZLEN	LRANGE

static int lrange, maxlzlen, maxrlelen;



#ifdef BIG
#define OUT_SIZE 2000000
#else
#define OUT_SIZE 65536
#endif /* BIG */
static unsigned char outBuffer[OUT_SIZE];
static int outPointer = 0;
static int bitMask = 0x80;


static void FlushBits(void) {
    if (bitMask != 0x80)
	outPointer++;
}


static void PutBit(int bit) {
    if (bit && outPointer < OUT_SIZE)
	outBuffer[outPointer] |= bitMask;
    bitMask >>= 1;
    if (!bitMask) {
	bitMask = 0x80;
	outPointer++;
    }
}


void PutValue(int value) {
    int bits = 0, count = 0;

    while (value>1) {
	bits = (bits<<1) | (value & 1);	/* is reversed compared to value */
	value >>= 1;
	count++;
	PutBit(1);
    }
    if (count<maxGamma)
	PutBit(0);
    while (count--) {
	PutBit((bits & 1));	/* output is reversed again -> same as value */
	bits >>= 1;
    }
}

#if 0
int LenValue(int value) {
    int count = 0;

    while (value>1) {
	value >>= 1;
	count += 2;
    }
    if (count<maxGamma)
	return count + 1;
    return count;
}
void InitValueLen(void) {
}
#else
int RealLenValue(int value) {
    int count = 0;

    if (value<2)	/* 1 */
	count = 0;
    else if (value<4)	/* 2-3 */
	count = 1;
    else if (value<8)	/* 4-7 */
	count = 2;
    else if (value<16)	/* 8-15 */
	count = 3;
    else if (value<32)	/* 16-31 */
	count = 4;
    else if (value<64)	/* 32-63 */
	count = 5;
    else if (value<128)	/* 64-127 */
	count = 6;
    else if (value<256)	/* 128-255 */
	count = 7;

    if (count<maxGamma)
	return 2*count + 1;
    return 2*count;
}
static int lenValue[256];
void InitValueLen(void);
void InitValueLen() {
    int i;
    for (i=1; i<256; i++)
	lenValue[i] = RealLenValue(i);
}
#define LenValue(a) (lenValue[a])

#endif


void PutNBits(int byte, int bits) {
    while (bits--)
	PutBit((byte & (1<<bits)));
}


static int gainedEscaped = 0;
static int gainedRle = 0, gainedSRle = 0, gainedLRle = 0;
static int gainedLz = 0, gainedRlecode = 0;

#ifdef DELTA
static int gainedDLz = 0, timesDLz = 0;
#endif

static int timesEscaped = 0, timesNormal = 0;
static int timesRle = 0, timesSRle = 0, timesLRle = 0;
static int timesLz = 0;

static int lenStat[8][4];


int OutputNormal(int *esc, unsigned char *data, int newesc) {
    timesNormal++;
    if ((data[0] & escMask) == *esc) {
	PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */
	PutValue(2-1);
	PutBit(1);
	PutBit(0);

#if 0
	*esc = (*esc + (1<<(8-escBits))) & escMask;
	PutNBits(data[0], 8-escBits);

	gainedEscaped += 3;
#else
	*esc = newesc;
	PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */
	PutNBits(data[0], 8-escBits);

	gainedEscaped += escBits + 3;
#endif
	timesEscaped++;
	return 1;
    }
    PutNBits(data[0], 8);
    return 0;
}



void OutputEof(int *esc);
void OutputEof(int *esc) {
    /* EOF marker */
    PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */
    PutValue(3-1);	/* >1 */
    PutValue((2<<maxGamma)-1);	/* Maximum value */

    /* flush */
    FlushBits();
}


static unsigned char rleValues[32] = {1,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
				0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
static int rleHist[256];

void PutRleByte(int data) {
    int index;

    for (index = 1; index < 16/*32*/; index++) {
	if (data == rleValues[index]) {
	    if (index==1)
		lenStat[0][3]++;
	    else if (index<=3)
		lenStat[1][3]++;
	    else if (index<=7)
		lenStat[2][3]++;
	    else if (index<=15)
		lenStat[3][3]++;
	    /*else if (index<=31)
		lenStat[4][3]++;*/

	    gainedRlecode += 8 - LenValue(index);

	    PutValue(index);
	    return;
	}
    }
/*fprintf(stderr, "RLECode n: 0x%02x\n", data);*/
    PutValue(16/*32*/ + (data>>4/*3*/));

    gainedRlecode -= LenValue(16/*32*/+(data>>4/*3*/)) + 4/*3*/;

    PutNBits(data, 4/*3*/);

    lenStat[4/*5*/][3]++;
    /* Note: values 64..127 are not used if maxGamma>5 */
}


#if 0
int LenRleByte(unsigned char data) {
    int index;

    for (index = 1; index < 16/*32*/; index++) {
	if (data == rleValues[index]) {
	    return LenValue(index);
	}
    }
    return LenValue(16/*32*/ + 0) + 4/*3*/;
}
#else
static unsigned char rleLen[256];
void InitRleLen(void);
void InitRleLen() {
    int i;

    for (i=0; i<256; i++)
	rleLen[i] = LenValue(16/*32*/ + 0) + 4/*3*/;
    for (i=1; i<16 /*32*/; i++)
	rleLen[rleValues[i]] = LenValue(i);
}
#define LenRleByte(d) (rleLen[d])
#endif


int LenRle(int len, int data) {
    int out = 0;

    do {
	if (len == 1) {
	    out += escBits + 3 + 8;
	    len = 0;
	} else if (len <= (1<<maxGamma)) {
	    out += escBits + 3 + LenValue(len-1) + LenRleByte(data);
	    len = 0;
	} else {
	    int tmp = min(len, maxrlelen);
	    out += escBits + 3 + maxGamma + 8 +
			LenValue(((tmp-1)>>8)+1) + LenRleByte(data);

	    len -= tmp;
	}
    } while (len);
    return out;
}

int OutputRle(int *esc, unsigned char *data, int rlelen) {
    int len = rlelen, tmp;

    while (len) {
	if (len >= 2 && len <= (1<<maxGamma)) {
	    /* Short RLE */
	    if (len==2)
		lenStat[0][2]++;
	    else if (len<=4)
		lenStat[1][2]++;
	    else if (len<=8)
		lenStat[2][2]++;
	    else if (len<=16)
		lenStat[3][2]++;
	    else if (len<=32)
		lenStat[4][2]++;
	    else if (len<=64)
		lenStat[5][2]++;
	    else if (len<=128)
		lenStat[6][2]++;
	    else if (len<=256)
		lenStat[6][2]++;

	    PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */
	    PutValue(2-1);
	    PutBit(1);
	    PutBit(1);
	    PutValue(len-1);
	    PutRleByte(*data);

	    tmp = 8*len -escBits -3 -LenValue(len-1) -LenRleByte(*data);
	    gainedRle += tmp;
	    gainedSRle += tmp;

	    timesRle++;
	    timesSRle++;
	    return 0;
	}
	if (len<3) {
	    while (len--)
		OutputNormal(esc, data, *esc);
	    return 0;
	}

	if (len <= maxrlelen) {
	    /* Run-length encoding */
	    PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */

	    PutValue(2-1);
	    PutBit(1);
	    PutBit(1);

	    PutValue((1<<maxGamma) + (((len-1)&0xff)>>(8-maxGamma)));

	    PutNBits((len-1), 8-maxGamma);
	    PutValue(((len-1)>>8) + 1);
	    PutRleByte(*data);

	    tmp = 8*len -escBits -3 -maxGamma -8 -LenValue(((len-1)>>8)+1)
		-LenRleByte(*data);
	    gainedRle += tmp;
	    gainedLRle += tmp;

	    timesRle++;
	    timesLRle++;
	    return 0;
	}

	/* Run-length encoding */
	PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */

	PutValue(2-1);
	PutBit(1);
	PutBit(1);

	PutValue((1<<maxGamma) + (((maxrlelen-1)&0xff)>>(8-maxGamma)));

	PutNBits((maxrlelen-1) & 0xff, 8-maxGamma);
	PutValue(((maxrlelen-1)>>8)+1);
	PutRleByte(*data);

	tmp = 8*maxrlelen -escBits -3 -maxGamma -8
	    -LenValue(((maxrlelen-1)>>8)+1) -LenRleByte(*data);
	gainedRle += tmp;
	gainedLRle += tmp;
	timesRle++;
	timesLRle++;
	len -= maxrlelen;
	data += maxrlelen;
    }
    return 0;
}


#ifdef DELTA
/*    e..e	101  (4..)	111111 111111	8b(add) 8b(POSLO)	DLZ*/
static int LenDLz(int lzlen, int lzpos) {
    return escBits + 2*maxGamma + 8 + 8 + LenValue(lzlen-1);
}

static int OutputDLz(int *esc, int lzlen, int lzpos, int add) {
    PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */

    PutValue(lzlen-1);
    PutValue((2<<maxGamma)-1);	/* Maximum value */
    PutNBits(add, 8);
    PutNBits(((lzpos-1) & 0xff) ^ 0xff, 8);

    gainedDLz += 8*lzlen -(escBits + LenValue(lzlen-1) + 2*maxGamma + 16);
    timesDLz++;
    return 4;
}
#endif


static int LenLz(int lzlen, int lzpos) {
    if (lzlen==2) {
#if 0
	if (lzpos <= 16)
	    return escBits + 2 + 5;
	if (lzpos <= 128)
	    return escBits + 2 + 8;
#else
	if (lzpos <= 256)
	    return escBits + 2 + 8;
#endif
	return 100000;
    }

    return escBits + 8 + extraLZPosBits +
		LenValue(((lzpos-1)>>(8+extraLZPosBits))+1) +
		LenValue(lzlen-1);
}


static int OutputLz(int *esc, int lzlen, int lzpos, char *data, int curpos) {
    if (lzlen==2)
	lenStat[0][1]++;
    else if (lzlen<=4)
	lenStat[1][1]++;
    else if (lzlen<=8)
	lenStat[2][1]++;
    else if (lzlen<=16)
	lenStat[3][1]++;
    else if (lzlen<=32)
	lenStat[4][1]++;
    else if (lzlen<=64)
	lenStat[5][1]++;
    else if (lzlen<=128)
	lenStat[6][1]++;
    else if (lzlen<=256)
	lenStat[7][1]++;

    if (lzlen >= 2 && lzlen <= maxlzlen) {
	int tmp;

	PutNBits((*esc>>(8-escBits)), escBits);	/* escBits>=0 */

	tmp = ((lzpos-1)>>(8+extraLZPosBits))+2;
	if (tmp==2)
	    lenStat[0][0]++;
	else if (tmp<=4)
	    lenStat[1][0]++;
	else if (tmp<=8)
	    lenStat[2][0]++;
	else if (tmp<=16)
	    lenStat[3][0]++;
	else if (tmp<=32)
	    lenStat[4][0]++;
	else if (tmp<=64)
	    lenStat[5][0]++;
	else if (tmp<=128)
	    lenStat[6][0]++;
	else if (tmp<=256)
	    lenStat[6][0]++;

	if (lzlen==2) {
	    PutValue(lzlen-1);
	    PutBit(0);
	    if (lzpos > 256)
		fprintf(stderr,
			"Error at %d: lzpos too long (%d) for lzlen==2\n",
			curpos, lzpos);
#if 0
	    if (lzpos <= 16) {
		PutBit(0);
		PutNBits(((lzpos-1) & 0xff) ^ 0xff, 4);
	    } else {
		PutBit(1);
		PutNBits(((lzpos-1) & 0xff) ^ 0xff, 8);
	    }
#else
	    PutNBits(((lzpos-1) & 0xff) ^ 0xff, 8);
#endif
	} else {
	    PutValue(lzlen-1);
	    PutValue( ((lzpos-1) >> (8+extraLZPosBits)) +1);
	    PutNBits( ((lzpos-1) >> 8), extraLZPosBits);
	    PutNBits(((lzpos-1) & 0xff) ^ 0xff, 8);
	}

	gainedLz += 8*lzlen -LenLz(lzlen, lzpos);
	timesLz++;
	return 3;
    }
    fprintf(stderr, "Error: lzlen too short/long (%d)\n", lzlen);
    return lzlen;
}



static unsigned short *rle, *elr, *lzlen, *lzpos, *lzmlen, *lzmpos;
#ifdef DELTA
static unsigned short *lzlen2, *lzpos2;
#endif
static int *length, inlen;
static unsigned char *indata, *mode, *newesc;
unsigned short *backSkip;


enum MODE {
    LITERAL = 0,
    LZ77 = 1,
    RLE = 2,
#ifdef DELTA
    DLZ = 3,
#endif
    MMARK = 4
};

static int lzopt = 0;
/* Non-recursive version */
/* NOTE! IMPORTANT! the "length" array length must be inlen+1 */

int OptimizeLength(int optimize) {
    int i;

    length[inlen] = 0;		/* one off the end, our 'target' */
    for (i=inlen-1; i>=0; i--) {
    	int r1 = 8 + length[i+1], r2, r3;

	if (!lzlen[i] && !rle[i]
#ifdef DELTA
		&& (!lzlen2 || !lzlen2[i])
#endif
	) {
	    length[i] = r1;
	    mode[i] = LITERAL;
	    continue;
	}

	/* If rle>maxlzlen, skip to the start of the rle-maxlzlen.. */
	if (rle[i] > maxlzlen && elr[i] > 1) {
	    int z = elr[i];

	    i -= elr[i];

	    r2 = LenRle(rle[i], indata[i]) + length[i+ rle[i]];
	    if (optimize) {
		int ii, mini = rle[i], minv = r2;

		int bot = rle[i] - (1<<maxGamma);
		if (bot < 2)
		    bot = 2;

		for (ii=mini-1; ii>=bot; ii--) {
		    int v = LenRle(ii, indata[i]) + length[i + ii];
		    if (v < minv) {
			minv = v;
			mini = ii;
		    }
		}
		if (minv != r2) {
		    lzopt += r2 - minv;
		    rle[i] = mini;
		    r2 = minv;
		}
	    }
	    length[i] = r2;
	    mode[i] = RLE;

	    for (; z>=0; z--) {
		length[i+z] = r2;
		mode[i+z] = RLE;
	    }
	    continue;
	}
	r3 = r2 = r1 + 1000; /* r3 >= r2 > r1 */

	if (rle[i]) {
	    r2 = LenRle(rle[i], indata[i]) + length[i+ rle[i]];

	    if (optimize) {
		int ii, mini = rle[i], minv = r2;

#if 0
		int bot = rle[i] - (1<<maxGamma);
		if (bot < 2)
		    bot = 2;

		for (ii=mini-1; ii>=bot; ii--) {
		    int v = LenRle(ii, indata[i]) + length[i + ii];
		    if (v < minv) {
			minv = v;
			mini = ii;
		    }
		}
#else
		/* Check only the original length and all shorter
		   lengths that are power of two.

		   Does not really miss many 'minimums' this way,
		   at least not globally..

		   Makes the assumption that the Elias Gamma Code is
		   used, i.e. values of the form 2^n are 'optimal' */
		ii = 2;
		while (rle[i] > ii) {
		    int v = LenRle(ii, indata[i]) + length[i + ii];
		    if (v < minv) {
			minv = v;
			mini = ii;
		    }
		    ii <<= 1;
		}
#endif
		if (minv != r2) {
/*printf("%05d RL %d %d\n", i, rle[i], mini);*/
		    lzopt += r2 - minv;
		    rle[i] = mini;
		    r2 = minv;
		}
	    }
	}
	if (lzlen[i]) {
	    r3 = LenLz(lzlen[i], lzpos[i]) + length[i + lzlen[i]];

	    if (optimize && lzlen[i]>2) {
		int ii, mini = lzlen[i], minv = r3, mino = lzpos[i];
		int topLen = LenLz(lzlen[i], lzpos[i])
		    - LenValue(lzlen[i]-1);

#if 0
		int bot = 3;
		if (lzpos[i] <= 256)
		    bot = 2;

		for (ii=mini-1; ii>=bot; ii--) {
		    int v = topLen + LenValue(ii-1) + length[i + ii];
		    if (v < minv) {
			minv = v;
			mini = ii;
		    }
		}
#else
		/* Check only the original length and all shorter
		   lengths that are power of two.

		   Does not really miss many 'minimums' this way,
		   at least not globally..

		   Makes the assumption that the Elias Gamma Code is
		   used, i.e. values of the form 2^n are 'optimal' */
		ii = 4;
		while (lzlen[i] > ii) {
		    int v = topLen + LenValue(ii-1) + length[i + ii];
		    if (v < minv) {
			minv = v;
			mini = ii;
		    }
		    ii <<= 1;
		}

		/* Then check the max lengths we have found, but
		   did not originally approve because they seemed
		   to gain less than the shorter, nearer matches. */
		ii = 3;
		while (lzmlen[i] >= ii) {
		    int v = LenLz(ii, lzmpos[i]) + length[i + ii];
		    if (v < minv) {
			minv = v;
			mini = ii;
			mino = lzmpos[i];
		    }
		    ii++;
		}
#endif
#ifdef BACKSKIP_FULL
		/*
		  Note:
		  2-byte optimization checks are no longer done
		  with the rest, because the equation gives too long
		  code lengths for 2-byte matches if extraLzPosBits>0.
		  */
		/* Two-byte rescan/check */
		if (backSkip[i] && backSkip[i] <= 256) {
		    /* There are previous occurrances (near enough) */
		    int v = LenLz(2, (int)backSkip[i]) + length[i + 2];

		    if (v < minv) {
			minv = v;
			mini = 2;
			lzlen[i] = mini;
			r3 = minv;
			lzpos[i] = (int)backSkip[i];
		    }
		}
#endif /* BACKSKIP_FULL */
		if (minv != r3 && minv < r2) {
                    /*
		      printf("@%05d LZ %d %4x -> %d %4x\n",
		      i, lzlen[i], lzpos[i], mini, lzpos[i]);
		      */
		    lzopt += r3 - minv;
		    lzlen[i] = mini;
		    lzpos[i] = mino;
		    r3 = minv;
		}
	    }
	}

	if (r2 <= r1) {
	    if (r2 <= r3) {
		length[i] = r2;
		mode[i] = RLE;
	    } else {
		length[i] = r3;
		mode[i] = LZ77;
	    }
	} else {
	    if (r3 <= r1) {
		length[i] = r3;
		mode[i] = LZ77;
	    } else {
		length[i] = r1;
		mode[i] = LITERAL;
	    }
	}
#ifdef DELTA
	if (lzlen2 && lzlen2[i] > 3) {
	    r3 = LenDLz(lzlen2[i], lzpos2[i]) + length[i + lzlen2[i]];
	    if (r3 < length[i]) {
		length[i] = r3;
		mode[i] = DLZ;
	    }
	}
#endif
    }
    return length[0];
}


/*
    The algorithm in the OptimizeEscape() works as follows:
    1) Only unpacked bytes are processed, they are marked
       with MMARK. We proceed from the end to the beginning.
       Variable A (old/new length) is updated.
    2) At each unpacked byte, one and only one possible
       escape matches. A new escape code must be selected
       for this case. The optimal selection is the one which
       provides the shortest number of escapes to the end
       of the file,
	i.e. A[esc] = 1+min(A[0], A[1], .. A[states-1]).
       For other states A[esc] = A[esc];
       If we change escape in this byte, the new escape is
       the one with the smallest value in A.
    3) The starting escape is selected from the possibilities
       and mode 0 is restored to all mode 3 locations.

 */

int OptimizeEscape(int *startEscape, int *nonNormal) {
    int i, j, states = (1<<escBits);
    long minp = 0, minv = 0, other = 0;
    long a[256]; /* needs int/long */
    long b[256]; /* Remembers the # of escaped for each */
    int esc8 = 8-escBits;

    for (i=0; i<256; i++)
	b[i] = a[i] = -1;

    if (states>256) {
	fprintf(stderr, "Escape optimize: only 256 states (%d)!\n",
		states);
	return 0;
    }

    /* Mark those bytes that are actually outputted */
    for (i=0; i<inlen; ) {
	switch (mode[i]) {
#ifdef DELTA
	case DLZ:
	    other++;
	    i += lzlen2[i];
	    break;
#endif

	case LZ77:
	    other++;
	    i += lzlen[i];
	    break;

	case RLE:
	    other++;
	    i += rle[i];
	    break;

	/*case LITERAL:*/
	default:
	    mode[i++] = MMARK; /* mark it used so we can identify it */
	    break;
	}
    }

    for (i=inlen-1; i>=0; i--) {
	/* Using a table to skip non-normal bytes does not help.. */
	if (mode[i] == MMARK) {
	    int k = (indata[i] >> esc8);

	    /* Change the tag values back to normal */
	    mode[i] = LITERAL;

	    /*
		k are the matching bytes,
		minv is the minimum value,
		minp is the minimum index
	     */

	    newesc[i] = (minp << esc8);
	    a[k] = minv + 1;
	    b[k] = b[minp] + 1;
	    if (k==minp) {
		/* Minimum changed -> need to find a new minimum */
		/* a[k] may still be the minimum */
		minv++;
		for (k=states-1; k>=0; k--) {
		    if (a[k] < minv) {
			minv = a[k];
			minp = k;
			/*
			    There may be others, but the first one that
			    is smaller than the old minimum is equal to
			    any other new minimum.
			 */
			break;
		    }
		}
	    }
	}
    }

    /* Select the best value for the initial escape */
    if (startEscape) {
	i = inlen;	/* make it big enough */
	for (j=states-1; j>=0; j--) {
	    if (a[j] <= i) {
		*startEscape = (j << esc8);
		i = a[j];
	    }
	}
    }
    if (nonNormal)
	*nonNormal = other;
    return b[startEscape ? (*startEscape>>esc8) : 0];
}


/* Initialize the RLE byte code table according to all RLE's found so far */
/* O(n) */
void InitRle(int);
void InitRle(int flags) {
    int p, mr, mv, i;

    for (i=1; i<16/*32*/; i++) {
	mr = -1;
	mv = 0;

	for (p=0; p<256; p++) {
	    if (rleHist[p] > mv) {
		mv = rleHist[p];
		mr = p;
	    }
	}
	if (mv>0) {
	    rleValues[i] = mr;
	    rleHist[mr] = -1;
	} else
	    break;
    }
    InitRleLen();
}


/* Initialize the RLE byte code table according to RLE's actually used */
/* O(n) */
void OptimizeRle(int);
void OptimizeRle(int flags) {
    int p, mr, mv, i;

    if ((flags & F_NORLE)) {
	rleUsed = 0;
	return;
    }
    if ((flags & F_STATS))
	fprintf(stderr, "RLE Byte Code Re-Tune, RLE Ranks:\n");
    for (p=0; p<256; p++)
	rleHist[p] = 0;

    for (p=0; p<inlen; ) {
	switch (mode[p]) {
#ifdef DELTA
	case DLZ: /* lz */
	    p += lzlen2[p];
	    break;
#endif
	case LZ77: /* lz */
	    p += lzlen[p];
	    break;

	case RLE: /* rle */
	    rleHist[indata[p]]++;
	    p += rle[p];
	    break;

    /*  case LITERAL:
	case MMARK:*/
	default:
	    p++;
	    break;
	}
    }

    for (i=1; i<16 /*32*/; i++) {
	mr = -1;
	mv = 0;

	for (p=0; p<256; p++) {
	    if (rleHist[p] > mv) {
		mv = rleHist[p];
		mr = p;
	    }
	}
	if (mv>0) {
	    rleValues[i] = mr;
	    if ((flags & F_STATS)) {
		fprintf(stderr, " %2d.0x%02x %-3d ", i, mr, mv);
		if (!((i - 1) % 6))
		    fprintf(stderr, "\n");
	    }
	    rleHist[mr] = -1;
	} else
	    break;
    }
    rleUsed = i-1;

    if ((flags & F_STATS))
	if (((i - 1) % 6)!=1)
	    fprintf(stderr, "\n");
    InitRleLen();
}


static const unsigned char *up_Data;
static int up_Mask, up_Byte;
void up_SetInput(const unsigned char *data) {
    up_Data = data;
    up_Mask = 0x80;
    up_Byte = 0;
}
int up_GetBits(int bits) {
    int val = 0;

    while (bits--) {
	val <<= 1;
	if ((*up_Data & up_Mask))
	   val |= 1;
	up_Mask >>= 1;
	if (!up_Mask) {
	    up_Mask = 0x80;
	    up_Data++;
	    up_Byte++;
	}
    }
    return val;
}
int up_GetValue(void) {
    int i = 0;

    while (i<maxGamma) {
	if (!up_GetBits(1))
	    break;
	i++;
    }
    return (1<<i) | up_GetBits(i);
}


int UnPack(int loadAddr, const unsigned char *data, const char *file,
	   int flags) {
    long size, startEsc, endAddr, execAddr, headerSize;
    long startAddr, error = 0;
    FILE *fp;
    int i, overlap;
    long timeused = clock();
    const char *byteCodeVec;
#define MAXCODES 20
    int mismatch[MAXCODES], collect[ftEnd];
    struct FixStruct *dc;

    /* Search for the right code */
    if (data[0] == 'p' && data[1] == 'u') {
	/* was saved without decompressor */
	int cnt = 2;

	endAddr = (data[cnt] | (data[cnt+1]<<8)) + 0x100;
	cnt += 2;

	startEsc = data[cnt++];
	startAddr = data[cnt] | (data[cnt+1] << 8);
	cnt += 2;

	escBits = data[cnt++];
	if (escBits < 0 || escBits > 8) {
	    fprintf(stderr, "Error: Broken archive, escBits %d.\n",
		    escBits);
	    return 20;
	}
	maxGamma = data[cnt++] - 1;
	if (data[cnt++] != (1<<maxGamma) ||
	   maxGamma < 5 || maxGamma > 7) {
	    fprintf(stderr, "Error: Broken archive, maxGamma %d.\n",
		    maxGamma);
	    return 20;
	}
    lrange = LRANGE;
    maxlzlen = MAXLZLEN;
    maxrlelen = MAXRLELEN;

	extraLZPosBits = data[cnt++];
	if (extraLZPosBits < 0 || extraLZPosBits > 4) {
	    fprintf(stderr, "Error: Broken archive, extraLZPosBits %d.\n",
		    extraLZPosBits);
	    return 20;
	}

	execAddr = data[cnt] | (data[cnt+1]<<8);
	cnt += 2;

	rleUsed = data[cnt++];
	byteCodeVec = (const char *) &data[cnt - 1];

	overlap = 0;
	//memConfig = memConfig;
	//intConfig = intConfig;

	size = endAddr-startAddr;
	headerSize = cnt + rleUsed;

	endAddr = loadAddr + size;

    } else {

	for (i=0; fixStruct[i].code && i < MAXCODES; i++) {
	    int j, maxDiff = 0;

	    if (fixStruct[i].code[1] != (loadAddr>>8))
		maxDiff = 5;
	    for (j=0; fixStruct[i].fixes[j].type != ftEnd; j++) {
		maxDiff++;
	    }
	    mismatch[i] = 0;
	    for (j=2; j<fixStruct[i].codeSize-15; j++) {
		if (fixStruct[i].code[j] != data[j-2])
		    mismatch[i]++;
	    }
	    if (mismatch[i] <= maxDiff) {
		fprintf(stderr, "Detected %s (%d <= %d)\n",
			fixStruct[i].name, mismatch[i], maxDiff);
		break;
	    }
	    fprintf(stderr, "Not %s (%d > %d)\n",
		    fixStruct[i].name, mismatch[i], maxDiff);
	}
	dc = &fixStruct[i];
	if (!dc->code) {
	    fprintf(stderr,
		    "Error: The file is not compressed with this program.\n");
	    return 20;
	}

	if ((loadAddr & 0xff) != 1) {
	    fprintf(stderr, "Error: Misaligned basic start address 0x%04x\n",
		    loadAddr);
	    return 20;
	}
	/* TODO: check that the decrunch code and load address match. */

	error = 0;

	for (i=0; i<ftEnd; i++) {
	    collect[i] = 0;
	}
	collect[ftMemConfig] = memConfig;
	collect[ftCli] = intConfig;
	for (i=0; dc->fixes[i].type!=ftEnd; i++) {
	    collect[dc->fixes[i].type] = data[dc->fixes[i].offset-2];
	}

	overlap = collect[ftOverlap];
	/* TODO: check overlap LO/HI and WrapCount */
	maxGamma = collect[ftMaxGamma] - 1;
	if (maxGamma < 5 || maxGamma > 7) {
	    fprintf(stderr, "Error: Broken archive, maxGamma %d.\n",
		    maxGamma);
	    return 20;
	}
    lrange = LRANGE;
    maxlzlen = MAXLZLEN;
    maxrlelen = MAXRLELEN;

	if (collect[ft1MaxGamma] != (1<<maxGamma) ||
	    collect[ft8MaxGamma] != (8-maxGamma) ||
	    collect[ft2MaxGamma] != (2<<maxGamma)-1) {
	    fprintf(stderr,
		    "Error: Broken archive, maxGamma (%d) mismatch.\n",
		    maxGamma);
	    return 20;
	}

	startEsc = collect[ftEscValue];
	startAddr = collect[ftOutposLo] | (collect[ftOutposHi]<<8);
	escBits = collect[ftEscBits];
	if (escBits < 0 || escBits > 8) {
	    fprintf(stderr, "Error: Broken archive, escBits %d.\n",
		    escBits);
	    return 20;
	}

	if (collect[ftEsc8Bits] != 8-escBits) {
	    fprintf(stderr, "Error: Broken archive, escBits (%d) mismatch.\n",
		    escBits);
	    return 20;
	}

	extraLZPosBits = collect[ftExtraBits];
	if (extraLZPosBits < 0 || extraLZPosBits > 4) {
	    fprintf(stderr, "Error: Broken archive, extraLZPosBits %d.\n",
		    extraLZPosBits);
	    return 20;
	}
	endAddr = 0x100 + (collect[ftEndLo] | (collect[ftEndHi]<<8));
	size    = endAddr - (collect[ftInposLo] | (collect[ftInposHi]<<8));
	headerSize = ((collect[ftSizeLo] | (collect[ftSizeHi]<<8))
			+ 0x100 - size - loadAddr) & 0xffff;
	execAddr = collect[ftExecLo] | (collect[ftExecHi]<<8);

	memConfig = collect[ftMemConfig];
	intConfig = collect[ftCli];
	byteCodeVec = (const char *) &data[dc->codeSize - 32 -2];

	rleUsed = 15 - dc->codeSize +2 + headerSize;
    }


    if ((flags & F_STATS)) {
	fprintf(stderr,
		"Load 0x%04x, Start 0x%04lx, exec 0x%04lx, %s%s$01=$%02x\n",
		loadAddr, startAddr, execAddr,
		(intConfig==0x58)?"cli, ":"", (intConfig==0x78)?"sei, ":"",
		memConfig);
	fprintf(stderr, "Escape bits %d, starting escape 0x%02lx\n",
		escBits, (startEsc<<(8-escBits)));
	fprintf(stderr,
		"Decompressor size %ld, max length %d, LZPOS LO bits %d\n",
		headerSize+2, (2<<maxGamma), extraLZPosBits+8);
	fprintf(stderr, "rleUsed: %d\n", rleUsed);
    }

    if (rleUsed > 15) {
	fprintf(stderr, "Error: Old archive, rleUsed %d > 15.\n", rleUsed);
	return 20;
    }

    outPointer = 0;
    up_SetInput(data + headerSize);
    while (!error) {
	int sel = startEsc;

#ifndef BIG
	if (startAddr + outPointer >= up_Byte + endAddr - size) {
	    if (!error)
		fprintf(stderr, "Error: Target %5ld exceeds source %5ld..\n",
			startAddr + outPointer, up_Byte + endAddr - size);
	    error++;
	}
	if (up_Byte > size + overlap) {
	    fprintf(stderr, "Error: No EOF symbol found (%d > %d).\n",
		    up_Byte, (int) (size + overlap));
	    error++;
	}
#endif /* BIG */

	if (escBits)
	    sel = up_GetBits(escBits);
	if (sel == startEsc) {
	    int lzPos, lzLen = up_GetValue(), i;
#ifdef DELTA
	    int add = 0;
#endif

	    if (lzLen != 1) {
		int lzPosHi = up_GetValue()-1, lzPosLo;

		if (lzPosHi == (2<<maxGamma)-2) {
#ifdef DELTA
/* asm: 25 bytes longer */
		    if (lzLen > 2) {
			add = up_GetBits(8);
			lzPos = up_GetBits(8) ^ 0xff;
		    } else
#endif
		    break; /* EOF */
		} else {
		    if (extraLZPosBits) {
			lzPosHi = (lzPosHi<<extraLZPosBits) |
				    up_GetBits(extraLZPosBits);
		    }
		    lzPosLo = up_GetBits(8) ^ 0xff;
		    lzPos = (lzPosHi<<8) | lzPosLo;
		}
	    } else {
		if (up_GetBits(1)) {
		    int rleLen, byteCode, byte;

		    if (!up_GetBits(1)) {
			int newEsc = up_GetBits(escBits);

			outBuffer[outPointer++] =
			    (startEsc<<(8-escBits)) | up_GetBits(8-escBits);
/*fprintf(stdout, "%5ld %5ld  *%02x\n",
	outPointer-1, up_Byte, outBuffer[outPointer-1]);*/
			startEsc = newEsc;
			if (outPointer >= OUT_SIZE) {
			    fprintf(stderr, "Error: Broken archive, "
				    "output buffer overrun at %d.\n",
				    outPointer);
			    return 20;
			}
			continue;
		    }
		    rleLen = up_GetValue();
		    if (rleLen >= (1<<maxGamma)) {
			rleLen = ((rleLen-(1<<maxGamma))<<(8-maxGamma)) |
			    up_GetBits(8-maxGamma);
			rleLen |= ((up_GetValue()-1)<<8);
		    }
		    byteCode = up_GetValue();
		    if (byteCode < 16/*32*/) {
			byte = byteCodeVec[byteCode];
		    } else {
			byte = ((byteCode-16/*32*/)<<4/*3*/) | up_GetBits(4/*3*/);
		    }

/*fprintf(stdout, "%5ld %5ld RLE %5d 0x%02x\n", outPointer, up_Byte, rleLen+1,
	byte);*/
		    if (outPointer + rleLen + 1 >= OUT_SIZE) {
			fprintf(stderr, "Error: Broken archive, "
				"output buffer overrun at %d.\n",
				OUT_SIZE);
			return 20;
		    }
		    for (i=0; i<=rleLen; i++) {
			outBuffer[outPointer++] = byte;
		    }
		    continue;
		}
		lzPos = up_GetBits(8) ^ 0xff;
	    }
/*fprintf(stdout, "%5ld %5ld LZ %3d 0x%04x\n",
	outPointer, up_Byte, lzLen+1, lzPos+1);*/

	    /* outPointer increases in the loop, thus its minimum is here */
	    if (outPointer - lzPos -1 < 0) {
		fprintf(stderr, "Error: Broken archive, "
			"LZ copy position underrun at %d (%d). "
			"lzLen %d.\n",
			outPointer, lzPos+1, lzLen+1);
		return 20;
	    }
	    if (outPointer + lzLen + 1 >= OUT_SIZE) {
		fprintf(stderr, "Error: Broken archive, "
			"output buffer overrun at %d.\n",
			OUT_SIZE);
		return 20;
	    }
	    for (i=0; i<=lzLen; i++) {
		outBuffer[outPointer] = outBuffer[outPointer - lzPos - 1]
#ifdef DELTA
					DELTA_OP add;
#else
					;
#endif
		outPointer++;
	    }
	} else {
	    int byte = (sel<<(8-escBits)) | up_GetBits(8-escBits);
/*fprintf(stdout, "%5ld %5ld  %02x\n",
	outPointer, up_Byte, byte);*/
	    outBuffer[outPointer++] = byte;
	    if (outPointer >= OUT_SIZE) {
		fprintf(stderr, "Error: Broken archive, "
			"output buffer overrun at %d.\n",
			outPointer);
		return 20;
	    }
	}
    }
    if (error)
	fprintf(stderr, "Error: Target exceeded source %5ld times.\n",
		error);

    if ((file && (fp = fopen(file, "wb"))) || (fp = stdout)) {
	unsigned char tmp[2];
	tmp[0] = startAddr & 0xff;
	tmp[1] = (startAddr >> 8);

	fwrite(tmp, 2, 1, fp);
	fwrite(outBuffer, outPointer, 1, fp);
	if (fp != stdout)
	    fclose(fp);

	timeused = clock() - timeused;
	if (!timeused)
	    timeused++;	/* round upwards */
	fprintf(stderr,
		"Decompressed %d bytes in %4.2f seconds (%4.2f kB/s)\n",
		outPointer,
		(double)timeused/CLOCKS_PER_SEC,
		(double)CLOCKS_PER_SEC*outPointer/timeused/1024.0);

	return error;
    }
    fprintf(stderr, "Could not open file \"%s\" for writing.\n", file);
    return 20;
}



int PackLz77(int lzsz, int flags, int *startEscape,
	     int endAddr, int memEnd, int type) {
    int i, j, outlen, p, headerSize;
    int escape;
#ifdef HASH_COMPARE
    unsigned char *hashValue;
    unsigned char *a;
    int k;
#endif /* HASH_COMPARE */

#ifdef BIG
    unsigned int *lastPair;
#else
    unsigned short *lastPair;
#endif /* BIG */

#ifdef BACKSKIP_FULL
#ifdef RESCAN
    int rescan = 0;
#endif /* RESCAN */
#endif /* BACKSKIP_FULL */

#ifdef HASH_STAT
    unsigned long compares = 0, hashChecks = 0, hashEqual = 0;
#endif /* HASH_STAT */

    if (lzsz < 0 || lzsz > lrange) {
	fprintf(stderr, "LZ range must be from 0 to %d (was %d). Set to %d.\n",
		lrange, lzsz, lrange);
	lzsz = lrange;
    }
    if (lzsz > 65535) {
	fprintf(stderr,
		"LZ range must be from 0 to 65535 (was %d). Set to 65535.\n",
		lzsz);
	lzsz = 65535;
    }
    if (!lzsz)
	fprintf(stderr, "Warning: zero LZ range. Only RLE packing used.\n");

    InitRleLen();
    length = (int *)calloc(sizeof(int), inlen + 1);
    mode   = (unsigned char *)calloc(sizeof(unsigned char), inlen);
    rle    = (unsigned short *)calloc(sizeof(unsigned short), inlen);
    elr    = (unsigned short *)calloc(sizeof(unsigned short), inlen);
    lzlen  = (unsigned short *)calloc(sizeof(unsigned short), inlen);
    lzpos  = (unsigned short *)calloc(sizeof(unsigned short), inlen);
    lzmlen = (unsigned short *)calloc(sizeof(unsigned short), inlen);
    lzmpos = (unsigned short *)calloc(sizeof(unsigned short), inlen);
#ifdef DELTA
    if ((type & FIXF_DLZ)) {
	lzlen2  = (unsigned short *)calloc(sizeof(unsigned short), inlen);
	lzpos2  = (unsigned short *)calloc(sizeof(unsigned short), inlen);
    } else {
	lzlen2 = lzpos2 = NULL;
    }
#endif
    newesc = (unsigned char *)calloc(sizeof(unsigned char), inlen);
#ifdef BACKSKIP_FULL
    backSkip  = (unsigned short *)calloc(sizeof(unsigned short), inlen);
#else
    backSkip  = (unsigned short *)calloc(sizeof(unsigned short), 65536);
#endif /* BACKSKIP_FULL */
#ifdef HASH_COMPARE
    hashValue = (unsigned char *)malloc(inlen);
#endif /* HASH_COMPARE */
#ifdef BIG
    lastPair  = (unsigned int *)calloc(sizeof(unsigned int), 256*256);
#else
    lastPair  = (unsigned short *)calloc(sizeof(unsigned short), 256*256);
#endif /* BIG */


    /* error checking */
    if (!length || !mode || !rle || !elr || !lzlen || !lzpos ||
	!lzmlen || !lzmpos || !newesc || !lastPair || !backSkip
#ifdef DELTA
	|| ((type & FIXF_DLZ) && (!lzlen2 || !lzpos2))
#endif
#ifdef HASH_COMPARE
	|| !hashValue
#endif /* HASH_COMPARE */
	) {
	fprintf(stderr, "Memory allocation failed!\n");
	goto errorexit;
    }

#ifdef HASH_COMPARE
    i = 0;
    j = 0;
    a = indata + inlen;
    for (p=inlen-1; p>=0; p--) {
	k = j;
	j = i;
	i = *--a;	/* Only one read per position */

	/* Without hash: 18.56%, end+middle: 12.68% */
	/* hashValue[p] = i*2 ^ j*3 ^ k*5; */ /* 8.56% */
	/* hashValue[p] = i ^ j*2 ^ k*3; */   /* 8.85% */
	/* hashValue[p] = i + j + k; */       /* 9.33% */
	/* hashValue[p] = i + j*2 + k*3; */   /* 8.25% */
	/* hashValue[p] = i*2 + j*3 + k*5; */ /* 8.29% */
	/* hashValue[p] = i*3 + j*5 + k*7; */ /* 7.95% */
	hashValue[p] = i*3 + j*5 + k*7; /* 7.95 % */
    }
#endif /* HASH_COMPARE */
    /* Detect all RLE and LZ77 jump possibilities */
    for (p=0; p<inlen; p++) {
#ifndef BIG
	if (!(p & 2047)) {
	    fprintf(stderr, "\r%d ", p);
	    fflush(stderr);	/* for SAS/C */
	}
#endif /* BIG */
	/* check run-length code - must be done, LZ77 search needs it! */
	if (rle[p] <= 0) {
	    /*
		There are so few RLE's and especially so few
		long RLE's that byte-by-byte is good enough.
	     */
	    unsigned char *a = indata + p;
	    int val = *a++; /* if this were uchar, it would go to stack..*/
	    int top = inlen - p;
	    int rlelen = 1;

	    /* Loop for the whole RLE */
	    while (rlelen<top && *a++ == (unsigned char)val
#ifdef BIG
		  && rlelen < 65535
#endif /* BIG */
		 ) {
		rlelen++;
	    }
#ifdef HASH_STAT
	    compares += rlelen;
#endif /* HASH_STAT */

	    if (rlelen>=2) {
		rleHist[indata[p]]++;

		for (i=rlelen-1; i>=0; i--) {
		    rle[p+i] = rlelen-i;
		    elr[p+i] = i;	/* For RLE backward skipping */
		}
#if 0
		if (rlelen>maxlzlen) {
		    /* Jump over some unnecessary memory references */
		    p += rlelen - maxlzlen - 1;
		    continue;
		}
#endif
	    }
	}

	/* check LZ77 code */
	if (p+rle[p]+1<inlen) {
	    int bot = p - lzsz, maxval, maxpos, rlep = rle[p];
#ifdef HASH_COMPARE
	    unsigned char hashCompare = hashValue[p];
#else
	    unsigned char valueCompare = indata[p+2];
#endif /* HASH_COMPARE */

	    /*
		There's always 1 equal byte, although it may
		not be marked as RLE.
	     */
	    if (rlep <= 0)
		rlep = 1;
	    if (bot < 0)
		bot = 0;
	    bot += (rlep-1);

	    /*
		First get the shortest possible match (if any).
		If there is no 2-byte match, don't look further,
		because there can't be a longer match.
	     */
	    i = (int)lastPair[ (indata[p]<<8) | indata[p+1] ] -1;
	    if (i>=0 && i>=bot) {
		/* Got a 2-byte match at least */
		maxval = 2;
		maxpos = p-i;

		/*
		    A..AB	rlep # of A's, B is something else..

		    Search for bytes that are in p + (rlep-1), i.e.
		    the last rle byte ('A') and the non-matching one
		    ('B'). When found, check if the rle in the compare
		    position (i) is long enough (i.e. the same number
		    of A's at p and i-rlep+1).

		    There are dramatically less matches for AB than for
		    AA, so we get a huge speedup with this approach.
		    We are still guaranteed to find the most recent
		    longest match there is.
		 */

		i = (int)lastPair[(indata[p+(rlep-1)]<<8) | indata[p+rlep]] -1;
		while (i>=bot /* && i>=rlep-1 */) {   /* bot>=rlep-1, i>=bot  ==> i>=rlep-1 */

		    /* Equal number of A's ? */
		    if (!(rlep-1) || rle[i-(rlep-1)]==rlep) {	/* 'head' matches */
			/* rlep==1 ==> (rlep-1)==0 */
			/* ivanova.run: 443517 rlep==1,
			   709846 rle[i+1-rlep]==rlep */

			/*
			    Check the hash values corresponding to the last
			    two bytes of the currently longest match and
			    the first new matching(?) byte. If the hash
			    values don't match, don't bother to check the
			    data itself.
			 */
#ifdef HASH_STAT
			hashChecks++;
#endif /* HASH_STAT */
			if (
#ifdef HASH_COMPARE
			    hashValue[i+maxval-rlep-1] == hashCompare
#else
			    indata[i+maxval-rlep+1] == valueCompare
#endif /* HASH_COMPARE */
			   ) {
			    unsigned char *a = indata + i+2;	/* match  */
			    unsigned char *b = indata + p+rlep-1+2;/* curpos */
			    int topindex = inlen-(p+rlep-1);

			    /* the 2 first bytes ARE the same.. */
			    j = 2;
			    while (j < topindex && *a++==*b++)
				j++;

#ifdef HASH_STAT
			    hashEqual++;
			    compares += j - 1;
#endif /* HASH_STAT */
			    if (j + rlep-1 > maxval) {
				int tmplen = j+rlep-1, tmppos = p-i+rlep-1;

				if (tmplen > maxlzlen)
				    tmplen = maxlzlen;

				if (lzmlen[p] < tmplen) {
				    lzmlen[p] = tmplen;
				    lzmpos[p] = tmppos;
				}
				/* Accept only versions that really are shorter */
				if (tmplen*8 - LenLz(tmplen, tmppos) >
				    maxval*8 - LenLz(maxval, maxpos)) {
				    maxval = tmplen;
				    maxpos = tmppos;
#ifdef HASH_COMPARE
				    hashCompare = hashValue[p+maxval-2];
#else
				    valueCompare = indata[p+maxval];
#endif /* HASH_COMPARE */
				}
#if 0
				else {
				    printf("@%5d %d*8 - LenLz(%d, %4x)==%d < ",
					   p, tmplen, tmplen, tmppos,
					   tmplen*8 - LenLz(tmplen, tmppos));
				    printf("%d*8 - LenLz(%d, %4x)==%d\n",
					   maxval, maxval, maxpos,
					   maxval*8 - LenLz(maxval, maxpos));
				}
#endif
				if (maxval == maxlzlen)
				    break;
			    }
			}
		    }
#ifdef BACKSKIP_FULL
		    if (!backSkip[i])
			break; /* No previous occurrances (near enough) */
		    i -= (int)backSkip[i];
#else
		    if (!backSkip[i & 0xffff])
			break; /* No previous occurrances (near enough) */
		    i -= (int)backSkip[i & 0xffff];
#endif /* BACKSKIP_FULL */
		}

		/*
		    If there is 'A' in the previous position also,
		    RLE-like LZ77 is possible, although rarely
		    shorter than real RLE.
		 */
		if (p && rle[p-1] > maxval) {
		    maxval = rle[p-1] - 1;
		    maxpos = 1;
		}
		/*
		    Last, try to find as long as possible match
		    for the RLE part only.
		 */
		if (maxval < maxlzlen && rlep > maxval) {
		    bot = p - lzsz;
		    if (bot < 0)
			bot = 0;

		    /* Note: indata[p] == indata[p+1] */
		    i = (int)lastPair[indata[p]*257] -1;
		    while (/* i>= rlep-2 &&*/ i>=bot) {
			if (elr[i] + 2 > maxval) {
			    maxval = min(elr[i] + 2, rlep);
			    maxpos = p - i + (maxval-2);
			    if(maxval == rlep)
				break; /* Got enough */
			}
			i -= elr[i];
#ifdef BACKSKIP_FULL
			if (!backSkip[i])
			    break; /* No previous occurrances (near enough) */
			i -= (int)backSkip[i];
#else
			if (!backSkip[i & 0xffff])
			    break; /* No previous occurrances (near enough) */
			i -= (int)backSkip[i & 0xffff];
#endif /* BACKSKIP_FULL */
		    }
		}
		if (p+maxval > inlen) {
		    fprintf(stderr,
			    "Error @ %d, lzlen %d, pos %d - exceeds inlen\n",
			    p, maxval, maxpos);
		    maxval = inlen - p;
		}
		if (lzmlen[p] < maxval) {
		    lzmlen[p] = maxval;
		    lzmpos[p] = maxpos;
		}
		if (maxpos<=256 || maxval > 2) {
		    if (maxpos < 0)
			fprintf(stderr, "Error @ %d, lzlen %d, pos %d\n",
				p, maxval, maxpos);
		    lzlen[p] = (maxval<maxlzlen)?maxval:maxlzlen;
		    lzpos[p] = maxpos;
		}
	    }
	}
#ifdef DELTA
	/* check LZ77 code again, ROT1..255 */
	if ((type & FIXF_DLZ) && /* rle[p]<maxlzlen && */ p+rle[p]+1<inlen) {
	int rot;

	for (rot = 1; rot < 255/*BUG:?should be 256?*/; rot++) {
	    int bot = p - /*lzsz*/256, maxval, maxpos, rlep = rle[p];
	    unsigned char valueCompare = (indata[p+2] DELTA_OP rot) & 0xff;

	    /*
		There's always 1 equal byte, although it may
		not be marked as RLE.
	     */
	    if (rlep <= 0)
		rlep = 1;
	    if (bot < 0)
		bot = 0;
	    bot += (rlep-1);

	    /*
		First get the shortest possible match (if any).
		If there is no 2-byte match, don't look further,
		because there can't be a longer match.
	     */
	    i = (int)lastPair[ (((indata[p] DELTA_OP rot) & 0xff)<<8) |
				((indata[p+1] DELTA_OP rot) & 0xff) ] -1;
	    if (i>=0 && i>=bot) {
		/* Got a 2-byte match at least */
		maxval = 2;
		maxpos = p-i;

		/*
		    A..AB	rlep # of A's, B is something else..

		    Search for bytes that are in p + (rlep-1), i.e.
		    the last rle byte ('A') and the non-matching one
		    ('B'). When found, check if the rle in the compare
		    position (i) is long enough (i.e. the same number
		    of A's at p and i-rlep+1).

		    There are dramatically less matches for AB than for
		    AA, so we get a huge speedup with this approach.
		    We are still guaranteed to find the most recent
		    longest match there is.
		 */

		i = (int)lastPair[(((indata[p+(rlep-1)] DELTA_OP rot) & 0xff)<<8) |
				   ((indata[p+rlep] DELTA_OP rot) & 0xff)] -1;
		while (i>=bot /* && i>=rlep-1 */) {   /* bot>=rlep-1, i>=bot  ==> i>=rlep-1 */

		    /* Equal number of A's ? */
		    if (!(rlep-1) || rle[i-(rlep-1)]==rlep) {	/* 'head' matches */
			/* rlep==1 ==> (rlep-1)==0 */
			/* ivanova.run: 443517 rlep==1,
			   709846 rle[i+1-rlep]==rlep */

			/*
			    Check the hash values corresponding to the last
			    two bytes of the currently longest match and
			    the first new matching(?) byte. If the hash
			    values don't match, don't bother to check the
			    data itself.
			 */
#ifdef HASH_STAT
			hashChecks++;
#endif /* HASH_STAT */
			if (indata[i+maxval-rlep+1] == valueCompare) {
			    unsigned char *a = indata + i+2;	/* match  */
			    unsigned char *b = indata + p+rlep-1+2;/* curpos */
			    int topindex = inlen-(p+rlep-1);

			    /* the 2 first bytes ARE the same.. */
			    j = 2;
			    while (j < topindex && *a++==((*b++ DELTA_OP rot) & 0xff))
				j++;

#ifdef HASH_STAT
			    hashEqual++;
			    compares += j - 1;
#endif /* HASH_STAT */
			    if (j + rlep-1 > maxval) {
				int tmplen = j+rlep-1, tmppos = p-i+rlep-1;

				if (tmplen > maxlzlen)
				    tmplen = maxlzlen;

				/* Accept only versions that really are shorter */
				if (tmplen*8 - LenLz(tmplen, tmppos) >
				    maxval*8 - LenLz(maxval, maxpos)) {
				    maxval = tmplen;
				    maxpos = tmppos;

				    valueCompare = (indata[p+maxval] DELTA_OP rot) & 0xff;
				}
#if 0
				else {
				    printf("@%5d %d*8 - LenLz(%d, %4x)==%d < ",
					   p, tmplen, tmplen, tmppos,
					   tmplen*8 - LenLz(tmplen, tmppos));
				    printf("%d*8 - LenLz(%d, %4x)==%d\n",
					   maxval, maxval, maxpos,
					   maxval*8 - LenLz(maxval, maxpos));
				}
#endif
				if (maxval == maxlzlen)
				    break;
			    }
			}
		    }
#ifdef BACKSKIP_FULL
		    if (!backSkip[i])
			break; /* No previous occurrances (near enough) */
		    i -= (int)backSkip[i];
#else
		    if (!backSkip[i & 0xffff])
			break; /* No previous occurrances (near enough) */
		    i -= (int)backSkip[i & 0xffff];
#endif /* BACKSKIP_FULL */
		}

		if (p+maxval > inlen) {
		    fprintf(stderr,
			    "Error @ %d, lzlen %d, pos %d - exceeds inlen\n",
			    p, maxval, maxpos);
		    maxval = inlen - p;
		}
		if (maxval > 3 && maxpos <= 256 &&
		    (maxval > lzlen2[p] ||
		     (maxval == lzlen2[p] && maxpos < lzpos2[p]))) {
		    if (maxpos < 0)
			fprintf(stderr, "Error @ %d, lzlen %d, pos %d\n",
				p, maxval, maxpos);
		    lzlen2[p] = (maxval<maxlzlen)?maxval:maxlzlen;
		    lzpos2[p] = maxpos;
		}
	    }
	}
	if (lzlen2[p] <= lzlen[p] || lzlen2[p] <= rle[p]) {
	    lzlen2[p] = lzpos2[p] = 0;
	}
	}
#endif

	/* Update the two-byte history ('hash table') &
	   backSkip ('linked list') */
	if (p+1<inlen) {
	    int index = (indata[p]<<8) | indata[p+1];
	    int ptr = p - (lastPair[index]-1);

	    if (ptr > p || ptr > 0xffff)
		ptr = 0;

#ifdef BACKSKIP_FULL
	    backSkip[p] = ptr;
#else
	    backSkip[p & 0xffff] = ptr;
#endif /* BACKSKIP_FULL */
	    lastPair[index] = p+1;
	}
    }
    if ((flags & F_NORLE)) {
	for (p=1; p<inlen; p++) {
	    if (rle[p-1]-1 > lzlen[p]) {
		lzlen[p] = (rle[p]<maxlzlen)?rle[p]:maxlzlen;
		lzpos[p] = 1;
	    }
	}
	for (p=0; p<inlen; p++) {
	    rle[p] = 0;
	}
    }
    fprintf(stderr, "\rChecked: %d \n", p);
    fflush(stderr);	/* for SAS/C */


    /* Initialize the RLE selections */
    InitRle(flags);

    /* Check the normal bytes / all ratio */
    if ((flags & F_AUTO)) {
	int mb, mv;

	fprintf(stderr, "Selecting the number of escape bits.. ");
	fflush(stderr);	/* for SAS/C */

	/*
	    Absolute maximum number of escaped bytes with
	    the escape optimize is 2^-n, where n is the
	    number of escape bits used.

	    This worst case happens only on equal-
	    distributed normal bytes (01230123..).
	    This is why the typical values are so much smaller.
	 */

	mb = 0;
	mv = 8*OUT_SIZE;
	for (escBits=1; escBits<9; escBits++) {
	    int escaped, other = 0, c;

	    escMask = (0xff00>>escBits) & 0xff;

	    /* Find the optimum path for selected escape bits (no optimize) */
	    OptimizeLength(0);

	    /* Optimize the escape selections for this path & escBits */
	    escaped = OptimizeEscape(&escape, &other);

	    /* Compare value: bits lost for escaping -- bits lost for prefix */
	    c = (escBits+3)*escaped + other*escBits;
	    if ((flags & F_STATS)) {
		fprintf(stderr, " %d:%d", escBits, c);
		fflush(stderr);	/* for SAS/C */
	    }
	    if (c < mv) {
		mb = escBits;
		mv = c;
	    } else {
		/* minimum found */
		break;
	    }
	    if (escBits==4 && (flags & F_STATS))
		fprintf(stderr, "\n");
	}
	if (mb==1) {	/* Minimum was 1, check 0 */
	    int escaped;

	    escBits = 0;
	    escMask = 0;

	    /* Find the optimum path for selected escape bits (no optimize) */
	    OptimizeLength(0);
	    /* Optimize the escape selections for this path & escBits */
	    escaped = OptimizeEscape(&escape, NULL);

	    if ((flags & F_STATS)) {
		fprintf(stderr, " %d:%d", escBits, 3*escaped);
		fflush(stderr);	/* for SAS/C */
	    }
	    if (3*escaped < mv) {
		mb = 0;
		/* mv = 3*escaped; */
	    }
	}
	if ((flags & F_STATS))
	    fprintf(stderr, "\n");

	fprintf(stderr, "Selected %d-bit escapes\n", mb);
	escBits = mb;
	escMask = (0xff00>>escBits) & 0xff;
    }

    if (!(flags & F_NOOPT)) {
	fprintf(stderr, "Optimizing LZ77 and RLE lengths...");
 	fflush(stderr);	/* for SAS/C */
    }

    /* Find the optimum path (optimize) */
    OptimizeLength((flags & F_NOOPT)?0:1);
    if ((flags & F_STATS)) {
	if(!(flags & F_NOOPT))
	    fprintf(stderr, " gained %d units.\n", lzopt/8);
    } else
	fprintf(stderr, "\n");

    if (1 || (flags & F_AUTOEX)) {
	long lzstat[5] = {0,0,0,0,0}, i, cur = 0, old = extraLZPosBits;

	fprintf(stderr, "Selecting LZPOS LO length.. ");
	fflush(stderr);	/* for SAS/C */

	for (p=0; p<inlen; ) {
	    switch (mode[p]) {
	    case LZ77: /* lz */
		extraLZPosBits = 0;
		lzstat[0] += LenLz(lzlen[p], lzpos[p]);
		extraLZPosBits = 1;
		lzstat[1] += LenLz(lzlen[p], lzpos[p]);
		extraLZPosBits = 2;
		lzstat[2] += LenLz(lzlen[p], lzpos[p]);
		extraLZPosBits = 3;
		lzstat[3] += LenLz(lzlen[p], lzpos[p]);
		extraLZPosBits = 4;
		lzstat[4] += LenLz(lzlen[p], lzpos[p]);
		p += lzlen[p];
		break;
#ifdef DELTA
	    case DLZ:
		p += lzlen2[p];
		break;
#endif
	    case RLE: /* rle */
		p += rle[p];
		break;

	    default: /* normal */
		p++;
		break;
	    }
	}
	for (i=0; i<5; i++) {
	    if ((flags & F_STATS))
		fprintf(stderr, " %ld:%ld", i + 8, lzstat[i]);

	    /* first time around (lzstat[0] < lzstat[0]) */
	    if (lzstat[i] < lzstat[cur])
		cur = i;
	}
	extraLZPosBits = (flags & F_AUTOEX)?cur:old;

	if ((flags & F_STATS))
	    fprintf(stderr, "\n");

	fprintf(stderr, "Selected %d-bit LZPOS LO part\n",
		extraLZPosBits + 8);
	if (cur != old) {
	    fprintf(stderr,
		    "Note: Using option -p%ld you may get better results.\n",
		    cur);
	}
	/* Find the optimum path (optimize) */
	if (extraLZPosBits != old)
	    OptimizeLength((flags & F_NOOPT)?0:1);
    }
    if (1) {
	long stat[4] = {0,0,0,0};

	for (p=0; p<inlen; ) {
	    switch (mode[p]) {
	    case LZ77: /* lz */
		if ((lzpos[p] >> 8)+1 > (1<<maxGamma))
		    stat[3]++;
		if (lzlen[p] > (1<<maxGamma))
		    stat[0]++;
		p += lzlen[p];
		break;

	    case RLE: /* rle */
		if (rle[p] > (1<<(maxGamma-1))) {
		    if (rle[p] <= (1<<maxGamma))
			stat[1]++;
#if 0
		    else if (rle[p] <= (2<<maxGamma))
			stat[2]++;
#endif
		}
		p += rle[p];
		break;
#ifdef DELTA
	    case DLZ:
		p += lzlen2[p];
		break;
#endif
	    default: /* normal */
		p++;
		break;
	    }
	}
	/* TODO: better formula.. */
	if (maxGamma < 7 && stat[0] + stat[1] + stat[3] > 10) {
	    fprintf(stderr,
		    "Note: Using option -m%d you may get better results.\n",
		    maxGamma+1);
	}
	if (maxGamma > 5 && stat[0] + stat[1] + stat[3] < 4) {
	    fprintf(stderr,
		    "Note: Using option -m%d you may get better results.\n",
		    maxGamma-1);
	}
    }

    /* Optimize the escape selections */
    OptimizeEscape(&escape, NULL);
    if (startEscape)
	*startEscape = escape;
    OptimizeRle(flags);	/* Retune the RLE selections */

#ifdef ENABLE_VERBOSE
    if ((flags & F_VERBOSE)) {
	int oldEscape = escape;
	printf("normal RLE  LZLEN LZPOS(absolute)\n\n");

	for (p=0; p<inlen; ) {
	    switch (mode[p]) {
	    case LZ77:
		mode[p - lzpos[p]] |= MMARK; /* Was referred to by lz77 */
		p += lzlen[p];
		break;
	    case RLE:
		p += rle[p];
		break;
#ifdef DELTA
	    case DLZ:
		mode[p - lzpos2[p]] |= MMARK; /* Was referred to by lz77 */
		p += lzlen2[p];
		break;
#endif
	/*  case LITERAL:
	    case MMARK:*/
	    default:
		p++;
		break;
	    }
	}

	j = 0;
	for (p=0; p<inlen; p++) {
	    switch (mode[p]) {
#ifdef DELTA
	    case MMARK | DLZ:
	    case DLZ:
		if (j==p) {
		    printf(">");
		    j += lzlen2[p];
		} else
		    printf(" ");
		if (lzpos2) {
		    printf(" %04x*%03d*+%02x", lzpos2[p], lzlen2[p],
			   (indata[p] - indata[p-lzpos2[p]]) & 0xff);
		}
		printf(" 001   %03d   %03d  %04x(%04x)  %02x %s\n",
			rle[p], lzlen[p], lzpos[p], p-lzpos[p], indata[p],
			(mode[p] & MMARK)?"#":" ");
		break;
#endif
	    case MMARK | LITERAL:
	    case LITERAL:
		if (j==p) {
		    printf(">");
		} else
		    printf(" ");
#ifdef DELTA
		if (lzpos2) {
		    printf(" %04x %03d +%02x", lzpos2[p], lzlen2[p],
			   (indata[p] - indata[p-lzpos2[p]]) & 0xff);
		}
#endif
		if (j==p) {
		    printf("*001*  %03d   %03d  %04x(%04x)  %02x %s %02x",
			   rle[p], lzlen[p], lzpos[p], p-lzpos[p], indata[p],
			   (mode[p] & MMARK)?"#":" ", newesc[p]);
		    if ((indata[p] & escMask) == escape) {
			escape = newesc[p];
			printf("«");
		    }
		    printf("\n");
		    j += 1;
		} else {
		    printf("*001*  %03d   %03d  %04x(%04x)  %02x %s %02x\n",
			   rle[p], lzlen[p], lzpos[p], p-lzpos[p], indata[p],
			   (mode[p] & MMARK)?"#":" ", newesc[p]);
		}
		break;
	    case MMARK | LZ77:
	    case LZ77:
		if (j==p) {
		    printf(">");
		    j += lzlen[p];
		} else
		    printf(" ");
#ifdef DELTA
		if (lzpos2) {
		    printf(" %04x %03d +%02x", lzpos2[p], lzlen2[p],
			   (indata[p] - indata[p-lzpos2[p]]) & 0xff);
		}
#endif
		printf(" 001   %03d  *%03d* %04x(%04x)  %02x %s",
			rle[p], lzlen[p], lzpos[p], p-lzpos[p], indata[p],
			(mode[p] & MMARK)?"#":" ");

		printf("\n");

		break;
	    case MMARK | RLE:
	    case RLE:
		if (j==p) {
		    printf(">");
		    j += rle[p];
		} else
		    printf(" ");
#ifdef DELTA
		if (lzpos2) {
		    printf(" %04x %03d +%02x", lzpos2[p], lzlen2[p],
			   (indata[p] - indata[p-lzpos2[p]]) & 0xff);
		}
#endif
		printf(" 001  *%03d*  %03d  %04x(%04x)  %02x %s\n",
			rle[p], lzlen[p], lzpos[p], p-lzpos[p], indata[p],
			(mode[p] & MMARK)?"#":" ");
		break;
	    default:
		j++;
		break;
	    }
	    mode[p] &= ~MMARK;
	}
	escape = oldEscape;
    }
#endif /* ENABLE_VERBOSE */


    /* Perform rescan */
    {
	int esc = escape;

    for (p=0; p<inlen; ) {
	switch (mode[p]) {
	case LITERAL: /* normal */
	    if ((indata[p] & escMask) == esc) {
		esc = newesc[p];
	    }
	    p++;
	    break;

#ifdef DELTA
	case DLZ:
	    p += lzlen2[p];
	    break;
#endif

	case LZ77: /* lz77 */

#ifdef BACKSKIP_FULL
	    /* Not possible for smaller backSkip table
	       (the table is overwritten during previous use) */
#ifdef RESCAN
	    /* Re-search matches to get the closest one */
	    if (lzopt && /* If any changes to lengths.. */
	        lzlen[p] > 2 /*&& lzlen[p] > rle[p]*/) {
		int bot = p - lzpos[p] + 1, i;
		unsigned short rlep = rle[p];

		if (!rlep)
		    rlep = 1;
		if (bot < 0)
		    bot = 0;
		bot += (rlep-1);

		i = p - (int)backSkip[p];
		while (i>=bot /* && i>=rlep-1 */) {
		    /* Equal number of A's ? */
		    if (rlep==1 || rle[i-rlep+1]==rlep) {	/* 'head' matches */
			unsigned char *a = indata + i+1;	/* match  */
			unsigned char *b = indata + p+rlep-1+1;	/* curpos */
			int topindex = inlen-(p+rlep-1);

			j = 1;
			while (j < topindex && *a++==*b++)
			    j++;

			if (j + rlep-1 >= lzlen[p]) {
			    int tmppos = p-i+rlep-1;

			    rescan +=
				LenLz(lzlen[p], lzpos[p]) -
				LenLz(lzlen[p], tmppos);
#if 0
			    printf("@%d, lzlen %d, pos %04x -> %04x\n",
				    p, lzlen[p], lzpos[p], tmppos);
			    for (i=-1; i<=lzlen[p]; i++) {
				printf("%02x %02x %02x  ",
				       indata[p+i], indata[p-lzpos[p]+i],
				       indata[p-tmppos+i]);
			    }
			    printf("\n");
#endif
			    lzpos[p] = tmppos;
			    break;
			}
		    }
		    if (!backSkip[i])
			break; /* No previous occurrances (near enough) */
		    i -= (int)backSkip[i];
		}
	    }
#endif /* RESCAN */
#endif /* BACKSKIP_FULL */

	    p += lzlen[p];
	    break;

	case RLE: /* rle */
	    p += rle[p];
	    break;

	default: /* Error Flynn :-) */
	    fprintf(stderr, "Internal error: mode %d\n", mode[p]);
	    p++;
	    break;
	}
    }
    }


    /* start of output */

    for (p=0; p<inlen; ) {
	switch (mode[p]) {
	case LITERAL: /* normal */
	    length[p] = outPointer;

	    OutputNormal(&escape, indata+p, newesc[p]);
	    p++;
	    break;

#ifdef DELTA
	case DLZ:
	    for (i=0; i<lzlen2[p]; i++)
		length[p+i] = outPointer;
	    OutputDLz(&escape, lzlen2[p], lzpos2[p],
			(indata[p] - indata[p-lzpos2[p]]) & 0xff);
	    p += lzlen2[p];
	    break;
#endif

	case LZ77: /* lz77 */
	    for (i=0; i<lzlen[p]; i++)
		length[p+i] = outPointer;
	    OutputLz(&escape, lzlen[p], lzpos[p], (char *) (indata+p-lzpos[p]), p);
	    p += lzlen[p];
	    break;

	case RLE: /* rle */
	    for (i=0; i<rle[p]; i++)
		length[p+i] = outPointer;
	    OutputRle(&escape, indata+p, rle[p]);
	    p += rle[p];
	    break;

	default: /* Error Flynn :-) */
	    fprintf(stderr, "Internal error: mode %d\n", mode[p]);
	    p++;
	    break;
	}
    }
    OutputEof(&escape);


    /* xxxxxxxxxxxxxxxxxxx uncompressed */
    /*   yyyyyyyyyyyyyyyyy compressed */
    /* zzzz                */

    i = inlen;
    for (p=0; p<inlen; p++) {
	int pos = (inlen - outPointer) + (int)length[p] - p;
	i = min(i, pos);
    }
    if (i<0)
	reservedBytes = -i + 2;
    else
	reservedBytes = 0;

#ifndef BIG
    if (type == 0) {
	headerSize = 16 + rleUsed;
    } else
#endif /* BIG */
    {
	if (endAddr + reservedBytes + 3 > memEnd) {
	    type |= FIXF_WRAP;
	} else {
	    type &= ~FIXF_WRAP;
	}
	headerSize = GetHeaderSize(type, NULL) + rleUsed - 15;
    }
    outlen = outPointer + headerSize;	/* unpack code */
    fprintf(stderr, "In: %d, out: %d, ratio: %5.2f%% (%4.2f[%4.2f] b/B)"
	    ", gained: %5.2f%%\n",
	    inlen, outlen, (double)outlen*100.0/(double)inlen + 0.005,
	    8.0*(double)outlen/(double)inlen + 0.005,
	    8.0*(double)(outlen-headerSize+rleUsed+4)/(double)inlen + 0.005,
	    100.0 - (double)outlen*100.0/(double)inlen + 0.005);

#ifdef DELTA
    if ((type & FIXF_DLZ)) {
	fprintf(stderr, "Gained RLE: %d (S+L:%d+%d), DLZ: %d, LZ: %d, Esc: %d"
		", Decompressor: %d\n",
		gainedRle/8, gainedSRle/8, gainedLRle/8, gainedDLz/8,
		gainedLz/8, -gainedEscaped/8, -headerSize);

	fprintf(stderr, "Times  RLE: %d (%d+%d), DLZ: %d, LZ: %d, Esc: %d (normal: %d)"
		", %d escape bit%s\n",
		timesRle, timesSRle, timesLRle, timesDLz,
		timesLz, timesEscaped, timesNormal,
		escBits, (escBits==1)?"":"s" );
    } else
#endif
    {
	fprintf(stderr, "Gained RLE: %d (S+L:%d+%d), LZ: %d, Esc: %d"
		", Decompressor: %d\n",
		gainedRle/8, gainedSRle/8, gainedLRle/8,
		gainedLz/8, -gainedEscaped/8, -headerSize);

	fprintf(stderr, "Times  RLE: %d (%d+%d), LZ: %d, Esc: %d (normal: %d)"
		", %d escape bit%s\n",
		timesRle, timesSRle, timesLRle,
		timesLz, timesEscaped, timesNormal,
		escBits, (escBits==1)?"":"s" );
    }
    if ((flags & F_STATS)) {
	const char *ll[] = {"2", "3-4", "5-8", "9-16", "17-32", "33-64",
			    "65-128", "129-256"};
	fprintf(stderr, "(Gained by RLE Code: %d, LZPOS LO Bits %d"
		", maxLen: %d, tag bit/prim. %4.2f)\n",
		gainedRlecode/8 - rleUsed,
		extraLZPosBits + 8,
		(2<<maxGamma),
		(double)((timesRle+timesLz)*escBits +
			 timesEscaped*(escBits + 3))/
		(double)(timesRle+timesLz+timesNormal) + 0.0049);

	fprintf(stderr, "   LZPOS HI+2 LZLEN S-RLE RLEcode\n");
	fprintf(stderr, "   ------------------------------\n");
	for (i=0; i<=maxGamma; i++) {
	    fprintf(stderr, "%-7s %5d %5d", ll[i],
		    lenStat[i][0], lenStat[i][1]);
	    if (i<maxGamma)
		fprintf(stderr, " %5d", lenStat[i][2]);
	    else
		fprintf(stderr, "     -");

	    if (i<5)
		fprintf(stderr, "   %5d%s\n", lenStat[i][3], (i==4)?"*":"");
	    else
		fprintf(stderr, "       -\n");
	}
#ifdef BACKSKIP_FULL
#ifdef RESCAN
	fprintf(stderr, "LZ77 rescan gained %d bytes\n", rescan/8);
#endif /* RESCAN */
#endif /* BACKSKIP_FULL */


#ifdef HASH_STAT
#ifdef HASH_COMPARE
	fprintf(stderr,
		"Hash Checks %ld (%ld, %4.2f%% equal), RLE/LZ compares %ld\n",
		hashChecks, hashEqual,
		100.0*(double)hashEqual/(double)hashChecks,
		compares);
#else
	fprintf(stderr,
		"Value Checks %ld (%ld, %4.2f%% equal), RLE/LZ compares %ld\n",
		hashChecks, hashEqual,
		100.0*(double)hashEqual/(double)hashChecks,
		compares);
#endif /* HASH_COMPARE */
#endif /* HASH_STAT */

    }

errorexit:
    if (rle)
	free(rle);
    if (elr)
	free(elr);
    if (lzmlen)
	free(lzmlen);
    if (lzmpos)
	free(lzmpos);
    if (lzlen)
	free(lzlen);
    if (lzpos)
	free(lzpos);
    if (length)
	free(length);
    if (mode)
	free(mode);
    if (newesc)
	free(newesc);
    if (lastPair)
	free(lastPair);
    if (backSkip)
	free(backSkip);
#ifdef HASH_COMPARE
    if (hashValue)
	free(hashValue);
#endif /* HASH_COMPARE */
    return 0;
}



int main(int argc, char *argv[]) {
    int n, execAddr = -1, ea = -1, newlen, startAddr = -1, startEscape;
    int flags = F_2MHZ, lzlen = -1, buflen;
    char *fileIn = NULL, *fileOut = NULL;
    FILE *infp;
    unsigned char tmp[2];
    unsigned long timeused = clock();

    int machineType = 64;
    char *machineTypeTxt;
    int memStart, memEnd;
    int type = 0;

lrange = LRANGE;
maxlzlen = MAXLZLEN;
maxrlelen = MAXRLELEN;
    InitValueLen();

    flags |= (F_AUTO | F_AUTOEX);
    for (n=1; n<argc; n++) {
	if (!strcmp(argv[n], "-flist")) {
	  printf("List of Decompressors:\n");
	  printf("----------------------\n");
	  ListDecompressors(stdout);
	  return EXIT_FAILURE;
	} else if (!strcmp(argv[n], "-ffast")) {
	    type |= FIXF_FAST;
	} else if (!strcmp(argv[n], "-fnorle")) {
	    flags |= F_NORLE;
	} else if (!strcmp(argv[n], "-fshort")) {
	    type |= FIXF_SHORT;
	} else if (!strcmp(argv[n], "-fbasic")) {
	    type |= FIXF_BASIC;
#ifdef DELTA
	} else if (!strcmp(argv[n], "-fdelta")) {
	    type |= FIXF_DLZ;
#endif
	} else if (!strcmp(argv[n], "+f")) {
	    flags &= ~F_2MHZ;
	} else if (argv[n][0]=='-') {
	    int i = 1;
	    char *val, *tmp, c;
	    long tmpval;

	    while (argv[n][i]) {
		switch (argv[n][i]) {
		case 'u':
		    flags |= F_UNPACK;
		    break;

		case 'd':	/* Raw - no loading address */
		    flags |= F_SKIP;
		    break;

		case 'n':	/* noopt, no rle/lzlen optimization */
		    flags |= F_NOOPT;
		    break;

		case 's':
		    flags |= F_STATS;
		    break;

#ifdef ENABLE_VERBOSE
		case 'v':
		    flags |= F_VERBOSE;
		    break;
#endif /* ENABLE_VERBOSE */

		case 'f':
		    flags |= F_2MHZ;
		    break;

		case 'a':
		    flags |= F_AVOID;
		    break;

		case 'h':
		case '?':
		    flags |= F_ERROR;
		    break;

		case 'g':
		case 'i':
		case 'r':
		case 'x':
		case 'm':
		case 'e':
		case 'p':
		case 'l':
		case 'c': /* 64 (C64), 20 (VIC20), 16/4 (C16/Plus4) */
		    c = argv[n][i]; /* Remember the option */
		    if (argv[n][i+1]) {
			val = argv[n]+i+1;
		    } else if (n+1 < argc) {
			val = argv[n+1];
			n++;
		    } else {
			flags |= F_ERROR;
			break;
		    }

		    i = strlen(argv[n])-1;
		    if (*val=='$')
			tmpval = strtol(val+1, &tmp, 16);
		    else
			tmpval = strtol(val, &tmp, 0);
		    if (*tmp) {
			fprintf(stderr,
				"Error: invalid number: \"%s\"\n", val);
			flags |= F_ERROR;
			break;
		    }
		    switch (c) {
		    case 'r':
			lzlen = tmpval;
			break;
		    case 'x':
			ea = tmpval;
			break;
		    case 'm':
			maxGamma = tmpval;
			if (maxGamma < 5 || maxGamma > 7) {
			    fprintf(stderr, "Max length must be 5..7!\n");
			    flags |= F_ERROR;
			    maxGamma = 7;
			}
lrange = LRANGE;
maxlzlen = MAXLZLEN;
maxrlelen = MAXRLELEN;

			InitValueLen();
			break;
		    case 'e':
			escBits = tmpval;
			if (escBits < 0 || escBits > 8) {
			    fprintf(stderr, "Escape bits must be 0..8!\n");
			    flags |= F_ERROR;
			} else
			    flags &= ~F_AUTO;
			escMask = (0xff00>>escBits) & 0xff;
			break;
		    case 'p':
			extraLZPosBits = tmpval;
			if (extraLZPosBits < 0 || extraLZPosBits > 4) {
			    fprintf(stderr,
				    "Extra LZ-pos bits must be 0..4!\n");
			    flags |= F_ERROR;
			} else
			    flags &= ~F_AUTOEX;
			break;
		    case 'l':
			startAddr = tmpval;
			if (startAddr < 0 || startAddr > 0xffff) {
			    fprintf(stderr,
				    "Load address must be 0..0xffff!\n");
			    flags |= F_ERROR;
			}
			break;
		    case 'c': /* 64 (C64), 20 (VIC20), 16/4 (C16/Plus4) */
			machineType = tmpval;
			if (machineType != 64 && machineType != 20 &&
			    machineType != 16 && machineType != 4 &&
			    machineType != 128 && machineType != 0) {
			    fprintf(stderr, "Machine must be 64, 20, 16/4, 128!\n");
			    flags |= F_ERROR;
			}
			break;
		    case 'i': /* Interrupt config */
			if (tmpval==0) {
			    intConfig = 0x78; /* sei */
			} else {
			    intConfig = 0x58; /* cli */
			}
			break;
		    case 'g': /* Memory configuration */
			memConfig = (tmpval & 0xff);
			break;
		    }
		    break;

		default:
		    fprintf(stderr, "Error: Unknown option \"%c\"\n",
			    argv[n][i]);
		    flags |= F_ERROR;
		}
		i++;
	    }
	} else {
	    if (!fileIn) {
		fileIn = argv[n];
	    } else if (!fileOut) {
		fileOut = argv[n];
	    } else {
		fprintf(stderr, "Only two filenames wanted!\n");
		flags |= F_ERROR;
	    }
	}
    }

    if ((flags & F_ERROR)) {
	fprintf(stderr, "Usage: %s [-<flags>] [<infile> [<outfile>]]\n",
		argv[0]);
	fprintf(stderr,
		"\t -flist    list all decompressors\n"
		"\t -ffast    select faster version, if available (longer)\n"
		"\t -fshort   select shorter version, if available (slower)\n"
		"\t -fbasic   select version for BASIC programs (for VIC20 and C64)\n"
#ifdef DELTA
		"\t -fdelta   use delta-lz77 -- shortens some files\n"
#endif
		"\t -f        enable fast mode for C128 (C64 mode) and C16/+4 (default)\n"
		"\t +f        disable fast mode for C128 (C64 mode) and C16/+4\n"
		"\t c<val>    machine: 64 (C64), 20 (VIC20), 16 (C16/+4)\n"
		"\t a         avoid video matrix (for VIC20)\n"
		"\t d         data (no loading address)\n"
		"\t l<val>    set/override load address\n"
		"\t x<val>    set execution address\n"
		"\t e<val>    force escape bits\n"
		"\t r<val>    restrict lz search range\n"
		"\t n         no RLE/LZ length optimization\n"
		"\t s         full statistics\n"
#ifdef ENABLE_VERBOSE
		"\t v         verbose\n"
#endif /* ENABLE_VERBOSE */
		"\t p<val>    force extralzposbits\n"
		"\t m<val>    max len 5..7 (2*2^5..2*2^7)\n"
		"\t i<val>    interrupt enable after decompress (0=disable)\n"
		"\t g<val>    memory configuration after decompress\n"
		"\t u         unpack\n");
	return EXIT_FAILURE;
    }

    if (lzlen == -1)
	lzlen = DEFAULT_LZLEN;

    if (fileIn) {
	if (!(infp = fopen(fileIn, "rb"))) {
	    fprintf(stderr, "Could not open %s for reading!\n", fileIn);
	    return EXIT_FAILURE;
	}
    } else {
	fprintf(stderr, "Reading from stdin\n");
	fflush(stderr);	/* for SAS/C */
	infp = stdin;
    }

    if (!(flags & F_SKIP)) {
	ssize_t bytes_read = fread(tmp, 1, 2, infp);
	(void) bytes_read;
	/* Use it only if not overriden by the user */
	if (startAddr==-1)
	    startAddr = tmp[0] + 256*tmp[1];
    }
    if (startAddr==-1)
	startAddr = 0x258;

    /* Read in the data */
    inlen = 0;
    buflen = 0;
    indata = NULL;
    while (1) {
	if (buflen < inlen + lrange) {
	    unsigned char *tmp = realloc(indata, buflen + lrange);
	    if (!tmp) {
		free(indata);
		return 20;
	    }
	    indata = tmp;
	    buflen += lrange;
	}
	newlen = fread(indata + inlen, 1, lrange, infp);
	if (newlen <= 0)
	    break;
	inlen += newlen;
    }
    if (infp != stdin)
	fclose(infp);

    if ((flags & F_UNPACK)) {
	n = UnPack(startAddr, indata, fileOut, flags);
	if (indata)
	    free(indata);
	return n;
    }

    if (startAddr < 0x258
#ifndef BIG
	|| startAddr + inlen -1 > 0xffff
#endif /* BIG */
       ) {
	fprintf(stderr,
		"Only programs from 0x0258 to 0xffff can be compressed\n");
	fprintf(stderr, "(the input file is from 0x%04x to 0x%04x)\n",
		startAddr, startAddr+inlen-1);
	if (indata)
	    free(indata);
	return EXIT_FAILURE;
    }

    switch (machineType) {
    case 20:
	machineTypeTxt = "VIC20 with 8k or 16k (or 24k) expansion memory";
	memStart = 0x1201;
	memEnd = 0x4000;
	type |= FIXF_VIC20 | FIXF_WRAP;

	if (startAddr+inlen > 0x8000) {
	    fprintf(stderr, "Original file exceeds 0x8000 (0x%04x), "
		    "not a valid VIC20 file!\n", startAddr+inlen-1);
	    n = EXIT_FAILURE;
	    goto errexit;
	} else if (startAddr+inlen > 0x6000) {
	    if (startAddr < 0x1000) {
		fprintf(stderr, "Original file exceeds 0x6000 (0x%04x), "
			"3kB+24kB memory expansions assumed\n",
			startAddr+inlen-1);
		machineTypeTxt = "VIC20 with 3k+24k expansion memory";
	    } else {
		fprintf(stderr, "Original file exceeds 0x6000 (0x%04x), "
			"24kB memory expansion assumed\n",
			startAddr+inlen-1);
		machineTypeTxt = "VIC20 with 24k expansion memory";
	    }
	    memEnd = 0x8000;
	} else if (startAddr+inlen > 0x4000) {
	    if (startAddr < 0x1000) {
		fprintf(stderr, "Original file exceeds 0x4000 (0x%04x), "
			"3kB+16kB memory expansion assumed\n",
			startAddr+inlen-1);
		machineTypeTxt =
		    "VIC20 with 3k+16k (or 3k+24k) expansion memory";
	    } else {
		fprintf(stderr, "Original file exceeds 0x4000 (0x%04x), "
			"16kB memory expansion assumed\n",
			startAddr+inlen-1);
		machineTypeTxt = "VIC20 with 16k (or 24k) expansion memory";
	    }
	    memEnd = 0x6000;
	} else if (startAddr+inlen > 0x2000) {
	    if (startAddr < 0x1000) {
		fprintf(stderr, "Original file exceeds 0x2000 (0x%04x), "
			"3kB+8kB memory expansion assumed\n",
			startAddr+inlen-1);
		machineTypeTxt =
		    "VIC20 with 3k+8k (or 3k+16k, or 3k+24k) expansion memory";
	    } else {
		fprintf(stderr, "Original file exceeds 0x2000 (0x%04x), "
			"8kB memory expansion assumed\n",
			startAddr+inlen-1);
	    }
	    /* memEnd = 0x4000; */
	} else {
	    if (startAddr >= 0x1000 && startAddr < 0x1200) {
		fprintf(stderr, "Program for unexpanded VIC detected.\n");
		memStart = 0x1001;
		memEnd = (flags & F_AVOID)?0x1e00:0x2000;
		machineTypeTxt = "VIC20 without expansion memory";
	    } if (startAddr >= 0x400 && startAddr < 0x1000) {
		fprintf(stderr, "Program for 3k-expanded VIC detected.\n");
		memStart = 0x0401;
		memEnd = (flags & F_AVOID)?0x1e00:0x2000;
		machineTypeTxt = "VIC20 with 3k expansion memory";
	    }
	}
	break;
    case 16:
    case 4:
   	type |= FIXF_C16 | FIXF_WRAP;
	if (startAddr+inlen > 0x4000) {
	    fprintf(stderr, "Original file exceeds 0x4000, 61k RAM assumed\n");
	    memStart = 0x1001;
	    memEnd = 0xfd00;
	    machineTypeTxt = "Plus/4";
	} else {
	    fprintf(stderr, "Program for unexpanded C16 detected.\n");
	    memStart = 0x1001;
	    memEnd = 0x4000;
	    machineTypeTxt = "Commodore 16";
	}
	break;
    case 128:
   	type |= FIXF_C128 | FIXF_WRAP;
	memStart = 0x1c01;
	memEnd = 0x10000;
	machineTypeTxt = "Commodore 128";
	break;
    case 0:
	type |= 0;
	machineTypeTxt = "Without decompressor";
	memStart = 0x801;
	memEnd = 0x10000;
	break;
    default:	/* C64 */
	type |= FIXF_C64 | FIXF_WRAP;	/* C64, wrap active */
	machineTypeTxt = "Commodore 64";
	memStart = 0x801;	/* Loading address */
	memEnd = 0x10000;
	break;
    }

    if (startAddr <= memStart) {
	for (n=memStart-startAddr; n<memStart-startAddr+60; n++) {
	    if (indata[n]==0x9e) {	/* SYS token */
		execAddr = 0;
		n++;
		/* Skip spaces and parens */
		while (indata[n]=='(' || indata[n]==' ')
		   n++;

		while (indata[n]>='0' && indata[n]<='9') {
		    execAddr = execAddr * 10 + indata[n++] - '0';
		}
		break;
	    }
	}
    }
    if (ea != -1) {
	if (execAddr!=-1 && ea!=execAddr)
	    fprintf(stderr, "Discarding execution address 0x%04x=%d\n",
		    execAddr, execAddr);
	execAddr = ea;
    } else if (execAddr < startAddr || execAddr >= startAddr+inlen) {
	if ((type & FIXF_BASIC)) {
	    execAddr = 0xa7ae;
	} else {
	    fprintf(stderr, "Note: The execution address was not detected "
		    "correctly!\n");
	    fprintf(stderr, "      Use the -x option to set the execution "
		    "address.\n");
	}
    }
    fprintf(stderr, "Load address 0x%04x=%d, Last byte 0x%04x=%d\n",
	    startAddr, startAddr, startAddr+inlen-1, startAddr+inlen-1);
    fprintf(stderr, "Exec address 0x%04x=%d\n", execAddr, execAddr);
    fprintf(stderr, "New load address 0x%04x=%d\n", memStart, memStart);
    if (machineType == 64) {
	fprintf(stderr, "Interrupts %s and memory config set to $%02x "
		"after decompression\n",
		(intConfig==0x58)?"enabled":"disabled", memConfig);
	fprintf(stderr, "Runnable on %s\n", machineTypeTxt);
    } else if (machineType != 0) {
	fprintf(stderr, "Interrupts %s after decompression\n",
		(intConfig==0x58)?"enabled":"disabled");
	fprintf(stderr, "Runnable on %s\n", machineTypeTxt);
    } else {
	fprintf(stderr, "Standalone decompressor required\n");
    }
#if 0
    if ((flags & F_2MHZ))
	type |= FIXF_FAST;
#endif
    n = PackLz77(lzlen, flags, &startEscape, startAddr + inlen, memEnd, type);
    if (!n) {
	int endAddr = startAddr + inlen; /* end for uncompressed data */
	int hDeCall, progEnd = endAddr;

	if (GetHeaderSize(type, &hDeCall) == 0) {
	    GetHeaderSize(type & ~FIXF_WRAP, &hDeCall);
	}
	if (machineType != 0 &&
	    endAddr - ((outPointer + 255) & ~255) < memStart + hDeCall + 3) {
	    /* would overwrite the decompressor, move a bit upwards */
	    fprintf(stderr, "$%x < $%x, decompressor overwrite possible, "
		    "moving upwards\n",
		    endAddr - ((outPointer + 255) & ~255),
		    memStart + hDeCall + 3);
	    endAddr = memStart + hDeCall + 3 + ((outPointer + 255) & ~255);
	}
	/* Should check that endAddr really is larger than original endaddr! */
#if 0
	/* Move the end address for files that got expanded */
	if (memStart + hSize + outPointer > endAddr) {
	    endAddr = memStart + hSize + outPointer;
	}
#endif
	/* 3 bytes reserved for EOF */
	/* bytes reserved for temporary data expansion (escaped chars) */
	endAddr += 3 + reservedBytes;

#ifdef BIG
	endAddr = 0x10000;
#endif /* BIG */
#ifdef DELTA
	if (!timesDLz) {
	    type &= ~FIXF_DLZ;
	}
#endif
	SavePack(type, outBuffer, outPointer, fileOut,
		 startAddr, execAddr, startEscape, rleValues,
		 endAddr, progEnd, extraLZPosBits, (flags & F_2MHZ)?1:0,
		 memStart, memEnd);

	timeused = clock()-timeused;
	if (!timeused)
	    timeused++;
	fprintf(stderr,
		"Compressed %d bytes in %4.2f seconds (%4.2f kB/sec)\n",
		inlen,
		(double)timeused/CLOCKS_PER_SEC,
		(double)CLOCKS_PER_SEC*inlen/timeused/1024.0);
    }
errexit:
    if (indata)
	free(indata);
    return n;
}