static void Main(string[] args)
        {
            ProcUtils proc;
            KeyUtils keys = new KeyUtils();
            CHConfig config = new CHConfig();
            config.ReadSettingsFromFile("chconfig.cfg");
            bool clicker = true,
                drawing = true,
                randomize = false,
                firstRun = true,
                castSpells = false,
                advanceLevels = true;
            Random random = new Random();
            Point[] trail = new Point[16];

            while (!keys.KeyIsDown(WinAPI.VirtualKeyShort.F10))
            {
                Console.Clear();
                Console.WriteLine("Controls:\n" +
                    "F10: Terminate\n" +
                    "F9: Toggle auto-clicker\n" +
                    "F8: Toggle drawing\n" +
                    "F7: Toggle randomization\n" +
                    "Num9/Num6: Increase/decrease clicker-offset (x)\n" +
                    "Num8/Num5: Increase/decrease clicker-offset (y)\n" +
                    "F6: Save window-size and -position and clicker-offsets\n" +
                    "F5: Apply saved window-size and -position to game-window\n" +
                    "F4: Toggle spell-casting");

                firstRun = true;
                Console.WriteLine("Wait for ClickerHeroes to start...");
                while (!ProcUtils.ProcessIsRunning("Clicker Heroes")) { Thread.Sleep(500); }
                proc = new ProcUtils("Clicker Heroes", WinAPI.ProcessAccessFlags.VirtualMemoryOperation);

                Console.WriteLine("Wait for ClickerHeroes' window to show up...");
                while (proc.Process.MainWindowHandle == IntPtr.Zero) { Thread.Sleep(500); }
                while (ProcUtils.ProcessIsRunning("Clicker Heroes"))
                {
                    Thread.Sleep(8);

                    keys.Update();
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.F9))
                        clicker = !clicker;
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.F8))
                        drawing = !drawing;
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.F7))
                        randomize = !randomize;
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.F4))
                        castSpells = !castSpells;
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.F3))
                        advanceLevels = !advanceLevels;

                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.NUMPAD8))
                        config.SetValue("offsetY", config.GetValue<int>("offsetY") + 1);
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.NUMPAD5))
                        config.SetValue("offsetY", config.GetValue<int>("offsetY") - 1);
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.NUMPAD9))
                        config.SetValue("offsetX", config.GetValue<int>("offsetX") + 1);
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.NUMPAD6))
                        config.SetValue("offsetY", config.GetValue<int>("offsetY") + 1);
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.F5))
                    {
                        firstRun = true;
                        config.ReadSettingsFromFile("chconfig.cfg");
                    }

                    WinAPI.WINDOWINFO info = new WinAPI.WINDOWINFO();
                    if (!WinAPI.GetWindowInfo(proc.Process.MainWindowHandle, ref info))
                        continue;

                    if (firstRun)
                    {
                        if (config.GetValue<int>("windowHeight") != 0 || config.GetValue<int>("windowWidth") != 0 || config.GetValue<int>("windowX") != 0 || config.GetValue<int>("windowY") != 0)
                        {
                            WinAPI.SetWindowPos(proc.Process.MainWindowHandle, IntPtr.Zero, config.GetValue<int>("windowX"), config.GetValue<int>("windowY"), config.GetValue<int>("windowWidth"), config.GetValue<int>("windowHeight"), 0);
                        }

                        for (int i = 0; i < trail.Length; i++)
                            trail[i] = new Point(0, 0);

                        firstRun = false;
                    }
                    if (keys.KeyWentUp(WinAPI.VirtualKeyShort.F6))
                    {
                        config.SetValue("windowWidth", info.rcWindow.Right - info.rcWindow.Left);
                        config.SetValue("windowHeight", info.rcWindow.Bottom - info.rcWindow.Top);
                        config.SetValue("windowX", info.rcWindow.Left);
                        config.SetValue("windowY", info.rcWindow.Top);
                        config.SaveSettingsToFile("chconfig.cfg");
                    }

                    int width = info.rcClient.Right - info.rcClient.Left;
                    int height = info.rcClient.Bottom - info.rcClient.Top;
                    int sin = (int)(Math.Sin(DateTime.Now.TimeOfDay.TotalSeconds * 10) * width * 0.06);
                    int cos = (int)(Math.Cos(DateTime.Now.TimeOfDay.TotalSeconds * 10) * height * 0.07);
                    int randomD = (int)Math.Sqrt(Math.Sqrt(width * height));
                    int click_x = (int)(width * 0.725) + sin + config.GetValue<int>("offsetX");
                    int click_y = (int)(height * 0.55) + cos + config.GetValue<int>("offsetY");

                    if (randomize)
                    {
                        random = new Random(random.Next(0, (int)Environment.TickCount));
                        click_x += random.Next(0, randomD) * (random.Next(0, 2) == 1 ? 1 : -1);
                        click_y += random.Next(0, randomD) * (random.Next(0, 2) == 1 ? 1 : -1);
                    }

                    if (advanceLevels && clicker)
                    {
                        int x = (int)(width * 0.81);
                        int y = (int)(height * 0.06);
                        int lParam = WinAPI.MakeLParam(x, y);
                        int wParam = 0;
                        WinAPI.SendMessage(proc.Process.MainWindowHandle, (uint)WinAPI.WindowMessage.WM_LBUTTONDOWN, wParam, lParam);
                        WinAPI.SendMessage(proc.Process.MainWindowHandle, (uint)WinAPI.WindowMessage.WM_LBUTTONUP, wParam, lParam);
                    }

                    if (clicker)
                    {

                        int lParam = WinAPI.MakeLParam(click_x, click_y);
                        int wParam = 0;
                        WinAPI.SendMessage(proc.Process.MainWindowHandle, (uint)WinAPI.WindowMessage.WM_LBUTTONDOWN, wParam, lParam);
                        WinAPI.SendMessage(proc.Process.MainWindowHandle, (uint)WinAPI.WindowMessage.WM_LBUTTONUP, wParam, lParam);
                    }

                    if (castSpells)
                    {
                        for (uint i = 0; i < 10; i++)
                        {
                            uint key = (uint)WinAPI.VirtualKeyShort.KEY_0 + i;
                            uint scanCode = WinAPI.MapVirtualKey(key, 0);
                            uint lParam = lParam = (0x00000001 | (scanCode << 16));

                            WinAPI.SendMessage(proc.Process.MainWindowHandle, (uint)WinAPI.WindowMessage.WM_KEYDOWN, (int)key, (int)lParam);
                            WinAPI.SendMessage(proc.Process.MainWindowHandle, (uint)WinAPI.WindowMessage.WM_KEYUP, (int)key, (int)lParam);
                        }
                    }

                    if (drawing)
                    {

                        Point[] tmp = new Point[trail.Length];
                        Array.Copy(trail, 1, tmp, 0, trail.Length - 1);
                        trail = tmp;
                        trail[trail.Length - 1] = new Point(click_x, click_y);
                        try
                        {
                            using (Graphics g = Graphics.FromHwnd(proc.Process.MainWindowHandle))
                            {
                                g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

                                g.DrawRectangle(Pens.Black, width / 2f, 0, width / 2f, height);

                                StringBuilder builder = new StringBuilder();
                                builder.AppendLine("ClickerHeroes - ExternalUtilsCSharp");
                                builder.AppendFormat("Autoclicker: {0}\n", clicker.ToString());
                                builder.AppendFormat("Randomize: {0}\n", randomize.ToString());
                                builder.AppendFormat("Cast spells: {0}\n", castSpells.ToString());
                                builder.AppendFormat("Offsets (x,y): {0} {1}\n", config.GetValue<int>("offsetX").ToString(), config.GetValue<int>("offsetY").ToString());
                                builder.AppendFormat("Current Window size (w,h): {0} {1}\n", (info.rcWindow.Right - info.rcWindow.Left).ToString(), (info.rcWindow.Bottom - info.rcWindow.Top).ToString());
                                builder.AppendFormat("Current Window coords (x,y): {0} {1}\n", info.rcWindow.Left.ToString(), info.rcWindow.Top.ToString());
                                builder.AppendFormat("Saved Window size (w,h): {0} {1}\n", config.GetValue<int>("windowWidth").ToString(), config.GetValue<int>("windowHeight").ToString());
                                builder.AppendFormat("Saved Window coords (x,y): {0} {1}", config.GetValue<int>("windowX").ToString(), config.GetValue<int>("windowY").ToString());

                                using (Font fnt = new Font("Courier New", 8))
                                {
                                    string text = builder.ToString();
                                    SizeF size = g.MeasureString(text, fnt);
                                    g.FillRectangle(Brushes.Black, width / 2f, 0, size.Width + 8, size.Height + 8);
                                    g.DrawString(text, fnt, Brushes.Red, width / 2f + 4, 4);
                                }

                                for (int i = trail.Length - 1; i >= 1; i--)
                                {
                                    if (trail[i].X != 0 && trail[i].Y != 0 && trail[i - 1].X != 0 && trail[i - 1].Y != 0)
                                    {
                                        g.DrawLine(Pens.Red, trail[i], trail[i - 1]);
                                    }
                                }
                                g.FillEllipse(Brushes.Red, click_x - 8, click_y - 8, 16, 16);
                                int x = (int)(width * 0.81);
                                int y = (int)(height * 0.06);
                                g.FillEllipse(Brushes.Red, x - 8, y - 8, 16, 16);
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Drawing failed: {0}", ex.Message);
                        }
                    }
                }
            }
        }
        public static void Main(string[] args)
        {
            System.Windows.Forms.Application.EnableVisualStyles();
            System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
            Console.Title = "SteamMonsterGame";

            Console.WriteLine("> Waiting for steam to start up...");
            while (!ProcUtils.ProcessIsRunning("Steam"))
                Thread.Sleep(250);

            proc = new ProcUtils("Steam", WinAPI.ProcessAccessFlags.QueryLimitedInformation);
            hWnd = IntPtr.Zero;

            Console.WriteLine("> Waiting for steam-window to start up...");
            do
                hWnd = WinAPI.FindWindowByCaption(hWnd, "Steam");
            while (hWnd == IntPtr.Zero);

            Console.WriteLine("> Initializing utils");
            keys = new KeyUtils();
            lastClickerPos = new Vector2();

            Console.WriteLine("> Initializing overlay");
            using (overlay = new SharpDXOverlay())
            {
                overlay.ChildControls.Clear();
                Console.WriteLine("> Attaching overlay");
                overlay.Attach(hWnd);
                overlay.TickEvent += overlay_TickEvent;
                overlay.DrawOnlyWhenInForeground = false;
                overlay.BeforeDrawingEvent += overlay_BeforeDrawingEvent;

                Console.WriteLine("> Setting up fonts");
                SharpDXRenderer renderer = overlay.Renderer;
                renderer.CreateFont("smallFont", "Century Gothic", 12f);
                renderer.CreateFont("tallFont", "Century Gothic", 16f);

                Console.WriteLine("> Initializing controls");
                InitializeComponent();

                Console.WriteLine("> Setting up controls");
                lblCaption.Font = renderer.GetFont("tallFont");
                lblDescription.Font = renderer.GetFont("smallFont");
                btnToggleMenu.Font = renderer.GetFont("smallFont");

                wndWindow.Font = renderer.GetFont("tallFont");
                lblAutomation.Font = renderer.GetFont("smallFont");
                chbAutoClicker.Font = renderer.GetFont("smallFont");
                chbMoveMouse.Font = renderer.GetFont("smallFont");
                rdbUsePost.Font = renderer.GetFont("smallFont");
                rdbUseSend.Font = renderer.GetFont("smallFont");
                lblVisuals.Font = renderer.GetFont("smallFont");
                chbVisDrawClicker.Font = renderer.GetFont("smallFont");
                lblPerformance.Font = renderer.GetFont("smallFont");
                lblFpsLogic.Font = renderer.GetFont("smallFont");
                lblFpsLogicAverage.Font = renderer.GetFont("smallFont");
                lblFpsDraw.Font = renderer.GetFont("smallFont");
                lblFpsDrawAverage.Font = renderer.GetFont("smallFont");

                pnlPanel.ChildControls.Clear();
                pnlPanel.AddChildControl(lblCaption);
                pnlPanel.AddChildControl(lblDescription);
                pnlPanel.InsertSpacer();
                pnlPanel.AddChildControl(btnToggleMenu);

                wndWindow.Panel.AddChildControl(lblAutomation);
                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(chbAutoClicker);
                wndWindow.Panel.AddChildControl(chbMoveMouse);
                wndWindow.Panel.AddChildControl(rdbUsePost);
                wndWindow.Panel.AddChildControl(rdbUseSend);

                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(lblVisuals);
                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(chbVisDrawClicker);

                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(lblPerformance);
                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(lblFpsLogic);
                wndWindow.Panel.AddChildControl(pgbFpsLogic);
                wndWindow.Panel.AddChildControl(lblFpsLogicAverage);
                wndWindow.Panel.AddChildControl(lblFpsDraw);
                wndWindow.Panel.AddChildControl(pgbFpsDraw);
                wndWindow.Panel.AddChildControl(lblFpsDrawAverage);

                overlay.ChildControls.Add(pnlPanel);
                overlay.ChildControls.Add(wndWindow);
                overlay.ChildControls.Add(clkWindow);

                Console.WriteLine("> Running overlay (close this console to terminate!)");
                System.Windows.Forms.Application.Run(overlay);
            }
        }
        public static void Main(string[] args)
        {
            System.Windows.Forms.Application.EnableVisualStyles();
            System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);

            while (!ProcUtils.ProcessIsRunning("Clicker Heroes"))
                Thread.Sleep(250);

            InitializeComponent();

            proc = new ProcUtils("Clicker Heroes", WinAPI.ProcessAccessFlags.QueryLimitedInformation);
            keys = new KeyUtils();
            lastClickerPos = new Vector2();
            using (overlay = new SharpDXOverlay())
            {
                overlay.ChildControls.Clear();
                overlay.Attach(proc.Process.MainWindowHandle);
                overlay.TickEvent += overlay_TickEvent;
                overlay.DrawOnlyWhenInForeground = false;
                overlay.BeforeDrawingEvent += overlay_BeforeDrawingEvent;

                SharpDXRenderer renderer = overlay.Renderer;
                renderer.CreateFont("smallFont", "Century Gothic", 12f);
                renderer.CreateFont("tallFont", "Century Gothic", 16f);

                lblCaption.Font = renderer.GetFont("tallFont");
                lblDescription.Font = renderer.GetFont("smallFont");
                btnToggleMenu.Font = renderer.GetFont("smallFont");

                wndWindow.Font = renderer.GetFont("tallFont");
                lblAutomation.Font = renderer.GetFont("smallFont");
                chbAutoClicker.Font = renderer.GetFont("smallFont");
                chbAutoSpells.Font = renderer.GetFont("smallFont");
                rdbUsePost.Font = renderer.GetFont("smallFont");
                rdbUseSend.Font = renderer.GetFont("smallFont");
                lblVisuals.Font = renderer.GetFont("smallFont");
                chbVisDrawClicker.Font = renderer.GetFont("smallFont");
                chbVisDrawLevels.Font = renderer.GetFont("smallFont");
                lblPerformance.Font = renderer.GetFont("smallFont");
                lblFpsLogic.Font = renderer.GetFont("smallFont");
                lblFpsLogicAverage.Font = renderer.GetFont("smallFont");
                lblFpsDraw.Font = renderer.GetFont("smallFont");
                lblFpsDrawAverage.Font = renderer.GetFont("smallFont");

                segments.Width = overlay.Width;
                segments.Height = overlay.Height;

                pnlPanel.ChildControls.Clear();
                pnlPanel.AddChildControl(lblCaption);
                pnlPanel.AddChildControl(lblDescription);
                pnlPanel.InsertSpacer();
                pnlPanel.AddChildControl(btnToggleMenu);

                wndWindow.Panel.AddChildControl(lblAutomation);
                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(chbAutoClicker);
                wndWindow.Panel.AddChildControl(chbAutoSpells);
                wndWindow.Panel.AddChildControl(rdbUsePost);
                wndWindow.Panel.AddChildControl(rdbUseSend);

                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(lblVisuals);
                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(chbVisDrawClicker);
                wndWindow.Panel.AddChildControl(chbVisDrawLevels);

                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(lblPerformance);
                wndWindow.Panel.InsertSpacer();
                wndWindow.Panel.AddChildControl(lblFpsLogic);
                wndWindow.Panel.AddChildControl(pgbFpsLogic);
                wndWindow.Panel.AddChildControl(lblFpsLogicAverage);
                wndWindow.Panel.AddChildControl(lblFpsDraw);
                wndWindow.Panel.AddChildControl(pgbFpsDraw);
                wndWindow.Panel.AddChildControl(lblFpsDrawAverage);

                overlay.ChildControls.Add(pnlPanel);
                overlay.ChildControls.Add(segments);
                overlay.ChildControls.Add(wndWindow);
                System.Windows.Forms.Application.Run(overlay);
            }
        }
        private static void Loop()
        {
            ProcUtils proc;
            ProcessModule swtorModule = null;
            ProcessModule memoryManModule = null;

            while (!ProcUtils.ProcessIsRunning("swtor") && m_bWork) { Thread.Sleep(500); }
            if (!m_bWork)
                return;

            Process swtor = Process.GetProcessesByName("swtor").FirstOrDefault(p => string.IsNullOrWhiteSpace(p.MainWindowTitle));
            proc = new ProcUtils(swtor, WinAPI.ProcessAccessFlags.VirtualMemoryRead | WinAPI.ProcessAccessFlags.VirtualMemoryWrite | WinAPI.ProcessAccessFlags.VirtualMemoryOperation);
            MemUtils.Handle = proc.Handle;

            while (swtorModule == null) { swtorModule = proc.GetModuleByName("swtor.exe"); }
            while (memoryManModule == null) { memoryManModule = proc.GetModuleByName("MemoryMan.dll"); }

            int swrba = swtorModule.BaseAddress.ToInt32();
            int mma = memoryManModule.BaseAddress.ToInt32();
            int pb = MemUtils.Read<int>((IntPtr)(swrba) + 0x01412EA4);

            float prev_x = 0.0f;
            float prev_y = 0.0f;
            float prev_z = 0.0f;

            byte[] nop = { 0x90, 0x90, 0x90, 0x90, 0x90 };
            byte[] up_down_bytes = { 0xF3, 0x0F, 0x11, 0x46, 0x0C };

            while (proc.IsRunning && m_bWork)
            {
                Thread.Sleep((int)(1000f / 60f));

                //Don't do anything if game is not in foreground
                //if (WinAPI.GetForegroundWindow() != proc.Process.MainWindowHandle)
                //    continue;

                int xyz2 = MemUtils.Read<int>((IntPtr)(pb) + 0x18);
                IntPtr xyz = (IntPtr)(xyz2) + 0x14;

                IntPtr x_address = (IntPtr)(xyz);
                IntPtr y_address = (IntPtr)(xyz + 0x04);
                IntPtr z_address = (IntPtr)(xyz + 0x08);

                float x = MemUtils.Read<float>(x_address);
                float y = MemUtils.Read<float>(y_address);
                float z = MemUtils.Read<float>(z_address);

                #region Handling input
                keyUtils.Update();
                Console.WriteLine("X: " + x + " Y: " + y + " Z: " + z);
                //if (keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.ESCAPE))
                //    m_bWork = false;
                if (keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.NUMPAD1) && keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.KEY_W)) // FORWARD
                    MemUtils.Write<float>((IntPtr)(z_address), prev_z -= 0.15f);
                if (keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.NUMPAD1) && keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.KEY_A)) // LEFT
                    MemUtils.Write<float>((IntPtr)(x_address), prev_x -= 0.15f);
                if (keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.NUMPAD1) && keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.KEY_S)) // BACK
                    MemUtils.Write<float>((IntPtr)(z_address), prev_z += 0.15f);
                if (keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.NUMPAD1) && keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.KEY_D)) // RIGHT
                    MemUtils.Write<float>((IntPtr)(x_address), prev_x += 0.15f);
                if (keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.NUMPAD1) && keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.SPACE)) // UP
                    MemUtils.Write<float>((IntPtr)(y_address), prev_y + 0.10f);
                if (keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.NUMPAD1) && keyUtils.KeyIsDown(WinAPI.VirtualKeyShort.CONTROL)) // DOWN
                    MemUtils.Write<float>((IntPtr)(y_address), prev_y - 0.10f);

                #endregion
                prev_x = x;
                prev_y = y;
                prev_z = z;

            }
        }
 /// <summary>
 /// Initializes a new ProcUtils
 /// </summary>
 /// <param name="process">Process-object of the process</param>
 /// <param name="handleFlags">ProcessAccessFlags to use</param>
 public ProcUtils(Process process, WinAPI.ProcessAccessFlags handleFlags)
 {
     this.Process = process;
     this.Handle  = ProcUtils.OpenHandleByProcess(process, handleFlags);
 }
        public static void Main(string[] args)
        {
            System.Windows.Forms.Application.EnableVisualStyles();
            System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);

            PrintSuccess("[>]=-- Zat's CSGO-ESP");
            KeyUtils = new KeyUtils();
            ConfigUtils = new CSGOConfigUtils();

            ConfigUtils.SetValue("espEnabled", true);
            ConfigUtils.SetValue("espBox", false);
            ConfigUtils.SetValue("espSkeleton", true);
            ConfigUtils.SetValue("espName", false);
            ConfigUtils.SetValue("espHealth", true);

            ConfigUtils.SetValue("aimEnabled", true);
            ConfigUtils.SetValue("aimKey", WinAPI.VirtualKeyShort.XBUTTON1);
            ConfigUtils.SetValue("aimToggle", false);
            ConfigUtils.SetValue("aimHold", true);
            ConfigUtils.SetValue("aimFov", 30f);
            ConfigUtils.SetValue("aimSmoothEnabled", true);
            ConfigUtils.SetValue("aimSmoothValue", 0.2f);
            ConfigUtils.SetValue("aimFilterSpotted", false);
            ConfigUtils.SetValue("aimFilterSpottedBy", false);
            ConfigUtils.SetValue("aimFilterEnemies", true);
            ConfigUtils.SetValue("aimFilterAllies", false);

            ConfigUtils.SetValue("rcsEnabled", true);
            ConfigUtils.SetValue("rcsForce", 100f);

            ConfigUtils.ReadSettingsFromFile("euc_csgo.cfg");

            PrintInfo("> Waiting for CSGO to start up...");
            while (!ProcUtils.ProcessIsRunning("csgo"))
                Thread.Sleep(250);

            ProcUtils = new ProcUtils("csgo", WinAPI.ProcessAccessFlags.VirtualMemoryRead | WinAPI.ProcessAccessFlags.VirtualMemoryWrite | WinAPI.ProcessAccessFlags.VirtualMemoryOperation);
            MemUtils = new ExternalUtilsCSharp.MemUtils();
            MemUtils.Handle = ProcUtils.Handle;

            PrintInfo("> Waiting for CSGOs window to show up...");
            while ((hWnd = WinAPI.FindWindowByCaption(hWnd, "Counter-Strike: Global Offensive")) == IntPtr.Zero)
                Thread.Sleep(250);

            ProcessModule clientDll, engineDll;
            PrintInfo("> Waiting for CSGO to load client.dll...");
            while ((clientDll = ProcUtils.GetModuleByName(@"bin\client.dll")) == null)
                Thread.Sleep(250);
            PrintInfo("> Waiting for CSGO to load engine.dll...");
            while ((engineDll = ProcUtils.GetModuleByName(@"engine.dll")) == null)
                Thread.Sleep(250);

            Framework = new Framework(clientDll, engineDll);

            PrintInfo("> Initializing overlay");
            using (SHDXOverlay = new SharpDXOverlay())
            {
                SHDXOverlay.Attach(hWnd);
                SHDXOverlay.TickEvent += overlay_TickEvent;

                InitializeComponents();
                SharpDXRenderer renderer = SHDXOverlay.Renderer;
                TextFormat smallFont = renderer.CreateFont("smallFont", "Century Gothic", 10f);
                TextFormat largeFont = renderer.CreateFont("largeFont", "Century Gothic", 14f);
                TextFormat heavyFont = renderer.CreateFont("heavyFont", "Century Gothic", 14f, FontStyle.Normal, FontWeight.Heavy);

                windowMenu.Font = smallFont;
                windowMenu.Caption.Font = largeFont;
                windowGraphs.Font = smallFont;
                windowGraphs.Caption.Font = largeFont;
                windowSpectators.Font = smallFont;
                windowSpectators.Caption.Font = largeFont;
                graphMemRead.Font = smallFont;
                graphMemWrite.Font = smallFont;
                for (int i = 0; i < ctrlPlayerESP.Length; i++)
                {
                    ctrlPlayerESP[i].Font = heavyFont;
                    SHDXOverlay.ChildControls.Add(ctrlPlayerESP[i]);
                }
                ctrlRadar.Font = smallFont;

                windowMenu.ApplySettings(ConfigUtils);

                SHDXOverlay.ChildControls.Add(ctrlRadar);
                SHDXOverlay.ChildControls.Add(windowMenu);
                SHDXOverlay.ChildControls.Add(windowGraphs);
                SHDXOverlay.ChildControls.Add(windowSpectators);
                SHDXOverlay.ChildControls.Add(cursor);
                PrintInfo("> Running overlay");
                System.Windows.Forms.Application.Run(SHDXOverlay);
            }
            ConfigUtils.SaveSettingsToFile("euc_csgo.cfg");
        }