#include <stdio.h>

unsigned char buf1[0x10000];
unsigned char buf2[0x12000]; // the absolute worst scenario is that the compressed version actually comes out larger and the size will increase be by a factor of 9/8

unsigned short blockSize[0x12000];
unsigned short offset[0x12000];

// This looks similar if not identical to an LZ compression I've seen in Final Fantasy VI...

unsigned int decompress(unsigned int inputLength, unsigned char* readBuf, unsigned char* writeBuf)
{
    unsigned int index = 1, j = 0;
    unsigned char codeByte = readBuf[0];
    unsigned int codeByteBitTest = 7; // a bitmask
    unsigned int count = 0;
    unsigned int outputLength = 0;

    //read length
    unsigned char nextByte;
    unsigned int len;
    unsigned int start_pos;
    unsigned int k, oldJ;
   
    while(index < inputLength)
    {
        // will test 0x80, then 0x40, ... down to 0x01
        if((codeByte & (1 << codeByteBitTest))  != 0)
        {
            nextByte = readBuf[index];
            len = nextByte >> 2; // length is stored as the upper 6 bits of the byte       
            count += len;
            index++;

            // offset into the read buffer is 10 bits, ranging 0x0000 to 0x03FF
            start_pos = ((nextByte & 3) << 8) + readBuf[index];
            index++;

            //copy bytes
            oldJ = j;

            // Copy data from previous data that is already in the write buffer using an LZ-like method
            for(k = 0; len != 0; k++)
            {
                writeBuf[j] = writeBuf[(oldJ - start_pos) + k];
                j++; len--;
            }
        }
        else
        {
            // copy without decompressing
            writeBuf[j] = readBuf[index];
            index++; j++; count++;
        }

        if(!codeByteBitTest)
        {
            codeByte = readBuf[index];
            index++;

            // reset the bitmask
            codeByteBitTest = 7;
        }
        else
            codeByteBitTest--;

    }

    return j;
}

unsigned int compress(unsigned int inputLength, unsigned char* readBuf, unsigned char* writeBuf)
{
    // I'm using a different bit mask representation than Euclid did in the decompression routine
    unsigned char mask = 0x80;

    unsigned char* ctrlByte = NULL;

    unsigned int index = 0, j = 0, k = 0;
    unsigned short matchLen = 0;

    // ------------------------------------------------
   
    // see what the largest number of bytes we can get for this particular location with LZ
    for(index = 0; index < inputLength; index++)
    {
        offset[index] = 0;
        blockSize[index] = 0;

        for(j = 0; j < i; j++)
        {
            k = 0;
            matchLen = 0;

            // the compression format cannot reach back any further than 0x3FF bytes in to the buffer
            if((index - j) > 0x3FF)
                j = index - 0x3FF;
           
            // the decompression engine is only capable of tracking 6 bits of length for a block
            while( (readBuf[j + k] == readBuf[index + k]) && (matchLen < 0x3F) )
            {
                if( (index + k) >= inputLength )
                    break;

               matchLen++; k++;
            }
               
            // new winnar
            if((matchLen > blockSize[index]) && (matchLen >= 3))
            {
                offset[index] = (index - j);
                blockSize[index] = matchLen;           
            }
        }       
    }
   
    ctrlByte = &writeBuf[0];
    (*ctrlByte) = 0; // no compression being used at initialization
   
    for(index = 0, k = 1; index < inputLength; index++)
    {
        if(!mask)
        {
            mask = 0x80;
            ctrlByte = &writeBuf[k++];
        } 
       
        if(!blockSize[index])
            writeBuf[k++] = readBuf[index];
        else
        {
            (*ctrlByte) |= mask; // indicate that this series will use LZ

            writeBuf[k++] = (blockSize[index] << 2) | (offset[index] >> 8);
            writeBuf[k++] = offset[index] & 0xFF;

            index += blockSize[index] - 1;
        }   
   
        mask >>= 1;
    }

    return k;
}

    //example code that uses the above routines
    //note that this is not a self contained program in and of itself
    // you'll need a main() function similar to Euclid's original file

    FILE* fp = fopen("C:\\\\test.bin","rb");
    FILE* wp = fopen("C:\\\\test2.bin","wb");
    FILE* dp = fopen("C:\\\\test3.bin","wb");

    unsigned int a = 0, b = 0;

    // rather than using an explicit value of 0x10000 you could get the filesize
    // as long as it's under 0x10000 bytes it should be fine
    // test.bin just happened to be 0x10000 bytes so you'll get an error on fread if you change it to load a
    // smaller file
    fread(buf1,sizeof(unsigned char), 0x10000, fp);
    fclose(fp);

    a = compress(0x10000, buf1, buf2);

    fwrite(buf2,sizeof(unsigned char), a ,wp);
    fclose(wp);

    b = decompress(a, buf2, buf1);

    fwrite(buf1, sizeof(unsigned char), b , dp);
    fclose(dp);