public static void ScanOffsets(MemUtils memUtils,ProcessModule client,ProcessModule engine)
 {
     clientDll = client;
     engineDll = engine;
     clientDllBase = clientDll.BaseAddress.ToInt32();
     engineDllBase = engineDll.BaseAddress.ToInt32();
     EntityOff(memUtils);
     LocalPlayer(memUtils);
     Jump(memUtils);
     GameResources(memUtils);
     ClientState(memUtils);
     SetViewAngles(memUtils);
     SignOnState(memUtils);
     GlowManager(memUtils);
     WeaponTable(memUtils);
     EntityID(memUtils);
     EntityHealth(memUtils);
     EntityVecOrigin(memUtils);
     PlayerTeamNum(memUtils);
     PlayerBoneMatrix(memUtils);
     PlayerWeaponHandle(memUtils);
     vMatrix(memUtils);
     clientDll = null;
     engineDll = null;
     clientDllBase = 0;
     engineDllBase = 0;
 }

 public ModuleDataObject(Process p, ProcessModule m, bool isDisabled)
     : base(string.Format("{0}.{1}", p.Id, m.FileName))
 {
     ID = p.Id;
     Refresh(p, m, isDisabled);
     ConstructionIsFinished = true;
 }

 public CacheInfo(ProcessModule module)
 {
     FileDescription = module.FileVersionInfo.FileDescription;
     FileVersion = module.FileVersionInfo.FileVersion;
     ProductName = module.FileVersionInfo.ProductName;
     ProductVersion = module.FileVersionInfo.ProductVersion;
 }

 public HEAP_INFO(ulong heapAddress, ulong heapLength, string heapProtection, string extra, ProcessModule associatedModule)
 {
     this.heapAddress = heapAddress;
     this.heapLength = heapLength;
     this.heapProtection = heapProtection;
     this.extra = extra;
     this.associatedModule = associatedModule;
 }

 /// <summary>
 ///     Initializes a new instance of the <see cref="RemoteModule" /> class.
 /// </summary>
 /// <param name="memorySharp">The reference of the <see cref="MemorySharp" /> object.</param>
 /// <param name="module">The native <see cref="ProcessModule" /> object corresponding to this module.</param>
 internal RemoteModule(MemoryBase memorySharp, ProcessModule module) : base(memorySharp, module.BaseAddress)
 {
     // Save the parameter
     Native = module;
     LazyData =
         new Lazy<byte[]>(
             () => MemoryCore.ReadBytes(memorySharp.Handle, module.BaseAddress, module.ModuleMemorySize));
 }

        public virtual void Update(IntPtr value, ProcessModule targetModule)
        {
            IntPtr baseAddress = targetModule.BaseAddress;
            FileVersionInfo info = targetModule.FileVersionInfo;

            int offset = value.GetInt32OffsetFrom(targetModule.BaseAddress);
            Build = info.FileVersion;
            Value = offset;
        }

		public uint FindPattern( ProcessModule pModule, string szPattern, string szMask, char Delimiter ) {
			string[] saPattern = szPattern.Split( Delimiter );
			byte[] bPattern = new byte[ saPattern.Length ];

			for( int i = 0; i < bPattern.Length; i++ )
				bPattern[ i ] = Convert.ToByte( saPattern[ i ], 0x10 );

			return FindPattern( pModule, bPattern, szMask );
		}

 public Memory(ProcessModule engineDll, ProcessModule clientDll)
 {
     Scanner.ScanOffsets(clientDll, engineDll, Program.MemUtils);
     ClientDllBase = (int) clientDll.BaseAddress;
     var engineDllBase = (int) engineDll.BaseAddress;
     _entityList = ClientDllBase + Offsets.Misc.EntityList;
     _viewMatrix = ClientDllBase + Offsets.Misc.ViewMatrix;
     ClientState = Program.MemUtils.Read<int>((IntPtr) (engineDllBase + Offsets.ClientState.Base));
     ActiveWeapon = "Default";
 }

        public static void doWork(object crap)
        {
            try
            {
                Process process = Process.GetCurrentProcess();

                ProcessModule[] modules = new ProcessModule[process.Modules.Count];
                process.Modules.CopyTo(modules, 0);

                var niQuery =
                    from m in modules
                    where m.FileName.Contains(@"\" + process.ProcessName + ".ni")
                    select m.FileName;
                bool ni = niQuery.Count() > 0 ? true : false;

                if (!ni)
                {
                    // FORNOW: for PoC debugging and sanity checking
                    Console.WriteLine("The app is not NGen'd.");
                    Console.WriteLine("NGen'ing the app...");

                    var assemblyPath = process.MainModule.FileName;

                    ProcessStartInfo startInfo = new ProcessStartInfo();
                    // TODO: Determine the path to (the appropriate version of)
                    // ngen.exe.
                    // FORNOW: Just use a hardcoded path to ngen.exe for PoC.
                    startInfo.FileName =
                        @"C:\Windows\Microsoft.NET\Framework\v4.0.30319\ngen.exe";
                    startInfo.Arguments = "install \"" + assemblyPath + "\"";
                    // TBD: process options that you think make sense
                    startInfo.CreateNoWindow = false;
                    startInfo.UseShellExecute = false;
                    startInfo.WindowStyle = ProcessWindowStyle.Hidden;

                    try
                    {
                        using (Process exeProcess = Process.Start(startInfo))
                        {
                            exeProcess.WaitForExit();
                        }
                    }
                    catch
                    {
                        // TBD: error handling that you think makes sense - e.g.
                        // logging or displaying the error, moving on regardless
                        // etcetera.
                    }
                }
            }
            catch
            {

            }
        }

 public static CacheInfo Get(string key, ProcessModule module)
 {
     CacheInfo result;
     if( CachedInfos.TryGetValue(key, out result))
     {
         return result;
     }
     result = new CacheInfo(module);
     CachedInfos[key] = result;
     return result;
 }

 public Framework(ProcessModule clientDll, ProcessModule engineDll)
 {
     CSGOScanner.ScanOffsets(WithOverlay.MemUtils, clientDll, engineDll);
     clientDllBase = (int)clientDll.BaseAddress;
     engineDllBase = (int)engineDll.BaseAddress;
     dwEntityList = clientDllBase + CSGOOffsets.Misc.EntityList;
     dwViewMatrix = clientDllBase + CSGOOffsets.Misc.ViewMatrix;
     dwClientState = WithOverlay.MemUtils.Read<int>((IntPtr)(engineDllBase + CSGOOffsets.ClientState.Base));
     mouseEnabled = true;
     AimbotActive = false;
 }

 static bool IsNetModule(ProcessModule m)
 {
     var s = m.ModuleName;
     if (s.Equals("mscorwks.dll", StringComparison.OrdinalIgnoreCase))
         return true;
     if (s.Equals("mscorsvr.dll", StringComparison.OrdinalIgnoreCase))
         return true;
     if (s.Equals("clr.dll", StringComparison.OrdinalIgnoreCase))
         return true;
     return false;
 }

        public void BackgroundProcess()
        {
            do
            {
                Thread.Sleep(500);
                ffximain = (from ProcessModule m in pol.Modules where m.ModuleName.ToLower() == "ffximain.dll" select m).FirstOrDefault();
            }
            while (ffximain == null);

            _FFACE = new FFACE(pol.Id);
            while (_FFACE.Player.Name == "")
                Thread.Sleep(500);

            _FFACE.Windower.SendString("/vanatunes hold on");
            sCharName = _FFACE.Player.Name;
            profile = "(none)";
            //TODO: Check player name and set default profile

            byte[] mobPtrTmp = new byte[4];
            IntPtr mobPtrArraySize = new IntPtr();
            ReadProcessMemory(pol.Handle, new IntPtr(ffximain.BaseAddress.ToInt32() + 0x8020c), mobPtrTmp, 4, ref mobPtrArraySize);
            IntPtr mobPtr = new IntPtr(BitConverter.ToInt32(mobPtrTmp, 0));
            ReadProcessMemory(pol.Handle, mobPtr, mobFlags, 4096*4, ref mobPtrArraySize);

            m_Zone = _FFACE.Player.Zone;
            uVanaHour = _FFACE.Timer.GetVanaTime().Hour;
            m_Status = _FFACE.Player.Status;
            m_Buffs = _FFACE.Player.StatusEffects;

            if (_FFACE.Party.Party0Count == 1 && _FFACE.Party.Party1Count == 0 && _FFACE.Party.Party2Count == 0)
                bPartyMember = false;
            else
                bPartyMember = true;

            bFighting = false;
            bInBattlefield = false;

            do{
                if (CheckConditions())
                {
                    UInt16 thisTrack = ExecScript();
                    if (thisTrack != currentTrack)
                    {
                        currentTrack = thisTrack;
                        _FFACE.Windower.SendString("/vanatunes playOverride " + currentTrack);
                    }
                }

                Thread.Sleep(500);
            } while(Program.runCharThreads);
            if(ffximain != null)
                _FFACE.Windower.SendString("/vanatunes hold off");
        }

 public ModuleObject(Process p, ProcessModule m, string username)
 {
     Objects[(int)ModuleItemTypes.Name] = Path.GetFileName(m.FileName);
     Objects[(int)ModuleItemTypes.ID] = p.Id;
     Objects[(int)ModuleItemTypes.Path] = Path.GetDirectoryName(m.FileName);
     Objects[(int)ModuleItemTypes.ModuleMemorySize] = m.ModuleMemorySize; //
     Objects[(int)ModuleItemTypes.FileDescription] = m.FileVersionInfo.FileDescription;
     Objects[(int)ModuleItemTypes.FileVersion] = m.FileVersionInfo.FileVersion;
     Objects[(int)ModuleItemTypes.Product] = m.FileVersionInfo.ProductName;
     Objects[(int)ModuleItemTypes.ProductVersion] = m.FileVersionInfo.ProductVersion;
     ForegroundColor = ProcessObject.GetColorFromName(p, username);
     ToolTipText = m.FileVersionInfo.FileDescription;
 }

        public virtual bool TryGetCachedValue(ProcessModule targetModule, out IntPtr result)
        {
            result = IntPtr.Zero;
            IntPtr baseAddress = targetModule.BaseAddress;
            FileVersionInfo info = targetModule.FileVersionInfo;

            if (IsSameVersion(info))
            {
                result = baseAddress + Value;
                return true;
            }

            return false;
        }

 private void EnumModule(ProcessModule m)
 {
     this.lvModDetail.ClearItems();
     try
     {
         lvModDetail.AddItem(new object[] { "Base Address", m.BaseAddress.ToInt32().ToString("x").ToLower() });
         lvModDetail.AddItem(new object[] { "Entry Point Address", m.EntryPointAddress.ToInt32().ToString("x").ToLower() });
         lvModDetail.AddItem(new object[] { "File Name", m.FileName });
         lvModDetail.AddItem(new object[] { "File Version", m.FileVersionInfo.FileVersion.ToString() });
         lvModDetail.AddItem(new object[] { "File Description", m.FileVersionInfo.FileDescription.ToString() });
         lvModDetail.AddItem(new object[] { "Memory Size", m.ModuleMemorySize.ToString("N0") });
     }
     catch (Exception exp)
     {
         MessageBox.Show(exp.Message, exp.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
     }
 }

 /// <summary>
 ///     Performs a pattern scan.
 /// </summary>
 /// <param name="processHandle">The process the <see cref="ProcessModule" /> containing the data resides in.</param>
 /// <param name="processModule">The <see cref="ProcessModule" /> that contains the pattern data resides in.</param>
 /// <param name="data">The array of bytes containing the data to search for matches in.</param>
 /// <param name="mask">
 ///     The mask that defines the byte pattern we are searching for.
 ///     <example>
 ///         <code>
 /// var bytes = new byte[]{55,45,00,00,55} ;
 /// var mask = "xx??x";
 /// </code>
 ///     </example>
 /// </param>
 /// <param name="offsetToAdd">The offset to add to the offset result found from the pattern.</param>
 /// <param name="reBase">If the address should be rebased to this  Instance's base address.</param>
 /// <param name="wildCardChar">
 ///     [Optinal] The 'wild card' defines the <see cref="char" /> value that the mask uses to differentiate
 ///     between pattern data that is relevant, and pattern data that should be ignored. The default value is 'x'.
 /// </param>
 /// <param name="pattern">The byte array that contains the pattern of bytes we're looking for.</param>
 /// <returns>A new <see cref="PatternScanResult" /> instance.</returns>
 public static PatternScanResult Find(SafeMemoryHandle processHandle, ProcessModule processModule, byte[] data,
     byte[] pattern,
     string mask, int offsetToAdd, bool reBase, char wildCardChar = 'x')
 {
     for (var offset = 0; offset < data.Length; offset++)
     {
         if (mask.Where((m, b) => m == 'x' && pattern[b] != data[b + offset]).Any()) continue;
         var found = MemoryCore.Read<IntPtr>(processHandle,
             processModule.BaseAddress + offset + offsetToAdd);
         var result = new PatternScanResult
         {
             OriginalAddress = found,
             Address = reBase ? found : found.Subtract(processModule.BaseAddress),
             Offset = (IntPtr) offset
         };
         return result;
     }
     // If this is reached, the pattern was not found.
     throw new Exception("The pattern scan for the pattern mask: " + "[" + mask + "]" + " was not found.");
 }

        public static string GetFileProcessName(string filePath)
        {
            Process[] procs = Process.GetProcesses();
            string fileName = Path.GetFileName(filePath);

            foreach (Process proc in procs)
            {
                if (proc.MainWindowHandle != new IntPtr(0) && !proc.HasExited)
                {
                    ProcessModule[] arr = new ProcessModule[proc.Modules.Count];
                    foreach (ProcessModule pm in proc.Modules)
                    {
                        if (pm.ModuleName == fileName)
                            return proc.ProcessName;
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Memory yi okumak için Process İsmi Giriniz..
        /// </summary>
        /// <param name="ProccessName">Process Name</param>
        public MemoryReadLib(string ProccessName)
        {
            Process[] processes = Process.GetProcessesByName(ProccessName);
            foreach (Process pr in processes)
            {
                if (pr.ProcessName == ProccessName)
                {
                    this.War3 = pr;
                }
            }
            if (War3 != null)
            {
                ProcessModuleCollection blabla = War3.Modules;
                foreach (ProcessModule mdl in blabla)
                {
                    if (mdl.ModuleName == "Storm.dll")
                    {
                        this.StormDll = mdl;
                    }
                    else if (mdl.ModuleName == "Game.dll")
                    {
                        this.GameDll = mdl;
                    }
                }

                if (GameDll == null || StormDll == null)
                {
                    throw new NullReferenceException("There is no Game Process");
                }

            }
            else
            {
                throw new NullReferenceException("There is no Game Process");
            }
            
        }

        static void OutputModuleMemory(Process process, ProcessModule processModule, Stream stream)
        {
            IntPtr processHandler = process.Handle;
            IntPtr baseAddress = processModule.BaseAddress;
            int moduleMemorySize = processModule.ModuleMemorySize;
            Console.WriteLine("BaseAddress: {0}", baseAddress);
            Console.WriteLine("ModuleMemorySize: {0}", moduleMemorySize);

            int bufferSize = 4096;
            byte[] buffer = new byte[bufferSize];
            IntPtr pointer = baseAddress;
            IntPtr endPointer = IntPtr.Add(baseAddress, moduleMemorySize);
            while (pointer.ToInt64() < endPointer.ToInt64())
            {
                IntPtr readSizeResult = IntPtr.Zero;
                IntPtr readSize = GetReadSize(pointer, endPointer, bufferSize);
                if (NativeMethods.ReadProcessMemory(processHandler, pointer, buffer, readSize, ref readSizeResult))
                {
                    stream.Write(buffer, 0, readSizeResult.ToInt32());
                }

                pointer = IntPtr.Add(pointer, bufferSize);
            }
        }