LFSPro Launcher 1.5.3.7 - CruiseTweak.dll

//LFSPro Launcher 1.5.3.7
//CruiseTweak.dll
//http://lfspro.net/query/__CruiseTweak.dll

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Timers;
using System.Windows.Forms;
using LFS;  // Memory edit class https://pastebin.com/NKpwbW7G

namespace CruiseTweak
{
    // Token: 0x02000004 RID: 4
    public class CruiseTweak : Form
    {
        // Token: 0x06000019 RID: 25 RVA: 0x00002710 File Offset: 0x00000910
        public CruiseTweak()
        {
            this.InitializeComponent();
            this.WriteDefaultValues();
            base.ShowInTaskbar = false;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            base.ShowInTaskbar = false;
            base.Hide();
            string[] commandLineArgs = Environment.GetCommandLineArgs();
            base.Shown += this.StartWatchdogs;
            this.Username = commandLineArgs[1].Replace("$", " ");
            this.Password = commandLineArgs[2].Replace("$", " ");
            this.LastUsername = this.Username;
            this.PlayerValidate();
            base.FormClosing += this.FormClose;
            base.FormClosed += this.FormClose1;
            this.TweakWrite_500ms.Enabled = true;
            this.TweakWrite_500ms.Elapsed += this.TweakWrite_500ms_Elapsed;
            this.TweakWrite_2Sec.Enabled = true;
            this.TweakWrite_2Sec.Elapsed += this.TweakWrite_2Sec_Elapsed;
            this.TweakRead_6Sec.Enabled = true;
            this.TweakRead_6Sec.Elapsed += this.TweakRead_6Sec_Elapsed;
            this.TweakRead_100ms.Enabled = true;
            this.TweakRead_100ms.Elapsed += this.TweakRead_100ms_Elapsed;
            this.FuelRead_6Sec.Enabled = true;
            this.FuelRead_6Sec.Elapsed += this.FuelRead_6Sec_Elapsed;
            this.FuelSave_20Sec.Enabled = true;
            this.FuelSave_20Sec.Elapsed += this.FuelSave_20Sec_Elapsed;
            this.PlayerSave_60Sec.Enabled = true;
            this.PlayerSave_60Sec.Elapsed += this.PlayerSave_60Sec_Elapsed;
            this.Watchdog.Enabled = true;
            this.Watchdog.Elapsed += this.Watchdog_Elapsed;
        }

        // Token: 0x0600001A RID: 26 RVA: 0x00002A50 File Offset: 0x00000C50
        private void FormClose(object sender, FormClosingEventArgs e)
        {
            try
            {
                string value = "Taskkill /IM x86Watchdog.dll /F";
                string value2 = "Taskkill /IM x64Watchdog.dll /F";
                Process process = new Process();
                process.StartInfo.FileName = "cmd.exe";
                process.StartInfo.RedirectStandardInput = true;
                process.StartInfo.RedirectStandardOutput = true;
                process.StartInfo.CreateNoWindow = true;
                process.StartInfo.UseShellExecute = false;
                process.Start();
                process.StandardInput.WriteLine(value);
                process.StandardInput.Flush();
                process.StandardInput.WriteLine(value2);
                process.StandardInput.Flush();
                process.StandardInput.Close();
                process.WaitForExit();
                Console.WriteLine(process.StandardOutput.ReadToEnd());
            }
            catch
            {
            }
            Environment.Exit(1);
            Application.Exit();
        }

        // Token: 0x0600001B RID: 27 RVA: 0x00002B38 File Offset: 0x00000D38
        private void FormClose1(object sender, FormClosedEventArgs e)
        {
            try
            {
                string value = "Taskkill /IM x86Watchdog.dll /F";
                string value2 = "Taskkill /IM x64Watchdog.dll /F";
                Process process = new Process();
                process.StartInfo.FileName = "cmd.exe";
                process.StartInfo.RedirectStandardInput = true;
                process.StartInfo.RedirectStandardOutput = true;
                process.StartInfo.CreateNoWindow = true;
                process.StartInfo.UseShellExecute = false;
                process.Start();
                process.StandardInput.WriteLine(value);
                process.StandardInput.Flush();
                process.StandardInput.WriteLine(value2);
                process.StandardInput.Flush();
                process.StandardInput.Close();
                process.WaitForExit();
                Console.WriteLine(process.StandardOutput.ReadToEnd());
            }
            catch
            {
            }
        }

        // Token: 0x0600001C RID: 28 RVA: 0x00002C14 File Offset: 0x00000E14
        private void StartWatchdogs(object sender, EventArgs e)
        {
            try
            {
                string value = "Taskkill /IM x86Watchdog.dll /F";
                string value2 = "Taskkill /IM x64Watchdog.dll /F";
                Process process = new Process();
                process.StartInfo.FileName = "cmd.exe";
                process.StartInfo.RedirectStandardInput = true;
                process.StartInfo.RedirectStandardOutput = true;
                process.StartInfo.CreateNoWindow = true;
                process.StartInfo.UseShellExecute = false;
                process.Start();
                process.StandardInput.WriteLine(value);
                process.StandardInput.Flush();
                process.StandardInput.WriteLine(value2);
                process.StandardInput.Flush();
                process.StandardInput.Close();
                process.WaitForExit();
                Console.WriteLine(process.StandardOutput.ReadToEnd());
                base.Invoke(new Action(delegate
                {
                    CruiseTweak.StartAProcess("x86Watchdog.dll");
                }));
                base.Invoke(new Action(delegate
                {
                    this.Archteture();
                }));
            }
            catch (Exception ex)
            {
            }
        }

        // Token: 0x0600001D RID: 29 RVA: 0x00002D28 File Offset: 0x00000F28
        private void Archteture()
        {
            try
            {
                bool flag = Marshal.SizeOf(typeof(IntPtr)) == 8;
                if (flag)
                {
                    this.X64 = true;
                    CruiseTweak.StartAProcess("x64Watchdog.dll");
                }
            }
            catch (Exception ex)
            {
            }
        }

        // Token: 0x0600001E RID: 30 RVA: 0x00002D7C File Offset: 0x00000F7C
        private static void StartAProcess(string proc)
        {
            try
            {
                Process process = Process.Start(new ProcessStartInfo(proc)
                {
                    UseShellExecute = false
                });
            }
            catch (Exception ex)
            {
            }
        }

        // Token: 0x0600001F RID: 31 RVA: 0x00002DBC File Offset: 0x00000FBC
        private void Watchdog_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                this.SetPlayerUsingLauncher++;
                bool flag = this.SetPlayerUsingLauncher >= 6;
                if (flag)
                {
                    this.SetPlayerUsingLauncher = 0;
                    int num = new Random().Next(1, 200);
                    WebClient webClient = new WebClient();
                    webClient.OpenRead(new Uri(string.Concat(new object[]
                    {
                        "http://35.198.16.153/query/lfspro_launcher_savelog.php?Username=",
                        this.Username,
                        "&Password=",
                        this.Password,
                        "&Checksum=",
                        num
                    })));
                }
                this.CheckPlayerChanged();
                bool flag2 = false;
                bool flag3 = false;
                Process[] processes = Process.GetProcesses();
                foreach (Process process in processes)
                {
                    try
                    {
                        bool flag4 = process.MainModule.FileVersionInfo.FileDescription.Contains("x64Watchdog");
                        if (flag4)
                        {
                            flag2 = true;
                        }
                        bool flag5 = process.MainModule.FileVersionInfo.FileDescription.Contains("x86Watchdog");
                        if (flag5)
                        {
                            flag3 = true;
                        }
                    }
                    catch
                    {
                    }
                }
                bool flag6 = !flag2 && !flag3;
                if (flag6)
                {
                    base.Close();
                }
            }
            catch (Exception ex)
            {
            }
        }

        // Token: 0x06000020 RID: 32 RVA: 0x00002F34 File Offset: 0x00001134
        private void PlayerValidate()
        {
            try
            {
                string value = (from nic in NetworkInterface.GetAllNetworkInterfaces()
                where nic.OperationalStatus == OperationalStatus.Up
                select nic.GetPhysicalAddress().ToString()).FirstOrDefault<string>();
                string text = Convert.ToString(value);
                bool flag = text.Length < 3;
                if (flag)
                {
                    text = "NOADDFOUND";
                }
                WebBrowser webBrowser = new WebBrowser();
                webBrowser.Navigate(new Uri(string.Concat(new string[]
                {
                    "http://lfspro.net/query/lfspro_launcher_register.php?Username=",
                    this.Username,
                    "&Password=",
                    this.Password,
                    "&Checksum=",
                    text,
                    "&Version=",
                    Assembly.GetExecutingAssembly().GetName().Version.ToString()
                })));
                while (webBrowser.ReadyState != WebBrowserReadyState.Complete)
                {
                    Application.DoEvents();
                }
                string text2 = webBrowser.Document.Body.InnerHtml.ToString();
                bool flag2 = text2.Contains("User OK");
                if (flag2)
                {
                    this.PlayerValidated = true;
                }
                else
                {
                    this.PlayerValidated = false;
                    this.WriteDefaultValues();
                }
            }
            catch
            {
            }
        }

        // Token: 0x06000021 RID: 33 RVA: 0x000030A0 File Offset: 0x000012A0
        private void CheckPlayerChanged()
        {
            Process[] processesByName = Process.GetProcessesByName("LFS");
            bool flag = processesByName.Length != 0;
            if (flag)
            {
                using (Memory memory = new Memory(processesByName[0]))
                {
                    IntPtr address = memory.GetAddress("\"LFS.exe\"+00051124+0");
                    byte[] array = new byte[23];
                    memory.ReadMemory(address, array, 23);
                    string a = Encoding.UTF8.GetString(array).Trim(new char[1]);
                    bool flag2 = a != this.Username;
                    if (flag2)
                    {
                        this.PlayerValidate();
                    }
                }
            }
        }

        // Token: 0x06000022 RID: 34 RVA: 0x00003144 File Offset: 0x00001344
        private void WriteDefaultValues()
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (Memory memory = new Memory(processesByName[0]))
                    {
                        IntPtr address = memory.GetAddress("\"LFS.exe\"+000C7918+4");
                        IntPtr address2 = memory.GetAddress("\"LFS.exe\"+000C79BC+0");
                        IntPtr address3 = memory.GetAddress("\"LFS.exe\"+000C79F4+1C");
                        IntPtr address4 = memory.GetAddress("\"LFS.exe\"+000C7FB8+4");
                        float value = 0.143f;
                        memory.WriteFloat(address, value);
                        memory.WriteFloat(address2, value);
                        memory.WriteFloat(address3, value);
                        memory.WriteFloat(address4, value);
                        IntPtr address5 = memory.GetAddress("\"LFS.exe\"+0013A364+10");
                        IntPtr address6 = memory.GetAddress("\"LFS.exe\"+000C7BC4+4");
                        float value2 = 0.19f;
                        memory.WriteFloat(address5, value2);
                        memory.WriteFloat(address6, value2);
                        IntPtr address7 = memory.GetAddress("\"LFS.exe\"+000C7904+0");
                        IntPtr address8 = memory.GetAddress("\"LFS.exe\"+000C7994+4");
                        IntPtr address9 = memory.GetAddress("\"LFS.exe\"+000C79F4+10");
                        IntPtr address10 = memory.GetAddress("\"LFS.exe\"+000C7FA4+0");
                        float value3 = 1.6f;
                        memory.WriteFloat(address7, value3);
                        memory.WriteFloat(address8, value3);
                        memory.WriteFloat(address9, value3);
                        memory.WriteFloat(address10, value3);
                        IntPtr address11 = memory.GetAddress("\"LFS.exe\"+0013A364+4");
                        IntPtr address12 = memory.GetAddress("\"LFS.exe\"+000C7AD4+10");
                        float value4 = 2.225f;
                        memory.WriteFloat(address11, value4);
                        memory.WriteFloat(address12, value4);
                        IntPtr address13 = memory.GetAddress("\"LFS.exe\"+000C78F0+0");
                        IntPtr address14 = memory.GetAddress("\"LFS.exe\"+000C7954+C");
                        IntPtr address15 = memory.GetAddress("\"LFS.exe\"+000C7AD4+8");
                        IntPtr address16 = memory.GetAddress("\"LFS.exe\"+000C7B9C+0");
                        float value5 = 1000f;
                        memory.WriteFloat(address13, value5);
                        memory.WriteFloat(address14, value5);
                        memory.WriteFloat(address15, value5);
                        memory.WriteFloat(address16, value5);
                        IntPtr address17 = memory.GetAddress("\"LFS.exe\"+000C79F4+8");
                        IntPtr address18 = memory.GetAddress("\"LFS.exe\"+000C7F90+0");
                        float value6 = 400f;
                        memory.WriteFloat(address17, value6);
                        memory.WriteFloat(address18, value6);
                        IntPtr address19 = memory.GetAddress("\"LFS.exe\"+000C78D8+0");
                        byte[] bytes = BitConverter.GetBytes(memory.ReadInt32(address19));
                        byte[] array = bytes;
                        array[2] = 1;
                        byte[] value7 = new byte[]
                        {
                            array[0],
                            array[1],
                            array[2],
                            array[3]
                        };
                        int value8 = BitConverter.ToInt32(value7, 0);
                        memory.WriteInt32(address19, value8);
                        IntPtr address20 = memory.GetAddress("\"LFS.exe\"+000C7954+8");
                        byte[] bytes2 = BitConverter.GetBytes(memory.ReadInt32(address20));
                        byte[] array2 = bytes2;
                        array2[2] = 1;
                        byte[] value9 = new byte[]
                        {
                            array2[0],
                            array2[1],
                            array2[2],
                            array2[3]
                        };
                        int value10 = BitConverter.ToInt32(value9, 0);
                        memory.WriteInt32(address20, value10);
                        IntPtr address21 = memory.GetAddress("\"LFS.exe\"+000C79F4+4");
                        byte[] bytes3 = BitConverter.GetBytes(memory.ReadInt32(address21));
                        byte[] array3 = bytes3;
                        array3[2] = 1;
                        byte[] value11 = new byte[]
                        {
                            array3[0],
                            array3[1],
                            array3[2],
                            array3[3]
                        };
                        int value12 = BitConverter.ToInt32(value11, 0);
                        memory.WriteInt32(address21, value12);
                        IntPtr address22 = memory.GetAddress("\"LFS.exe\"+000C7AD4+4");
                        byte[] bytes4 = BitConverter.GetBytes(memory.ReadInt32(address22));
                        byte[] array4 = bytes4;
                        array4[2] = 1;
                        byte[] value13 = new byte[]
                        {
                            array4[0],
                            array4[1],
                            array4[2],
                            array4[3]
                        };
                        int value14 = BitConverter.ToInt32(value13, 0);
                        memory.WriteInt32(address22, value14);
                        IntPtr address23 = memory.GetAddress("\"LFS.exe\"+000C7B84+0");
                        byte[] bytes5 = BitConverter.GetBytes(memory.ReadInt32(address23));
                        byte[] array5 = bytes5;
                        array5[2] = 1;
                        byte[] value15 = new byte[]
                        {
                            array5[0],
                            array5[1],
                            array5[2],
                            array5[3]
                        };
                        int value16 = BitConverter.ToInt32(value15, 0);
                        memory.WriteInt32(address23, value16);
                        IntPtr address24 = memory.GetAddress("\"LFS.exe\"+000C7F3C+8");
                        byte[] bytes6 = BitConverter.GetBytes(memory.ReadInt32(address24));
                        byte[] array6 = bytes6;
                        array6[2] = 1;
                        byte[] value17 = new byte[]
                        {
                            array6[0],
                            array6[1],
                            array6[2],
                            array6[3]
                        };
                        int value18 = BitConverter.ToInt32(value17, 0);
                        memory.WriteInt32(address24, value18);
                        IntPtr address25 = memory.GetAddress("\"LFS.exe\"+0004F91C+10");
                        byte[] bytes7 = BitConverter.GetBytes(memory.ReadInt32(address25));
                        byte[] array7 = bytes7;
                        array7[2] = 3;
                        byte[] value19 = new byte[]
                        {
                            array7[0],
                            array7[1],
                            array7[2],
                            array7[3]
                        };
                        int value20 = BitConverter.ToInt32(value19, 0);
                        memory.WriteInt32(address25, value20);
                        IntPtr address26 = memory.GetAddress("\"LFS.exe\"+000C7954+4");
                        byte[] bytes8 = BitConverter.GetBytes(memory.ReadInt32(address26));
                        byte[] array8 = bytes8;
                        array8[2] = 3;
                        byte[] value21 = new byte[]
                        {
                            array8[0],
                            array8[1],
                            array8[2],
                            array8[3]
                        };
                        int value22 = BitConverter.ToInt32(value21, 0);
                        memory.WriteInt32(address26, value22);
                        IntPtr address27 = memory.GetAddress("\"LFS.exe\"+000C79F4+0");
                        byte[] bytes9 = BitConverter.GetBytes(memory.ReadInt32(address27));
                        byte[] array9 = bytes9;
                        array9[2] = 3;
                        byte[] value23 = new byte[]
                        {
                            array9[0],
                            array9[1],
                            array9[2],
                            array9[3]
                        };
                        int value24 = BitConverter.ToInt32(value23, 0);
                        memory.WriteInt32(address27, value24);
                        IntPtr address28 = memory.GetAddress("\"LFS.exe\"+000C7AD4+0");
                        byte[] bytes10 = BitConverter.GetBytes(memory.ReadInt32(address28));
                        byte[] array10 = bytes10;
                        array10[2] = 3;
                        byte[] value25 = new byte[]
                        {
                            array10[0],
                            array10[1],
                            array10[2],
                            array10[3]
                        };
                        int value26 = BitConverter.ToInt32(value25, 0);
                        memory.WriteInt32(address28, value26);
                        IntPtr address29 = memory.GetAddress("\"LFS.exe\"+0013A364+30");
                        byte[] bytes11 = BitConverter.GetBytes(memory.ReadInt32(address29));
                        byte[] array11 = bytes11;
                        array11[2] = 3;
                        byte[] value27 = new byte[]
                        {
                            array11[0],
                            array11[1],
                            array11[2],
                            array11[3]
                        };
                        int value28 = BitConverter.ToInt32(value27, 0);
                        memory.WriteInt32(address29, value28);
                        IntPtr address30 = memory.GetAddress("\"LFS.exe\"+000C7F3C+4");
                        byte[] bytes12 = BitConverter.GetBytes(memory.ReadInt32(address30));
                        byte[] array12 = bytes12;
                        array12[2] = 3;
                        byte[] value29 = new byte[]
                        {
                            array12[0],
                            array12[1],
                            array12[2],
                            array12[3]
                        };
                        int value30 = BitConverter.ToInt32(value29, 0);
                        memory.WriteInt32(address30, value30);
                        IntPtr address31 = memory.GetAddress("\"LFS.exe\"+0004F91C+8");
                        IntPtr address32 = memory.GetAddress("\"LFS.exe\"+000C7940+4");
                        IntPtr address33 = memory.GetAddress("\"LFS.exe\"+000C79E4+0");
                        IntPtr address34 = memory.GetAddress("\"LFS.exe\"+0013A364+28");
                        IntPtr address35 = memory.GetAddress("\"LFS.exe\"+000C7F2C+C");
                        float value31 = 0.15f;
                        memory.WriteFloat(address31, value31);
                        memory.WriteFloat(address32, value31);
                        memory.WriteFloat(address33, value31);
                        memory.WriteFloat(address34, value31);
                        memory.WriteFloat(address35, value31);
                        IntPtr address36 = memory.GetAddress("\"LFS.exe\"+000C79F4+34");
                        float value32 = 0.1f;
                        memory.WriteFloat(address36, value32);
                        IntPtr address37 = memory.GetAddress("\"LFS.exe\"+000C792C+0");
                        IntPtr address38 = memory.GetAddress("\"LFS.exe\"+0013A364+14");
                        IntPtr address39 = memory.GetAddress("\"LFS.exe\"+000C7BD8+0");
                        float value33 = 0.6f;
                        memory.WriteFloat(address37, value33);
                        memory.WriteFloat(address38, value33);
                        memory.WriteFloat(address39, value33);
                        IntPtr address40 = memory.GetAddress("\"LFS.exe\"+000C79BC+4");
                        IntPtr address41 = memory.GetAddress("\"LFS.exe\"+000C79F4+20");
                        float value34 = 0.4f;
                        memory.WriteFloat(address40, value34);
                        memory.WriteFloat(address41, value34);
                        IntPtr address42 = memory.GetAddress("\"LFS.exe\"+000C7FCC+0");
                        float value35 = 0.2f;
                        memory.WriteFloat(address42, value35);
                        IntPtr address43 = memory.GetAddress("\"LFS.exe\"+1B60F0");
                        int value36 = 2;
                        memory.WriteInt32(address43, value36);
                        IntPtr address44 = memory.GetAddress("\"LFS.exe\"+1B6108");
                        float value37 = 1298.392f;
                        memory.WriteFloat(address44, value37);
                        IntPtr address45 = memory.GetAddress("\"LFS.exe\"+1B610C");
                        byte[] bytes13 = BitConverter.GetBytes(memory.ReadInt32(address45));
                        byte[] array13 = bytes13;
                        array13[3] = 4;
                        byte[] value38 = new byte[]
                        {
                            array13[0],
                            array13[1],
                            array13[2],
                            array13[3]
                        };
                        int value39 = BitConverter.ToInt32(value38, 0);
                        memory.WriteInt32(address45, value39);
                        IntPtr address46 = memory.GetAddress("\"LFS.exe\"+1B6118");
                        float value40 = 0.83f;
                        memory.WriteFloat(address46, value40);
                        IntPtr address47 = memory.GetAddress("\"LFS.exe\"+1B6128");
                        float value41 = 0.6f;
                        memory.WriteFloat(address47, value41);
                        IntPtr address48 = memory.GetAddress("\"LFS.exe\"+1B611C");
                        float value42 = 1f;
                        memory.WriteFloat(address48, value42);
                        IntPtr address49 = memory.GetAddress("\"LFS.exe\"+1B6100");
                        int value43 = 12;
                        memory.WriteInt32(address49, value43);
                        IntPtr address50 = memory.GetAddress("\"LFS.exe\"+1B6110");
                        float value44 = 1f;
                        memory.WriteFloat(address50, value44);
                        IntPtr address51 = memory.GetAddress("\"LFS.exe\"+1B6114");
                        float value45 = 0.4f;
                        memory.WriteFloat(address51, value45);
                        IntPtr address52 = memory.GetAddress("\"LFS.exe\"+1B6124");
                        float value46 = 837.7581f;
                        memory.WriteFloat(address52, value46);
                        IntPtr address53 = memory.GetAddress("\"LFS.exe\"+1B63E0");
                        float value47 = 45f;
                        memory.WriteFloat(address53, value47);
                        IntPtr address54 = memory.GetAddress("\"LFS.exe\"+1B60F8");
                        int value48 = 2;
                        memory.WriteInt32(address54, value48);
                        IntPtr address55 = memory.GetAddress("\"LFS.exe\"+1B60F4");
                        int value49 = 1;
                        memory.WriteInt32(address55, value49);
                        IntPtr address56 = memory.GetAddress("\"LFS.exe\"+1B63B8");
                        float value50 = 1.125f;
                        memory.WriteFloat(address56, value50);
                        IntPtr address57 = memory.GetAddress("\"LFS.exe\"+1B63AC");
                        float value51 = -1.39881074f;
                        memory.WriteFloat(address57, value51);
                        IntPtr address58 = memory.GetAddress("\"LFS.exe\"+1B63BC");
                        float value52 = 0.3f;
                        memory.WriteFloat(address58, value52);
                        IntPtr address59 = memory.GetAddress("\"LFS.exe\"+1B6D50");
                        float value53 = 0.4f;
                        memory.WriteFloat(address59, value53);
                        IntPtr address60 = memory.GetAddress("\"LFS.exe\"+1B6850");
                        float value54 = 0.185f;
                        memory.WriteFloat(address60, value54);
                        IntPtr address61 = memory.GetAddress("\"LFS.exe\"+1B6854");
                        float value55 = 0.5f;
                        memory.WriteFloat(address61, value55);
                        IntPtr address62 = memory.GetAddress("\"LFS.exe\"+1B685C");
                        float value56 = 0.1778f;
                        memory.WriteFloat(address62, value56);
                        IntPtr address63 = memory.GetAddress("\"LFS.exe\"+1B6858");
                        float value57 = 0.190499991f;
                        memory.WriteFloat(address63, value57);
                        IntPtr address64 = memory.GetAddress("\"LFS.exe\"+1B6878");
                        float value58 = 0.063f;
                        memory.WriteFloat(address64, value58);
                        IntPtr address65 = memory.GetAddress("\"LFS.exe\"+1B683C");
                        float value59 = 1.36f;
                        memory.WriteFloat(address65, value59);
                        IntPtr address66 = memory.GetAddress("\"LFS.exe\"+1B6874");
                        float value60 = 0.209439516f;
                        memory.WriteFloat(address66, value60);
                        IntPtr address67 = memory.GetAddress("\"LFS.exe\"+1B67FC");
                        float value61 = 0.941f;
                        memory.WriteFloat(address67, value61);
                        IntPtr address68 = memory.GetAddress("\"LFS.exe\"+1B6808");
                        float value62 = 0.941f;
                        memory.WriteFloat(address68, value62);
                        IntPtr address69 = memory.GetAddress("\"LFS.exe\"+1B7770");
                        byte[] bytes14 = BitConverter.GetBytes(memory.ReadInt32(address69));
                        byte[] array14 = bytes14;
                        array14[0] = 2;
                        byte[] value63 = new byte[]
                        {
                            array14[0],
                            array14[1],
                            array14[2],
                            array14[3]
                        };
                        int value64 = BitConverter.ToInt32(value63, 0);
                        memory.WriteInt32(address69, value64);
                        IntPtr address70 = memory.GetAddress("\"LFS.exe\"+1B7788");
                        float value65 = 1800f;
                        memory.WriteFloat(address70, value65);
                        IntPtr address71 = memory.GetAddress("\"LFS.exe\"+1B778C");
                        byte[] bytes15 = BitConverter.GetBytes(memory.ReadInt32(address71));
                        byte[] array15 = bytes15;
                        array15[0] = 4;
                        byte[] value66 = new byte[]
                        {
                            array15[0],
                            array15[1],
                            array15[2],
                            array15[3]
                        };
                        int value67 = BitConverter.ToInt32(value66, 0);
                        memory.WriteInt32(address71, value67);
                        IntPtr address72 = memory.GetAddress("\"LFS.exe\"+1B7798");
                        float value68 = 0.854347467f;
                        memory.WriteFloat(address72, value68);
                        IntPtr address73 = memory.GetAddress("\"LFS.exe\"+1B77A8");
                        float value69 = 0.5625002f;
                        memory.WriteFloat(address73, value69);
                        IntPtr address74 = memory.GetAddress("\"LFS.exe\"+1B779C");
                        float value70 = 1f;
                        memory.WriteFloat(address74, value70);
                        IntPtr address75 = memory.GetAddress("\"LFS.exe\"+1B7780");
                        int value71 = 12;
                        memory.WriteInt32(address75, value71);
                        IntPtr address76 = memory.GetAddress("\"LFS.exe\"+1B7790");
                        float value72 = 1f;
                        memory.WriteFloat(address76, value72);
                        IntPtr address77 = memory.GetAddress("\"LFS.exe\"+1B7794");
                        float value73 = 0.4f;
                        memory.WriteFloat(address77, value73);
                        IntPtr address78 = memory.GetAddress("\"LFS.exe\"+1B77A4");
                        float value74 = 733.0383f;
                        memory.WriteFloat(address78, value74);
                        IntPtr address79 = memory.GetAddress("\"LFS.exe\"+1B7A60");
                        float value75 = 65f;
                        memory.WriteFloat(address79, value75);
                        IntPtr address80 = memory.GetAddress("\"LFS.exe\"+1B7778");
                        int value76 = 1;
                        memory.WriteInt32(address80, value76);
                        IntPtr address81 = memory.GetAddress("\"LFS.exe\"+1B7774");
                        int value77 = 1;
                        memory.WriteInt32(address81, value77);
                        IntPtr address82 = memory.GetAddress("\"LFS.exe\"+1B7A38");
                        float value78 = 1.50000012f;
                        memory.WriteFloat(address82, value78);
                        IntPtr address83 = memory.GetAddress("\"LFS.exe\"+1B7A3C");
                        float value79 = 0.532142758f;
                        memory.WriteFloat(address83, value79);
                        IntPtr address84 = memory.GetAddress("\"LFS.exe\"+1B7A2C");
                        float value80 = -1.49107027f;
                        memory.WriteFloat(address84, value80);
                        IntPtr address85 = memory.GetAddress("\"LFS.exe\"+1B9580");
                        float value81 = 0.4f;
                        memory.WriteFloat(address85, value81);
                        IntPtr address86 = memory.GetAddress("\"LFS.exe\"+1B7F78");
                        float value82 = 0.185f;
                        memory.WriteFloat(address86, value82);
                        IntPtr address87 = memory.GetAddress("\"LFS.exe\"+1B7F7C");
                        float value83 = 0.55f;
                        memory.WriteFloat(address87, value83);
                        IntPtr address88 = memory.GetAddress("\"LFS.exe\"+1B7F84");
                        float value84 = 0.1778f;
                        memory.WriteFloat(address88, value84);
                        IntPtr address89 = memory.GetAddress("\"LFS.exe\"+1B7F80");
                        float value85 = 0.2032f;
                        memory.WriteFloat(address89, value85);
                        IntPtr address90 = memory.GetAddress("\"LFS.exe\"+1B7FA0");
                        float value86 = 0.072f;
                        memory.WriteFloat(address90, value86);
                        IntPtr address91 = memory.GetAddress("\"LFS.exe\"+1B7F9C");
                        float value87 = 0.2007129f;
                        memory.WriteFloat(address91, value87);
                        IntPtr address92 = memory.GetAddress("\"LFS.exe\"+1B7F0C");
                        float value88 = 1.126572f;
                        memory.WriteFloat(address92, value88);
                        IntPtr address93 = memory.GetAddress("\"LFS.exe\"+1B7F18");
                        float value89 = 1.126572f;
                        memory.WriteFloat(address93, value89);
                        IntPtr address94 = memory.GetAddress("\"LFS.exe\"+1B7F60");
                        float value90 = 0.09517069f;
                        memory.WriteFloat(address94, value90);
                        IntPtr address95 = memory.GetAddress("\"LFS.exe\"+1B7F38");
                        float value91 = 0.22f;
                        memory.WriteFloat(address95, value91);
                        IntPtr address96 = memory.GetAddress("\"LFS.exe\"+1B7F3C");
                        float value92 = 0.5f;
                        memory.WriteFloat(address96, value92);
                        IntPtr address97 = memory.GetAddress("\"LFS.exe\"+1B7F44");
                        float value93 = 0.1905f;
                        memory.WriteFloat(address97, value93);
                        IntPtr address98 = memory.GetAddress("\"LFS.exe\"+1B7F40");
                        float value94 = 0.2032f;
                        memory.WriteFloat(address98, value94);
                        IntPtr address99 = memory.GetAddress("\"LFS.exe\"+1B7F5C");
                        float value95 = 0.2007129f;
                        memory.WriteFloat(address99, value95);
                        IntPtr address100 = memory.GetAddress("\"LFS.exe\"+1B7F24");
                        float value96 = -1.326286f;
                        memory.WriteFloat(address100, value96);
                        IntPtr address101 = memory.GetAddress("\"LFS.exe\"+1B7F30");
                        float value97 = -1.326286f;
                        memory.WriteFloat(address101, value97);
                        IntPtr address102 = memory.GetAddress("\"LFS.exe\"+000C792C+C");
                        IntPtr address103 = memory.GetAddress("\"LFS.exe\"+000C79D0+4");
                        IntPtr address104 = memory.GetAddress("\"LFS.exe\"+000C79F4+2C");
                        IntPtr address105 = memory.GetAddress("\"LFS.exe\"+000C7FDC+4");
                        float value98 = 104.71f;
                        memory.WriteFloat(address102, value98);
                        memory.WriteFloat(address103, value98);
                        memory.WriteFloat(address104, value98);
                        memory.WriteFloat(address105, value98);
                        IntPtr address106 = memory.GetAddress("\"LFS.exe\"+0013A364+20");
                        float value99 = 209.42f;
                        memory.WriteFloat(address106, value99);
                        IntPtr address107 = memory.GetAddress("\"LFS.exe\"+000C7BD8+C");
                        float value100 = 157.064941f;
                        memory.WriteFloat(address107, value100);
                        IntPtr address108 = memory.GetAddress("\"LFS.exe\"+005AAEE4+1FC+504");
                        double num = memory.ReadDouble(address108);
                        bool flag2 = num > 1.0;
                        if (flag2)
                        {
                            float value101 = 1f;
                            memory.WriteFloat(address108, value101);
                        }
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x06000023 RID: 35 RVA: 0x00004280 File Offset: 0x00002480
        private void WriteCustomValues()
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (Memory memory = new Memory(processesByName[0]))
                    {
                        IntPtr address = memory.GetAddress("\"LFS.exe\"+0002E130+0");
                        byte[] bytes = BitConverter.GetBytes(memory.ReadFloat(address));
                        IntPtr address2 = memory.GetAddress("\"LFS.exe\"+0002E130+4");
                        byte[] bytes2 = BitConverter.GetBytes(memory.ReadFloat(address2));
                        IntPtr address3 = memory.GetAddress("\"LFS.exe\"+0002E130+8");
                        byte[] bytes3 = BitConverter.GetBytes(memory.ReadFloat(address3));
                        string @string = Encoding.UTF8.GetString(bytes);
                        string string2 = Encoding.UTF8.GetString(bytes2);
                        string string3 = Encoding.UTF8.GetString(bytes3);
                        string text = @string + string2 + string3;
                        text = text.Replace("UF 1000", "UF1").Replace("XR GT TURBO", "XRT").Replace("XR GTR", "XRR").Replace("FZ50 GTR", "FZR").Replace("XF GTI", "XFG").Replace("XR GT", "XRG").Replace("LX4", "LX4").Replace("LX6", "LX6").Replace("RB4 GT", "RB4").Replace("FXO TURBO", "FXO").Replace("RACEABOUT", "RAC").Replace("FZ50", "FZ5").Replace("UF GTR", "UFR").Replace("XF GTR", "XFR").Replace("FXO GTR", "FXR").Replace("MRT5", "MRT").Replace("FORMULA BMW ", "FBM").Replace("FORMULA XR", "FOX").Replace("FORMULA V8", "FO8").Replace("BMW SAUBER F", "BF1");
                        text = text.Substring(0, 3);
                        int num = 0;
                        try
                        {
                            IntPtr address4 = memory.GetAddress("\"LFS.exe\"+005AAEE4+1F8");
                            num = memory.ReadInt32(address4);
                        }
                        catch
                        {
                            num = 0;
                        }
                        int num2 = 0;
                        bool flag2 = false;
                        int num3 = 0;
                        double num4 = 0.0;
                        int num5 = 0;
                        double num6 = 0.0;
                        double num7 = 0.0;
                        int num8 = 0;
                        string str = "";
                        while (num2 < 64 && !flag2)
                        {
                            str = str + this.CustomCarName[num2] + " ";
                            bool flag3 = this.CustomCarName[num2] == text;
                            if (flag3)
                            {
                                num3 = this.CustomCarTCS[num2];
                                num4 = this.CustomCarEngine[num2];
                                num5 = this.CustomCarTurboEnabled[num2];
                                num6 = this.CustomCarTurboPressure[num2];
                                num7 = this.CustomCarClutch[num2];
                                num8 = this.CustomCarGears[num2];
                                flag2 = true;
                            }
                            num2++;
                        }
                        bool flag4 = flag2;
                        if (flag4)
                        {
                            bool flag5 = text == "UF1" || text == "XFG" || text == "XRG";
                            if (flag5)
                            {
                                IntPtr address5 = memory.GetAddress("\"LFS.exe\"+000C79BC+0");
                                float value = (float)num4;
                                memory.WriteFloat(address5, value);
                                IntPtr address6 = memory.GetAddress("\"LFS.exe\"+000C7954+4");
                                byte[] bytes4 = BitConverter.GetBytes(memory.ReadInt32(address6));
                                byte[] array = bytes4;
                                array[2] = (byte)(num8 + 2);
                                byte[] value2 = new byte[]
                                {
                                    array[0],
                                    array[1],
                                    array[2],
                                    array[3]
                                };
                                int value3 = BitConverter.ToInt32(value2, 0);
                                memory.WriteInt32(address6, value3);
                            }
                            else
                            {
                                bool flag6 = text == "MRT";
                                if (flag6)
                                {
                                    IntPtr address7 = memory.GetAddress("\"LFS.exe\"+000C7FB8+4");
                                    float value4 = (float)num4;
                                    memory.WriteFloat(address7, value4);
                                    IntPtr address8 = memory.GetAddress("\"LFS.exe\"+000C7F3C+4");
                                    byte[] bytes5 = BitConverter.GetBytes(memory.ReadInt32(address8));
                                    byte[] array2 = bytes5;
                                    array2[2] = (byte)(num8 + 2);
                                    byte[] value5 = new byte[]
                                    {
                                        array2[0],
                                        array2[1],
                                        array2[2],
                                        array2[3]
                                    };
                                    int value6 = BitConverter.ToInt32(value5, 0);
                                    memory.WriteInt32(address8, value6);
                                }
                                else
                                {
                                    bool flag7 = text == "UFR" || text == "XFR" || text == "FXR" || text == "XRR" || text == "FZR";
                                    if (flag7)
                                    {
                                        IntPtr address9 = memory.GetAddress("\"LFS.exe\"+000C7BC4+4");
                                        float value7 = (float)num4;
                                        memory.WriteFloat(address9, value7);
                                        IntPtr address10 = memory.GetAddress("\"LFS.exe\"+0013A364+30");
                                        byte[] bytes6 = BitConverter.GetBytes(memory.ReadInt32(address10));
                                        byte[] array3 = bytes6;
                                        array3[2] = (byte)(num8 + 2);
                                        byte[] value8 = new byte[]
                                        {
                                            array3[0],
                                            array3[1],
                                            array3[2],
                                            array3[3]
                                        };
                                        int value9 = BitConverter.ToInt32(value8, 0);
                                        memory.WriteInt32(address10, value9);
                                    }
                                    else
                                    {
                                        bool flag8 = text == "FBM" || text == "FOX" || text == "FO8";
                                        if (flag8)
                                        {
                                            IntPtr address11 = memory.GetAddress("\"LFS.exe\"+0013A364+10");
                                            float value10 = (float)num4;
                                            memory.WriteFloat(address11, value10);
                                            IntPtr address12 = memory.GetAddress("\"LFS.exe\"+000C7AD4+0");
                                            byte[] bytes7 = BitConverter.GetBytes(memory.ReadInt32(address12));
                                            byte[] array4 = bytes7;
                                            array4[2] = (byte)(num8 + 2);
                                            byte[] value11 = new byte[]
                                            {
                                                array4[0],
                                                array4[1],
                                                array4[2],
                                                array4[3]
                                            };
                                            int value12 = BitConverter.ToInt32(value11, 0);
                                            memory.WriteInt32(address12, value12);
                                        }
                                        else
                                        {
                                            bool flag9 = text == "XRT" || text == "RB4" || text == "FZ5" || text == "LX4" || text == "LX6" || text == "RAC" || text == "FXO";
                                            if (flag9)
                                            {
                                                IntPtr address13 = memory.GetAddress("\"LFS.exe\"+000C7918+4");
                                                float value13 = (float)num4;
                                                memory.WriteFloat(address13, value13);
                                                IntPtr address14 = memory.GetAddress("\"LFS.exe\"+0004F91C+10");
                                                byte[] bytes8 = BitConverter.GetBytes(memory.ReadInt32(address14));
                                                byte[] array5 = bytes8;
                                                array5[2] = (byte)(num8 + 2);
                                                byte[] value14 = new byte[]
                                                {
                                                    array5[0],
                                                    array5[1],
                                                    array5[2],
                                                    array5[3]
                                                };
                                                int value15 = BitConverter.ToInt32(value14, 0);
                                                memory.WriteInt32(address14, value15);
                                            }
                                        }
                                    }
                                }
                            }
                            bool flag10 = num != 0;
                            if (flag10)
                            {
                                try
                                {
                                    IntPtr address15 = memory.GetAddress("\"LFS.exe\"+005AAEE4+1F8+500");
                                    float value16 = (float)num7;
                                    memory.WriteFloat(address15, value16);
                                    bool flag11 = num3 == 1;
                                    if (flag11)
                                    {
                                        IntPtr address16 = memory.GetAddress("\"LFS.exe\"+00438690+9C+768");
                                        int num9 = memory.ReadInt32(address16);
                                        memory.WriteInt32(address16, 1);
                                    }
                                    bool flag12 = num5 == 1;
                                    if (flag12)
                                    {
                                        IntPtr address17 = memory.GetAddress("\"LFS.exe\"+0042D4D8+1E8+488");
                                        int value17 = 13;
                                        memory.WriteInt32(address17, value17);
                                        IntPtr address18 = memory.GetAddress("\"LFS.exe\"+005AAEE4+1F8+4A8");
                                        float value18 = (float)num6;
                                        memory.WriteFloat(address18, value18);
                                    }
                                    else
                                    {
                                        IntPtr address19 = memory.GetAddress("\"LFS.exe\"+0042D4D8+1E8+488");
                                        int value19 = 12;
                                        memory.WriteInt32(address19, value19);
                                    }
                                }
                                catch
                                {
                                }
                            }
                        }
                        else
                        {
                            this.WriteDefaultValues();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
            }
        }

        // Token: 0x06000024 RID: 36 RVA: 0x00004A98 File Offset: 0x00002C98
        private void TweakWrite_500ms_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (Memory memory = new Memory(processesByName[0]))
                    {
                        IntPtr address = memory.GetAddress("\"LFS.exe\"+005AAEE4+1F8");
                        int num = memory.ReadInt32(address);
                        bool flag2 = num == 0;
                        if (flag2)
                        {
                            this.WriteCustomValues();
                        }
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x06000025 RID: 37 RVA: 0x00004B24 File Offset: 0x00002D24
        private void TweakWrite_2Sec_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (new Memory(processesByName[0]))
                    {
                        this.WriteCustomValues();
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x06000026 RID: 38 RVA: 0x00004B8C File Offset: 0x00002D8C
        private void TweakRead_6Sec_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (Memory memory = new Memory(processesByName[0]))
                    {
                        IntPtr address = memory.GetAddress("\"LFS.exe\"+0042D4D8+1E8+E50");
                        float num = memory.ReadFloat(address);
                        IntPtr address2 = memory.GetAddress("\"LFS.exe\"+005AAEE4+1F8");
                        int num2 = memory.ReadInt32(address2);
                        bool flag2 = num < 3f || num2 == 0;
                        if (flag2)
                        {
                            this.ReadPlayerCarsFromDB();
                        }
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x06000027 RID: 39 RVA: 0x00004C40 File Offset: 0x00002E40
        private void TweakRead_100ms_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (Memory memory = new Memory(processesByName[0]))
                    {
                        IntPtr address = memory.GetAddress("\"LFS.exe\"+0002E130+0");
                        byte[] bytes = BitConverter.GetBytes(memory.ReadFloat(address));
                        IntPtr address2 = memory.GetAddress("\"LFS.exe\"+0002E130+4");
                        byte[] bytes2 = BitConverter.GetBytes(memory.ReadFloat(address2));
                        IntPtr address3 = memory.GetAddress("\"LFS.exe\"+0002E130+8");
                        byte[] bytes3 = BitConverter.GetBytes(memory.ReadFloat(address3));
                        string @string = Encoding.UTF8.GetString(bytes);
                        string string2 = Encoding.UTF8.GetString(bytes2);
                        string string3 = Encoding.UTF8.GetString(bytes3);
                        string text = @string + string2 + string3;
                        text = text.Replace("UF 1000", "UF1").Replace("XR GT TURBO", "XRT").Replace("XR GTR", "XRR").Replace("FZ50 GTR", "FZR").Replace("XF GTI", "XFG").Replace("XR GT", "XRG").Replace("LX4", "LX4").Replace("LX6", "LX6").Replace("RB4 GT", "RB4").Replace("FXO TURBO", "FXO").Replace("RACEABOUT", "RAC").Replace("FZ50", "FZ5").Replace("UF GTR", "UFR").Replace("XF GTR", "XFR").Replace("FXO GTR", "FXR").Replace("MRT5", "MRT").Replace("FORMULA BMW ", "FBM").Replace("FORMULA XR", "FOX").Replace("FORMULA V8", "FO8").Replace("BMW SAUBER F", "BF1");
                        text = text.Substring(0, 3);
                        bool flag2 = text != this.CurrentCar;
                        if (flag2)
                        {
                            this.ReadPlayerCarsFromDB();
                            this.WriteCustomValues();
                            this.CurrentCar = text;
                        }
                        IntPtr address4 = memory.GetAddress("\"LFS.exe\"+005AAEE4+1F8");
                        int num = memory.ReadInt32(address4);
                        bool flag3 = num == 0;
                        if (flag3)
                        {
                            this.PlayerPitted = true;
                        }
                        else
                        {
                            bool flag4 = num != 0 && this.PlayerPitted;
                            if (flag4)
                            {
                                this.PlayerPitted = false;
                                this.FuelWriteDelay = true;
                            }
                        }
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x06000028 RID: 40 RVA: 0x00004EFC File Offset: 0x000030FC
        private void ReadPlayerCarsFromDB()
        {
            try
            {
                WebClient webClient = new WebClient();
                Stream stream = webClient.OpenRead(new Uri("http://35.198.16.153/query/lfspro_launcher_carspecs.php?Username=" + this.Username));
                StreamReader streamReader = new StreamReader(stream);
                string text = streamReader.ReadToEnd();
                string[] array = text.Split(new char[]
                {
                    '|'
                });
                bool flag = false;
                int num = 0;
                while (!flag)
                {
                    bool flag2 = array[num].Length > 1;
                    if (flag2)
                    {
                        string[] array2 = array[num].Split(new char[]
                        {
                            '$'
                        });
                        this.CustomCarName[num] = array2[0];
                        this.CustomCarTCS[num] = Convert.ToInt32(array2[1]);
                        this.CustomCarEngine[num] = double.Parse(array2[2], CultureInfo.InvariantCulture);
                        this.CustomCarTurboPressure[num] = double.Parse(array2[3], CultureInfo.InvariantCulture);
                        this.CustomCarTurboEnabled[num] = Convert.ToInt32(array2[4]);
                        this.CustomCarClutch[num] = double.Parse(array2[5], CultureInfo.InvariantCulture);
                        this.CustomCarGears[num] = Convert.ToInt32(array2[6]);
                    }
                    else
                    {
                        flag = true;
                    }
                    num++;
                }
            }
            catch
            {
            }
        }

        // Token: 0x06000029 RID: 41 RVA: 0x00005054 File Offset: 0x00003254
        private void FuelRead_6Sec_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (Memory memory = new Memory(processesByName[0]))
                    {
                        float num = 0f;
                        WebClient webClient = new WebClient();
                        Stream stream = webClient.OpenRead(new Uri("http://35.198.16.153/query/lfspro_launcher_fuelreload.php?Username=" + this.Username + "&Car=" + this.CurrentCar));
                        StreamReader streamReader = new StreamReader(stream);
                        string text = streamReader.ReadToEnd();
                        bool flag2 = text.Contains("1");
                        if (flag2)
                        {
                            WebClient webClient2 = new WebClient();
                            Stream stream2 = webClient2.OpenRead(new Uri("http://35.198.16.153/query/lfspro_launcher_readfuel.php?Username=" + this.Username + "&Car=" + this.CurrentCar));
                            StreamReader streamReader2 = new StreamReader(stream2);
                            string s = streamReader2.ReadToEnd();
                            num = float.Parse(s, CultureInfo.InvariantCulture);
                        }
                        IntPtr address = memory.GetAddress("\"LFS.exe\"+0042D4D8+1E8+650");
                        float num2 = memory.ReadFloat(address);
                        bool flag3 = num > num2 || this.FuelWriteDelay;
                        if (flag3)
                        {
                            this.WriteFuel();
                            this.FuelWriteDelay = false;
                        }
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x0600002A RID: 42 RVA: 0x000051B8 File Offset: 0x000033B8
        private void WriteFuel()
        {
            try
            {
                Process[] processesByName = Process.GetProcessesByName("LFS");
                bool flag = processesByName.Length != 0;
                if (flag)
                {
                    using (Memory memory = new Memory(processesByName[0]))
                    {
                        WebClient webClient = new WebClient();
                        Stream stream = webClient.OpenRead(new Uri("http://35.198.16.153/query/lfspro_launcher_readfuel.php?Username=" + this.Username + "&Car=" + this.CurrentCar));
                        StreamReader streamReader = new StreamReader(stream);
                        string s = streamReader.ReadToEnd();
                        float value = float.Parse(s, CultureInfo.InvariantCulture);
                        IntPtr address = memory.GetAddress("\"LFS.exe\"+0042D4D8+1E8+650");
                        memory.WriteFloat(address, value);
                        WebClient webClient2 = new WebClient();
                        webClient2.OpenRead(new Uri("http://35.198.16.153/query/lfspro_launcher_fuelreset.php?Username=" + this.Username + "&Car=" + this.CurrentCar));
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x0600002B RID: 43 RVA: 0x000052B4 File Offset: 0x000034B4
        private void FuelSave_20Sec_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                bool flag = !this.FuelWriteDelay;
                if (flag)
                {
                    Process[] processesByName = Process.GetProcessesByName("LFS");
                    bool flag2 = processesByName.Length != 0;
                    if (flag2)
                    {
                        using (Memory memory = new Memory(processesByName[0]))
                        {
                            IntPtr address = memory.GetAddress("\"LFS.exe\"+0042D4D8+1E8+650");
                            float num = memory.ReadFloat(address);
                            WebClient webClient = new WebClient();
                            Stream stream = webClient.OpenRead(new Uri("http://35.198.16.153/query/lfspro_launcher_readfuel.php?Username=" + this.Username + "&Car=" + this.CurrentCar));
                            StreamReader streamReader = new StreamReader(stream);
                            string s = streamReader.ReadToEnd();
                            float num2 = float.Parse(s, CultureInfo.InvariantCulture);
                            string text = Convert.ToString(num).Replace(',', '.');
                            bool flag3 = num < num2;
                            if (flag3)
                            {
                                WebClient webClient2 = new WebClient();
                                webClient2.OpenRead(new Uri(string.Concat(new string[]
                                {
                                    "http://35.198.16.153/query/lfspro_launcher_savefuel.php?Username=",
                                    this.Username,
                                    "&Password=",
                                    this.Password,
                                    "&FL=",
                                    text,
                                    "&Car=",
                                    this.CurrentCar
                                })));
                            }
                        }
                    }
                }
            }
            catch
            {
            }
        }

        // Token: 0x0600002C RID: 44 RVA: 0x00005428 File Offset: 0x00003628
        private void PlayerSave_60Sec_Elapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                int num = new Random().Next(1, 200);
                WebBrowser webBrowser = new WebBrowser();
                webBrowser.Navigate(new Uri(string.Concat(new object[]
                {
                    "http://35.198.16.153/query/lfspro_launcher_savelog.php?Username=",
                    this.Username,
                    "&Password=",
                    this.Password,
                    "&Checksum=",
                    num
                })));
            }
            catch (Exception ex)
            {
            }
        }

        // Token: 0x0600002D RID: 45 RVA: 0x000054B0 File Offset: 0x000036B0
        protected override void Dispose(bool disposing)
        {
            bool flag = disposing && this.components != null;
            if (flag)
            {
                this.components.Dispose();
            }
            base.Dispose(disposing);
        }

        // Token: 0x0600002E RID: 46 RVA: 0x000054E8 File Offset: 0x000036E8
        private void InitializeComponent()
        {
            base.SuspendLayout();
            base.AutoScaleDimensions = new SizeF(6f, 13f);
            base.AutoScaleMode = AutoScaleMode.Font;
            base.ClientSize = new Size(0, 0);
            base.ControlBox = false;
            base.FormBorderStyle = FormBorderStyle.None;
            base.Name = "CruiseTweak";
            this.Text = "CruiseTweak";
            base.WindowState = FormWindowState.Minimized;
            base.ResumeLayout(false);
        }

        // Token: 0x04000005 RID: 5
        private bool X64 = false;

        // Token: 0x04000006 RID: 6
        private bool PlayerValidated = false;

        // Token: 0x04000007 RID: 7
        private bool FuelWriteDelay = false;

        // Token: 0x04000008 RID: 8
        private bool PlayerPitted = false;

        // Token: 0x04000009 RID: 9
        private string Username = "";

        // Token: 0x0400000A RID: 10
        private string Password = "";

        // Token: 0x0400000B RID: 11
        private string LastUsername = "";

        // Token: 0x0400000C RID: 12
        private string CurrentCar = "";

        // Token: 0x0400000D RID: 13
        private int SetPlayerUsingLauncher = 0;

        // Token: 0x0400000E RID: 14
        private string[] CustomCarName = new string[64];

        // Token: 0x0400000F RID: 15
        private int[] CustomCarTCS = new int[64];

        // Token: 0x04000010 RID: 16
        private double[] CustomCarEngine = new double[64];

        // Token: 0x04000011 RID: 17
        private int[] CustomCarTurboEnabled = new int[64];

        // Token: 0x04000012 RID: 18
        private double[] CustomCarTurboPressure = new double[64];

        // Token: 0x04000013 RID: 19
        private double[] CustomCarClutch = new double[64];

        // Token: 0x04000014 RID: 20
        private int[] CustomCarGears = new int[64];

        // Token: 0x04000015 RID: 21
        private System.Timers.Timer TweakWrite_500ms = new System.Timers.Timer(500.0);

        // Token: 0x04000016 RID: 22
        private System.Timers.Timer TweakWrite_2Sec = new System.Timers.Timer(2000.0);

        // Token: 0x04000017 RID: 23
        private System.Timers.Timer TweakRead_6Sec = new System.Timers.Timer(6000.0);

        // Token: 0x04000018 RID: 24
        private System.Timers.Timer TweakRead_100ms = new System.Timers.Timer(100.0);

        // Token: 0x04000019 RID: 25
        private System.Timers.Timer FuelRead_6Sec = new System.Timers.Timer(6000.0);

        // Token: 0x0400001A RID: 26
        private System.Timers.Timer FuelSave_20Sec = new System.Timers.Timer(20000.0);

        // Token: 0x0400001B RID: 27
        private System.Timers.Timer PlayerSave_60Sec = new System.Timers.Timer(60000.0);

        // Token: 0x0400001C RID: 28
        private System.Timers.Timer Watchdog = new System.Timers.Timer(10000.0);

        // Token: 0x0400001D RID: 29
        private IContainer components = null;
    }
}