Help about C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace fcldParser
{
    class Program
    {
        /*
Header:
    File Format (4 bytes, usually: "FCLD") / File Version (4 bytes, eg. 0x00F51300) / Hex [CD CC 8C 3F] / File Count (4 bytes, eg. 0x71C6 // big endian)

File Entry:
    Filename Length (int) / File Name / Hex [00 00] / Unknown Data (6 bytes) / Hex [01] / Unknown Data (8 bytes, long?) / Hex [00]
        */

        /*[StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Explicit, CharSet = CharSet.Ansi)]
        public struct FCLDEntry
        {
            [MarshalAs(UnmanagedType.I8, SizeConst=6), FieldOffset(2)]
            public long Version;
            [FieldOffset(8)]
            public int HeaderChecksum;
            [FieldOffset(12)]
            public int FileCount;
        }*/

        static string bytesToString(byte[] mInput)
        {
            string mReturn = string.Empty;
            for (int iIndex = 0; iIndex < mInput.Length; iIndex++)
                mReturn += mInput[iIndex].ToString("X2").ToString() + " ";
            return mReturn.Substring(0, mReturn.Length - 1);
        }

        static void Main(string[] args)
        {
            //string mFileName = Console.ReadLine();
            string mBasePath = @"D:\Downloads\G1 Client\";
            mBasePath = @"C:\Users\Felix\Documents\WarRock\Warrock EU\";
            string mFileName = mBasePath + @"data\Global.FCL";
            if (System****.File.Exists(mFileName))
            {
                FileCodeListDocument iDocument = new FileCodeListDocument(mFileName);
                Console.WriteLine("Parsing document...");
                iDocument.parseDocument();
                Console.WriteLine("Document parsed");
                Console.WriteLine("Now exporting readable data...");
                string mMassiveContent = "== FileCodeListDocument Header\r\n";
                mMassiveContent += iDocument.Header.Format + "/" + iDocument.Header.Version.ToString() + " [CHKSM " + iDocument.Header.HeaderChecksum.ToString("X2") + "]\r\n";
                mMassiveContent += "Total Entrys: " + iDocument.Header.FileCount.ToString() + "\r\n\r\n\r\n";
                int mCount = 0;
                var iList = new List<string>(); // polynom meet list
                var jList = new List<uint>();
                var kList = new List<uint>();
                var lList = new List<uint>();
                byte mThreads = 0;
                foreach(FCLDEntry iEntry in iDocument.Entrys)
                {
                    /*if (!iEntry.FileName.Contains("ITEMS.BIN"))
                        continue;*/
                    /*if (iEntry.FileSize < 1024)
                        continue;
                    if (iEntry.FileSize > 131072)
                        continue;*/
                    if (!System****.File.Exists(mBasePath + iEntry.FileName))
                        continue;
                    /*if (kLis*****ntains(iEntry.FileSize))
                        continue;
                    kList.Add(iEntry.FileSize);*/
                    //Console.WriteLine("File Scan [" + iEntry.FileName + "]");
                    mMassiveContent += "File: " + iEntry.FileName + "\r\n";
                    mMassiveContent += "Size: " + iEntry.FileSize + " (" + iEntry.FileSize.ToString("X2") + ") bytes\r\n";
                    mMassiveContent += "UBDump: " + bytesToString(iEntry.UnknownBytes) + "\r\n";
                    mMassiveContent += "Checksum: " + iEntry.FileChecksum.ToString("X2").PadLeft(8, '0') + "\r\n";
                    byte[] iFileBytes = System****.File.ReadAllBytes(mBasePath + iEntry.FileName);
                    uint mChecksum = Crc32.Compute(iFileBytes);
                    mMassiveContent += "RealChecksum: " + mChecksum.ToString("X2").PadLeft(8, '0') + "\r\n";
                    mMassiveContent += "Checksum XOR: " + (iEntry.FileChecksum ^ mChecksum).ToString("X2").PadLeft(8, '0') + "\r\n\r\n";

                    //var iThread = new System.Threading.Thread(new System.Threading.ThreadStart(() =>
                    //{

                    //Console.WriteLine("Collision Scan...");
                    //uint iChecksum = iEntry.FileChecksum ^ (BitConverter.ToUInt32(new byte[4] { iIndex, iIndex, iIndex, iIndex }, 0));
                    var iAction = new Action<uint, byte, bool>((uint mPoly, byte polyMethod, bool doReverse) =>
                        {
                            string mLog = "Trying Match @" + iEntry.FileName + " - [mPoly:" + mPoly.ToString("X2") + " / polyMethod:" + polyMethod.ToString() + " / revesed: " + doReverse.ToString() + "]\r\n";
                            byte[] baChecksum = BitConverter.GetBytes(iEntry.FileChecksum);
                            if(doReverse)
                                Array.Reverse(baChecksum);
                            uint iChecksum = BitConverter.ToUInt32(baChecksum, 0) ^ mPoly;
                            if (mChecksum == iChecksum)
                            {
                                //Console.WriteLine("i like meat");
                                if (jLis*****ntains(mPoly))
                                {
                                    mLog += "+ iChecksum:" + iChecksum.ToString("X2") + " / mPoly:" + mPoly.ToString("X2") + " / fileSize:" + iEntry.FileSize.ToString("X2") + " / fileChecksum:" + iEntry.FileChecksum.ToString("X2") + " / polyMethod:" + polyMethod.ToString() + "\r\n";
                                    Console.WriteLine(mLog);
                                    //Console.WriteLine(mLog);
                                    if (lLis*****ntains(mPoly))
                                    {
                                        Console.WriteLine("MATCHED KEY!!!");
                                        Console.ReadLine();
                                    }
                                    else
                                        lList.Add(iChecksum);
                                    iList.Add(mLog);
                                }
                                else
                                    jList.Add(mPoly);
                            }
                        });
                    var kAction = new Action<uint, byte, bool>((uint mPoly, byte polyMethod, bool doReverse) =>
                    {
                        for (byte iIndex = 0; iIndex < 32; iIndex++)
                        {
                            iAction((mPoly << iIndex) | (mPoly >> (32 - iIndex)), polyMethod, doReverse); // bit rotate
                        }
                    });
                    var jAction = new Action<bool>((bool mReverse) =>
                    {
                        for (byte cIndex = 0; cIndex < 3; cIndex++)
                        {
                            uint tukBytes = BitConverter.ToUInt32(iEntry.UnknownBytes, cIndex);
                            kAction(tukBytes, 0, mReverse);
                            kAction(tukBytes ^ (uint)iDocument.Header.HeaderChecksum, 1, mReverse);
                            kAction(tukBytes ^ mChecksum, 2, mReverse);
                            kAction(tukBytes ^ mChecksum ^ (uint)iDocument.Header.HeaderChecksum, 3, mReverse);
                            kAction(tukBytes ^ mChecksum ^ iEntry.FileChecksum, 4, mReverse);
                            kAction(tukBytes ^ mChecksum ^ iEntry.FileChecksum ^ (uint)iDocument.Header.HeaderChecksum, 5, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize, 6, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ (uint)iDocument.Header.HeaderChecksum, 7, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ mChecksum, 8, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ mChecksum ^ (uint)iDocument.Header.HeaderChecksum, 9, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum, 10, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum ^ (uint)iDocument.Header.HeaderChecksum, 11, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum ^ mChecksum, 12, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum ^ mChecksum ^ (uint)iDocument.Header.HeaderChecksum, 13, mReverse);
                            
                            kAction(tukBytes ^ 0xffffffff, 14, mReverse);
                            kAction(tukBytes ^ (uint)iDocument.Header.HeaderChecksum ^ 0xffffffff, 15, mReverse);
                            kAction(tukBytes ^ mChecksum ^ 0xffffffff, 16, mReverse);
                            kAction(tukBytes ^ mChecksum ^ (uint)iDocument.Header.HeaderChecksum ^ 0xffffffff, 17, mReverse);
                            kAction(tukBytes ^ mChecksum ^ iEntry.FileChecksum ^ 0xffffffff, 18, mReverse);
                            kAction(tukBytes ^ mChecksum ^ iEntry.FileChecksum ^ (uint)iDocument.Header.HeaderChecksum ^ 0xffffffff, 19, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ 0xffffffff, 20, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ (uint)iDocument.Header.HeaderChecksum ^ 0xffffffff, 21, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ mChecksum ^ 0xffffffff, 22, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ mChecksum ^ (uint)iDocument.Header.HeaderChecksum ^ 0xffffffff, 23, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum ^ 0xffffffff, 24, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum ^ (uint)iDocument.Header.HeaderChecksum ^ 0xffffffff, 25, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum ^ mChecksum ^ 0xffffffff, 26, mReverse);
                            kAction(tukBytes ^ iEntry.FileSize ^ iEntry.FileChecksum ^ mChecksum ^ (uint)iDocument.Header.HeaderChecksum ^ 0xffffffff, 27, mReverse);
                            //(uint)iDocument.Header.HeaderChecksum
                        }

                        kAction(mChecksum, 28, mReverse);
                        //kAction(mChecksum ^ iEntry.FileChecksum, 29, mReverse);
                        kAction(iEntry.FileSize, 30, mReverse);
                        kAction(iEntry.FileSize ^ mChecksum, 31, mReverse);
                        kAction(iEntry.FileSize ^ iEntry.FileChecksum, 32, mReverse);
                        kAction(iEntry.FileSize ^ iEntry.FileChecksum ^ mChecksum, 33, mReverse);
                        
                        //kAction(iEntry.FileChecksum ^ mChecksum, 34, mReverse);
                        
                        kAction(iEntry.FileSize, 35, mReverse);
                        kAction(iEntry.FileSize ^ mChecksum, 36, mReverse);
                        kAction(mChecksum, 37, mReverse);
                        
                        kAction(mChecksum ^ 0xffffffff, 38, mReverse);
                        kAction(mChecksum ^ iEntry.FileChecksum ^ 0xffffffff, 39, mReverse);
                        kAction(iEntry.FileSize ^ 0xffffffff, 40, mReverse);
                        kAction(iEntry.FileSize ^ mChecksum ^ 0xffffffff, 41, mReverse);
                        kAction(iEntry.FileSize ^ iEntry.FileChecksum ^ 0xffffffff, 42, mReverse);
                        kAction(iEntry.FileSize ^ iEntry.FileChecksum ^ mChecksum ^ 0xffffffff, 43, mReverse);
                        
                        kAction(iEntry.FileChecksum ^ mChecksum ^ 0xffffffff, 44, mReverse);
                        
                        kAction(iEntry.FileSize ^ 0xffffffff, 45, mReverse);
                        kAction(iEntry.FileSize ^ mChecksum ^ 0xffffffff, 46, mReverse);
                        kAction(mChecksum ^ 0xffffffff, 47, mReverse);
                    });

                    jAction(true);
                    jAction(false);

                    /*for (uint iIndex = 0x0; iIndex < 0xffffffff; iIndex++)
                    {
                        iAction(iIndex, 7, false);
                        if(iIndex % 0xFFFFFF == 0)
                            Console.Write(".");
                    }
                    Console.WriteLine("Finished OP1");
                    mThreads++;
                    //Console.WriteLine("Scan aborted");
                    //}));
                    //iThread.Start();*/

                    mCount++;
                    if (mCount >= 3500)
                        break;
                    if (mCount % 100 == 0)
                        Console.Write(".");
                }

                //while (mThreads != 10)
                //System.Threading.Thread.Sleep(500);
                mMassiveContent += "\r\n\r\n\r\n\r\n== Polynomial Collisions\r\n\r\n";
                foreach (string cEntry in iList)
                {
                    mMassiveContent += cEntry + "\r\n";
                    //Console.WriteLine(cEntry);
                }
                Console.WriteLine("Saving file [" + mCount.ToString() + "]...");
                if (System****.File.Exists(@"C:\Users\Felix\Desktop\data.dat"))
                    System****.File.Delete(@"C:\Users\Felix\Desktop\data.dat");
                System****.File.WriteAllText(@"C:\Users\Felix\Desktop\data.dat", mMassiveContent);
                Console.WriteLine("Trying to find correct CRC32Polynom. ...");

            }
            else
                Console.WriteLine("File not Found");
            Console.ReadLine();
        }
    }
}

namespace fcldParser
{
    using System;
    using System.Collections.Generic;
    using System****;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Text;

    internal class FileCodeListDocument
    {
        protected List<FCLDEntry> _Entrys;

        public FileCodeListDocument(string FileName)
        {
            this.Content = File.ReadAllBytes(FileName);
            this._Entrys = new List<FCLDEntry>();
        }

        public void parseDocument()
        {
            FCLDHeader header = (FCLDHeader)Marshal.PtrToStructure(GCHandle.Alloc(this.Content, GCHandleType.Pinned).AddrOfPinnedObject(), typeof(FCLDHeader));
            this.Header = header;
            int startIndex = 0x10;
            for (int i = 0; i < header.FileCount; i++)
            {
                int num3 = BitConverter.ToInt32(this.Content, startIndex);
                string fileName = "";
                for (int j = startIndex + 4; j < ((startIndex + 4) + num3); j++)
                {
                    fileName = fileName + Convert.ToChar(this.Content[j]).ToString();
                }
                byte[] destinationArray = new byte[6];
                Array.Copy(this.Content, ((startIndex + 4) + num3) + 2, destinationArray, 0, 6);
                uint fileSize = BitConverter.ToUInt32(this.Content, (startIndex + 13) + num3);
                uint fileChecksum = BitConverter.ToUInt32(this.Content, (startIndex + num3) + 0x11);
                this._Entrys.Add(new FCLDEntry(fileName, destinationArray, fileSize, fileChecksum));
                startIndex += 0x15 + num3;
            }
        }

        public void patchEntry(FCLDEntry iEntry, FCLDEntry newEntry)
        {
            if (newEntry.UnknownBytes == null)
            {
                newEntry = new FCLDEntry(newEntry.FileName, iEntry.UnknownBytes, newEntry.FileSize, newEntry.FileChecksum);
            }
            this._Entrys[this._Entrys.IndexOf(iEntry)] = newEntry;
        }

        public void saveDocument(string mFile)
        {
            if (File.Exists(mFile))
            {
                File.Delete(mFile);
            }
            BinaryWriter writer = new BinaryWriter(File.Open(mFile, FileMode.CreateNew, FileAccess.Write, FileShare.None));
            writer.Write(Encoding.UTF8.GetBytes(this.Header.Format));
            writer.Write(this.Header.Version);
            writer.Write(this.Header.HeaderChecksum);
            writer.Write(this.Header.FileCount);
            foreach (FCLDEntry entry in this._Entrys)
            {
                writer.Write((uint)entry.FileName.Length);
                writer.Write(Encoding.UTF8.GetBytes(entry.FileName));
                writer.Write((short)0);
                writer.Write(entry.UnknownBytes);
                writer.Write((byte)1);
                writer.Write(entry.FileSize);
                writer.Write(entry.FileChecksum);
            }
            writer.Flush();
            writer.Close();
        }

        public byte[] Content { get; private set; }

        public FCLDEntry[] Entrys
        {
            get
            {
                return this._Entrys.ToArray();
            }
        }

        public FCLDHeader Header { get; private set; }
    }
}