private: System::Void menuItem9_Click(System::Object *  sender, System::EventArgs *  e)
{
////////////////////////////////
//    Insert Single File      //
////////////////////////////////

// Initialize progress bar
progressBar1->Maximum = 217;
progressBar1->Value = 0;
progressBar1->Visible = true;

// Buffers
System::Byte pTable[] = __gc new System::Byte[0x451];
System::Byte decompBuf[] = __gc new System::Byte[0x10000];
System::Byte compBuf[] = __gc new System::Byte[0x10000];

// Variables
int i;
int q;
int decompLen;
int decompPos = 0;
int compLen;
int address;

// Open Rom Stream for read/edit
FileStream *romStream = __gc new FileStream(statusBarPanel1->Text, FileMode::Open);
FileStream *gfxStream = __gc new FileStream("allGFX.bin", FileMode::Open);

// Open Binary Reader
BinaryReader *romReader = __gc new BinaryReader(romStream);
BinaryReader *gfxReader = __gc new BinaryReader(gfxStream);
BinaryWriter *romWriter = __gc new BinaryWriter(romReader->BaseStream);

// Load pointer table
romReader->BaseStream->Seek(0x37732,Begin);
pTable = romReader->ReadBytes(0x451);

// loop to compress and write each block to ROM
for (i = 0; i < 218; i ++)
{
// Read predetermined length of graphic block based on pointer table length
decompLen = pTable[(i*5) + 4] * 0x100 + pTable[(i*5) + 3];

// Read 4BPP gfx to buffer
gfxReader->BaseStream->Seek(decompPos,Begin);
gfxReader->Read(decompBuf,0,decompLen);

// Fill compBuf with blank bytes
for (q=0; q < 0x10000; q++)
compBuf[q] = 0xFF;

// compress graphics and return compressed gfx block size in bytes
compLen = compress(decompBuf, compBuf, decompLen);

// Read current pointer and convert to a ROM address
address = pTable[i*5] + (pTable[(i*5) + 1] * 0x100) + (pTable[(i*5) + 2] * 0x10000);
address = PCaddress(address); // Convert the loROM address to a pc address

// Write block to ROM based on pointer table address
romWriter->Seek(address,Begin);
romWriter->Write(compBuf,0,compLen);

// Update decompPos
decompPos = decompPos + decompLen;

// Update progress bar
progressBar1->Value = i;
}

// Close streams
romStream->Close();
gfxStream->Close();

// Hide progress bar
progressBar1->Visible = false;
}

public:
unsigned int compress(System::Byte readBuf[], System::Byte writeBuf[], unsigned int inputLength)
{
/*
int p;
StringBuilder* rBufStr = __gc new StringBuilder(rBuf[0],0x10000);
StringBuilder* wBufStr = __gc new StringBuilder(wBuf[0],0x10000);
unsigned int temp;

// copy  rBuf and wBuf to strings
for(p=1; p < 0xFFFF; p++)
{
temp = rBuf[p];
rBufStr->Append(temp);
temp = wBuf[p];
wBufStr->Append(temp);
}

unsigned char* readBuf = (unsigned char*)(void*)Marshal::StringToHGlobalAnsi(rBufStr->ToString());
unsigned char* writeBuf = (unsigned char*)(void*)Marshal::StringToHGlobalAnsi(wBufStr->ToString());
*/
// I'm using a different bit mask representation than Euclid did in the decompression routine
unsigned char mask = 0x80;

unsigned char __gc* ctrlByte;

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

unsigned int offset = 0;
unsigned int blockSize = 0;

// ------------------------------------------------

// see what the largest number of bytes we can get for this particular location with LZ
for(i = 0; i < inputLength; i++)
{
offset = 0;
blockSize = 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((i - j) > 0x3FF)
j = i - 0x3FF;

// the decompression engine is only capable of tracking 6 bits of length for a block
while( (readBuf[j + k] == readBuf[i + k]) && (matchLen < 0x3F) )
{
if( (i + k) >= inputLength )
break;

matchLen++; k++;
}

// new winnar
if((matchLen > blockSize) && (matchLen >= 3))
{
offset = (i - j);
blockSize = matchLen;           
}
}       
}

ctrlByte = &writeBuf[0];
(*ctrlByte) = 0; // no compression being used at initialization

for(i = 0, k = 1; i < inputLength; i++)
{
if(!mask)
{
mask = 0x80;
ctrlByte = &writeBuf[k++];
} 

if(!blockSize)
writeBuf[k++] = readBuf[i];
else
{
(*ctrlByte) |= mask; // indicate that this series will use LZ

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

i += blockSize - 1;
}   

mask >>= 1;
}
/*
// Copy local array back to global array
for(p=0; p < 0x10000; p++)
{
rBuf[p] = readBuf[p];
wBuf[p] = writeBuf[p];
}

Marshal::FreeHGlobal(readBuf);
Marshal::FreeHGlobal(writeBuf);
*/

return k; // Length of compressed graphic block in bytes
}

unsigned long CheckSumCRC32::block_checksum(const void* data, const int& data_len)
inline unsigned long operator()(const void* data, const int& data_len)