Register for your free account! | Forgot your password?

You last visited: Today at 23:16

  • Please register to post and access all features, it's quick, easy and FREE!

 

Lyn 1.1.1

Reply
 
Old   #76
 
elite*gold: 0
Join Date: Jul 2010
Posts: 3
Received Thanks: 0
Quote:
Originally Posted by -BLUESCREEN- View Post
das sind doch schonmal worte um weiter zu kommen
danke ....
Weist du was ASM ist ???



C0nner is offline  
Old   #77
 
elite*gold: 0
Join Date: Nov 2010
Posts: 69
Received Thanks: 3
asm ist gay

bissle schwierig..
will den lyn code haben

hmmm...


-BLUESCREEN- is offline  
Old   #78
 
elite*gold: 5
Join Date: May 2010
Posts: 1,251
Received Thanks: 64
mh ja wasn nun ,funzt der jetzt gut oder nicht.
Funktioniert der so gut wie man es in den ganzen Vids z,z sieht oder wie :>
Dakushisai is offline  
Old   #79
 
elite*gold: 0
Join Date: Nov 2008
Posts: 141
Received Thanks: 3
stop flame/wine, someone is enough boned for find the code and update it ?


beefidus is offline  
Old   #80
 
elite*gold: 0
Join Date: Jul 2010
Posts: 3
Received Thanks: 0
Quote:
Originally Posted by -BLUESCREEN- View Post
asm ist gay

bissle schwierig..
will den lyn code haben

hmmm...
Ohne Asm wird es aber nicht gehen das ganze ist nicht mal eben ich mach mal das hat nichts damit zu tun ich mach mein cheatengine auf und such irgendwas und hab damit nen hack so einfach wird es dir nicht mehr gemacht wenn du kein asm kannst wird es ausehr Bots nichts des weiteren geben vergisst es Leute
C0nner is offline  
Old   #81
 
elite*gold: 0
Join Date: Nov 2010
Posts: 69
Received Thanks: 3
es wäre ganz schön wen du dich nur dazu meldest wen du auch was wichtiges beitragen kansnt ausser den leuten einen erzählen was sie können und was nicht.


hilfreicher wäre ein code von ihm mehr kann ich dazu nicht sagen.
denk was willst ^^
ich weiss was ich kann
-BLUESCREEN- is offline  
Old   #82
 
elite*gold: 0
Join Date: Jan 2006
Posts: 12
Received Thanks: 5
i tried to decompile the lyn and got this much so far i believe it was written in visual c. if everdox don't release the source we could is ida to disasemble lyn itself.
here is a snippet of the code:

Code:
namespace Lyn
{
    public __gc class Form1 : public Form
    {
        // Methods
        public: Form1()
        {
            try
            {
                this->InitializeComponent();
            }
            fault
            {
                base->Dispose(true);
            }
        }

        private: void __gc* ~Form1()
        {
            Container __gc* components = this->components;
            if (components != 0)
            {
                components->Dispose();
            }
        }

        private: void __gc* backgroundWorker1_DoWork(Object __gc* sender, DoWorkEventArgs __gc* e)
        {
            UInt32 __gc* num = 0;
            while (true)
            {
                basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* local9;
                UInt32 __gc* modopt(IsLong __gc*) num2 = (<Module>::PlayerPtr + 0x2c);
                *(*static_cast<__box Int32 __gc***>(&local9)) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                <Module>::std.basic_ios<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 80)));
                try
                {
                    num |= 1;
                    <Module>::std.basic_ostream<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local9), *static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc***>((&local9 + 4)), false, 0);
                    try
                    {
                        *(*static_cast<__box Int32 __gc***>(&local9))[4][*static_cast<__box Int32*>(&local9)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                        basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) pThis = *static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 4));
                        <Module>::std.basic_streambuf<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 4)));
                        try
                        {
                            *(*static_cast<__box Int32 __gc***>((&local9 + 4))) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                            *(*static_cast<__box Int32 __gc***>((&local9 + 0x40))) = 0;
                            *(*static_cast<__box Int32 __gc***>((&local9 + 0x44))) = 4;
                        }
                        fault
                        {
                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}, pThis);
                        }
                    }
                    fault
                    {
                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local9 + 8)));
                    }
                }
                fault
                {
                    if ((num & 1) != 0)
                    {
                        num &= 0xfffffffe;
                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local9 + 80)));
                    }
                }
                try
                {
                    basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local8;
                    *(*static_cast<__box Int32 __gc***>((&local8 + 20))) = 15;
                    *(*static_cast<__box Int32 __gc***>((&local8 + 0x10))) = 0;
                    *(*static_cast<__box SByte __gc***>(&local8)) = 0;
                    try
                    {
                        Single __gc* num3;
                        basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* local6;
                        basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local7;
                        <Module>::ReadProcessMemory(<Module>::hProcess, num2, *static_cast<__box void __gc***>(&num3), 4, 0);
                        <Module>::std.basic_ostream<char,std::char_traits<char> >.<<(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local9), num3);
                        basic_string<char,std::char_traits<char>,std::allocator<char> > __gc** localPtr3 = <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.str(*static_cast<__box basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* modopt(IsConst __gc*)* modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local9), &local7);
                        try
                        {
                            if (&local8 != localPtr3)
                            {
                                if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local8 + 20))))
                                {
                                    <Module>::delete(*(*static_cast<__box void __gc****>(&local8)));
                                }
                                *(*static_cast<__box Int32 __gc***>((&local8 + 20))) = 15;
                                *(*static_cast<__box Int32 __gc***>((&local8 + 0x10))) = 0;
                                *(*static_cast<__box SByte __gc***>(&local8)) = 0;
                                if (*(*static_cast<__box Int32 __gc***>((localPtr3 + 20))) < 0x10)
                                {
                                    UInt32 __gc* num6 = *static_cast<__box UInt32*>((*(*static_cast<__box Int32 __gc***>((localPtr3 + 0x10))) + 1));
                                    <Module>::memmove(*static_cast<__box void __gc***>(&local8), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(localPtr3), num6);
                                }
                                else
                                {
                                    *(*static_cast<__box Int32 __gc***>(&local8)) = *(*static_cast<__box Int32 __gc***>(localPtr3));
                                    *(*static_cast<__box Int32 __gc***>(localPtr3)) = 0;
                                }
                                *(*static_cast<__box Int32 __gc***>((&local8 + 0x10))) = *(*static_cast<__box Int32 __gc***>((localPtr3 + 0x10)));
                                *(*static_cast<__box Int32 __gc***>((&local8 + 20))) = *(*static_cast<__box Int32 __gc***>((localPtr3 + 20)));
                                *(*static_cast<__box Int32 __gc***>((localPtr3 + 0x10))) = 0;
                                *(*static_cast<__box Int32 __gc***>((localPtr3 + 20))) = 0;
                            }
                        }
                        fault
                        {
                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local7));
                        }
                        if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local7 + 20))))
                        {
                            <Module>::delete(*(*static_cast<__box void __gc****>(&local7)));
                        }
                        *(*static_cast<__box Int32 __gc***>((&local7 + 20))) = 15;
                        *(*static_cast<__box Int32 __gc***>((&local7 + 0x10))) = 0;
                        *(*static_cast<__box SByte __gc***>(&local7)) = 0;
                        String __gc* str3 = __gc new String(((0x10 > *(*static_cast<__box Int32 __gc***>((&local8 + 20)))) ? *static_cast<__box SByte __gc***>(&local8) : *static_cast<__box SByte __gc***>(*(*static_cast<__box Int32 __gc***>(&local8)))));
                        this->textBox4->Text = str3;
                        *(*static_cast<__box Int32 __gc***>(&local6)) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                        <Module>::std.basic_ios<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 80)));
                        try
                        {
                            num |= 2;
                            <Module>::std.basic_ostream<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local6), *static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc***>((&local6 + 4)), false, 0);
                            try
                            {
                                *(*static_cast<__box Int32 __gc***>(&local6))[4][*static_cast<__box Int32*>(&local6)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                                basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr11 = *static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 4));
                                <Module>::std.basic_streambuf<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 4)));
                                try
                                {
                                    *(*static_cast<__box Int32 __gc***>((&local6 + 4))) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                                    *(*static_cast<__box Int32 __gc***>((&local6 + 0x40))) = 0;
                                    *(*static_cast<__box Int32 __gc***>((&local6 + 0x44))) = 4;
                                }
                                fault
                                {
                                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}, localPtr11);
                                }
                            }
                            fault
                            {
                                <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local6 + 8)));
                            }
                        }
                        fault
                        {
                            if ((num & 2) != 0)
                            {
                                num &= 0xfffffffd;
                                <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local6 + 80)));
                            }
                        }
                        try
                        {
                            basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local5;
                            *(*static_cast<__box Int32 __gc***>((&local5 + 20))) = 15;
                            *(*static_cast<__box Int32 __gc***>((&local5 + 0x10))) = 0;
                            *(*static_cast<__box SByte __gc***>(&local5)) = 0;
                            try
                            {
                                basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* local3;
                                basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local4;
                                num2 += 4;
                                <Module>::ReadProcessMemory(<Module>::hProcess, num2, *static_cast<__box void __gc***>(&num3), 4, 0);
                                <Module>::std.basic_ostream<char,std::char_traits<char> >.<<(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local6), num3);
                                basic_string<char,std::char_traits<char>,std::allocator<char> > __gc** localPtr2 = <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.str(*static_cast<__box basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* modopt(IsConst __gc*)* modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local6), &local4);
                                try
                                {
                                    if (&local5 != localPtr2)
                                    {
                                        if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local5 + 20))))
                                        {
                                            <Module>::delete(*(*static_cast<__box void __gc****>(&local5)));
                                        }
                                        *(*static_cast<__box Int32 __gc***>((&local5 + 20))) = 15;
                                        *(*static_cast<__box Int32 __gc***>((&local5 + 0x10))) = 0;
                                        *(*static_cast<__box SByte __gc***>(&local5)) = 0;
                                        if (*(*static_cast<__box Int32 __gc***>((localPtr2 + 20))) < 0x10)
                                        {
                                            UInt32 __gc* num5 = *static_cast<__box UInt32*>((*(*static_cast<__box Int32 __gc***>((localPtr2 + 0x10))) + 1));
                                            <Module>::memmove(*static_cast<__box void __gc***>(&local5), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(localPtr2), num5);
                                        }
                                        else
                                        {
                                            *(*static_cast<__box Int32 __gc***>(&local5)) = *(*static_cast<__box Int32 __gc***>(localPtr2));
                                            *(*static_cast<__box Int32 __gc***>(localPtr2)) = 0;
                                        }
                                        *(*static_cast<__box Int32 __gc***>((&local5 + 0x10))) = *(*static_cast<__box Int32 __gc***>((localPtr2 + 0x10)));
                                        *(*static_cast<__box Int32 __gc***>((&local5 + 20))) = *(*static_cast<__box Int32 __gc***>((localPtr2 + 20)));
                                        *(*static_cast<__box Int32 __gc***>((localPtr2 + 0x10))) = 0;
                                        *(*static_cast<__box Int32 __gc***>((localPtr2 + 20))) = 0;
                                    }
                                }
                                fault
                                {
                                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local4));
                                }
                                if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local4 + 20))))
                                {
                                    <Module>::delete(*(*static_cast<__box void __gc****>(&local4)));
                                }
                                *(*static_cast<__box Int32 __gc***>((&local4 + 20))) = 15;
                                *(*static_cast<__box Int32 __gc***>((&local4 + 0x10))) = 0;
                                *(*static_cast<__box SByte __gc***>(&local4)) = 0;
                                String __gc* str2 = __gc new String(((0x10 > *(*static_cast<__box Int32 __gc***>((&local5 + 20)))) ? *static_cast<__box SByte __gc***>(&local5) : *static_cast<__box SByte __gc***>(*(*static_cast<__box Int32 __gc***>(&local5)))));
                                this->textBox5->Text = str2;
                                *(*static_cast<__box Int32 __gc***>(&local3)) = &<Module>::[email protected][email protected]@[email protected]@V?$allocato[email protected]@[email protected]@[email protected]@[email protected];
                                <Module>::std.basic_ios<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 80)));
                                try
                                {
                                    num |= 4;
                                    <Module>::std.basic_ostream<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local3), *static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc***>((&local3 + 4)), false, 0);
                                    try
                                    {
                                        *(*static_cast<__box Int32 __gc***>(&local3))[4][*static_cast<__box Int32*>(&local3)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                                        basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr10 = *static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 4));
                                        <Module>::std.basic_streambuf<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 4)));
                                        try
                                        {
                                            *(*static_cast<__box Int32 __gc***>((&local3 + 4))) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                                            *(*static_cast<__box Int32 __gc***>((&local3 + 0x40))) = 0;
                                            *(*static_cast<__box Int32 __gc***>((&local3 + 0x44))) = 4;
                                        }
                                        fault
                                        {
                                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}, localPtr10);
                                        }
                                    }
                                    fault
                                    {
                                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local3 + 8)));
                                    }
                                }
                                fault
                                {
                                    if ((num & 4) != 0)
                                    {
                                        num &= 0xfffffffb;
                                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local3 + 80)));
                                    }
                                }
                                try
                                {
                                    basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local2;
                                    *(*static_cast<__box Int32 __gc***>((&local2 + 20))) = 15;
                                    *(*static_cast<__box Int32 __gc***>((&local2 + 0x10))) = 0;
                                    *(*static_cast<__box SByte __gc***>(&local2)) = 0;
                                    try
                                    {
                                        basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local;
                                        num2 += 4;
                                        <Module>::ReadProcessMemory(<Module>::hProcess, num2, *static_cast<__box void __gc***>(&num3), 4, 0);
                                        <Module>::std.basic_ostream<char,std::char_traits<char> >.<<(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local3), num3);
                                        basic_string<char,std::char_traits<char>,std::allocator<char> > __gc** localPtr = <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.str(*static_cast<__box basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* modopt(IsConst __gc*)* modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local3), &local);
                                        try
                                        {
                                            if (&local2 != localPtr)
                                            {
                                                if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local2 + 20))))
                                                {
                                                    <Module>::delete(*(*static_cast<__box void __gc****>(&local2)));
                                                }
                                                *(*static_cast<__box Int32 __gc***>((&local2 + 20))) = 15;
                                                *(*static_cast<__box Int32 __gc***>((&local2 + 0x10))) = 0;
                                                *(*static_cast<__box SByte __gc***>(&local2)) = 0;
                                                if (*(*static_cast<__box Int32 __gc***>((localPtr + 20))) < 0x10)
                                                {
                                                    UInt32 __gc* num4 = *static_cast<__box UInt32*>((*(*static_cast<__box Int32 __gc***>((localPtr + 0x10))) + 1));
                                                    <Module>::memmove(*static_cast<__box void __gc***>(&local2), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(localPtr), num4);
                                                }
                                                else
                                                {
                                                    *(*static_cast<__box Int32 __gc***>(&local2)) = *(*static_cast<__box Int32 __gc***>(localPtr));
                                                    *(*static_cast<__box Int32 __gc***>(localPtr)) = 0;
                                                }
                                                *(*static_cast<__box Int32 __gc***>((&local2 + 0x10))) = *(*static_cast<__box Int32 __gc***>((localPtr + 0x10)));
                                                *(*static_cast<__box Int32 __gc***>((&local2 + 20))) = *(*static_cast<__box Int32 __gc***>((localPtr + 20)));
                                                *(*static_cast<__box Int32 __gc***>((localPtr + 0x10))) = 0;
                                                *(*static_cast<__box Int32 __gc***>((localPtr + 20))) = 0;
                                            }
                                        }
                                        fault
                                        {
                                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local));
                                        }
                                        if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local + 20))))
                                        {
                                            <Module>::delete(*(*static_cast<__box void __gc****>(&local)));
                                        }
                                        *(*static_cast<__box Int32 __gc***>((&local + 20))) = 15;
                                        *(*static_cast<__box Int32 __gc***>((&local + 0x10))) = 0;
                                        *(*static_cast<__box SByte __gc***>(&local)) = 0;
                                        String __gc* str = __gc new String(((0x10 > *(*static_cast<__box Int32 __gc***>((&local2 + 20)))) ? *static_cast<__box SByte __gc***>(&local2) : *static_cast<__box SByte __gc***>(*(*static_cast<__box Int32 __gc***>(&local2)))));
                                        this->textBox6->Text = str;
                                        <Module>::Sleep(0x5dc);
                                    }
                                    fault
                                    {
                                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local2));
                                    }
                                    if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local2 + 20))))
                                    {
                                        <Module>::delete(*(*static_cast<__box void __gc****>(&local2)));
                                    }
                                    *(*static_cast<__box Int32 __gc***>((&local2 + 20))) = 15;
                                    *(*static_cast<__box Int32 __gc***>((&local2 + 0x10))) = 0;
                                    *(*static_cast<__box SByte __gc***>(&local2)) = 0;
                                }
                                fault
                                {
                                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.__vbaseDtor, *static_cast<__box void __gc***>(&local3));
                                }
                                basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr9 = (&local3 + 80);
                                *(*static_cast<__box Int32 __gc***>(&local3))[4][*static_cast<__box Int32*>(&local3)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                                try
                                {
                                    basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr8 = *static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 4));
                                    *(*static_cast<__box Int32 __gc***>((&local3 + 4))) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                                    try
                                    {
                                        <Module>::std.basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >._Tidy(*static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 4)));
                                    }
                                    fault
                                    {
                                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}, localPtr8);
                                    }
                                    <Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 4)));
                                }
                                fault
                                {
                                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, ((localPtr9 - 80) + 8));
                                }
                                <Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 8)));
                                <Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 80)));
                            }
                            fault
                            {
                                <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local5));
                            }
                            if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local5 + 20))))
                            {
                                <Module>::delete(*(*static_cast<__box void __gc****>(&local5)));
                            }
                            *(*static_cast<__box Int32 __gc***>((&local5 + 20))) = 15;
                            *(*static_cast<__box Int32 __gc***>((&local5 + 0x10))) = 0;
                            *(*static_cast<__box SByte __gc***>(&local5)) = 0;
                        }
                        fault
                        {
                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.__vbaseDtor, *static_cast<__box void __gc***>(&local6));
                        }
                        basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr7 = (&local6 + 80);
                        *(*static_cast<__box Int32 __gc***>(&local6))[4][*static_cast<__box Int32*>(&local6)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                        try
                        {
                            basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr6 = *static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 4));
                            *(*static_cast<__box Int32 __gc***>((&local6 + 4))) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                            try
                            {
                                <Module>::std.basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >._Tidy(*static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 4)));
                            }
                            fault
                            {
                                <Module>::___CxxCallUnwindDtor(<Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}, localPtr6);
                            }
                            <Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 4)));
                        }
                        fault
                        {
                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, ((localPtr7 - 80) + 8));
                        }
                        <Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 8)));
                        <Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 80)));
                    }
                    fault
                    {
                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local8));
                    }
                    if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local8 + 20))))
                    {
                        <Module>::delete(*(*static_cast<__box void __gc****>(&local8)));
                    }
                    *(*static_cast<__box Int32 __gc***>((&local8 + 20))) = 15;
                    *(*static_cast<__box Int32 __gc***>((&local8 + 0x10))) = 0;
                    *(*static_cast<__box SByte __gc***>(&local8)) = 0;
                }
                fault
                {
                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.__vbaseDtor, *static_cast<__box void __gc***>(&local9));
                }
                basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr5 = (&local9 + 80);
                *(*static_cast<__box Int32 __gc***>(&local9))[4][*static_cast<__box Int32*>(&local9)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                try
                {
                    basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*) localPtr4 = *static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 4));
                    *(*static_cast<__box Int32 __gc***>((&local9 + 4))) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                    try
                    {
                        <Module>::std.basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >._Tidy(*static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 4)));
                    }
                    fault
                    {
                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}, localPtr4);
                    }
                    <Module>::std.basic_streambuf<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 4)));
                }
                fault
                {
                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, ((localPtr5 - 80) + 8));
                }
                <Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 8)));
                <Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 80)));
            }
        }

        private: void __gc* backgroundWorker2_DoWork(Object __gc* sender, DoWorkEventArgs __gc* e)
        {
            UInt32 __gc* modopt(IsLong __gc*) num12 = (<Module>::libBase + 0x335c);
            while (true)
            {
                Single __gc* num;
                Single __gc* num2;
                UInt32 __gc* modopt(IsLong __gc*) num3;
                <Module>::ReadProcessMemory(<Module>::hProcess, num12, &num3, 4, 0);
                num3 -= 0x24;
                <Module>::PlayerPtr = num3;
                if (<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 3)))) != 0)
                {
                    this->checkBox1->Checked = false;
                    this->checkBox1->ThreeState = true;
                    UInt32 __gc* modopt(IsLong __gc*) num7 = (<Module>::PlayerPtr + 0x30);
                    UInt32 __gc* modopt(IsLong __gc*) num6 = (<Module>::PlayerPtr + 0x84);
                    UInt32 __gc* modopt(IsLong __gc*) num11 = (<Module>::libBase + 0x1190);
                    <Module>::isdetour = true;
                    void __gc** voidPtr4 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num11, 1, 0, 0);
                    <Module>::WaitForSingleObject(voidPtr4, UInt32::MaxValue);
                    <Module>::CloseHandle(voidPtr4);
                    if (<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 3)))) != 0)
                    {
                        do
                        {
                            <Module>::ReadProcessMemory(<Module>::hProcess, num7, *static_cast<__box void __gc***>(&num2), 4, 0);
                            <Module>::ReadProcessMemory(<Module>::hProcess, num6, *static_cast<__box void __gc***>(&num), 4, 0);
                            num2 += *static_cast<__box Single*>(0.05);
                            num += *static_cast<__box Single*>(0.05);
                            <Module>::WriteProcessMemory(<Module>::hProcess, num7, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&num2), 4, 0);
                            <Module>::WriteProcessMemory(<Module>::hProcess, num6, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&num), 4, 0);
                            <Module>::Sleep(10);
                        }
                        while ((<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 3)))) != 0));
                    }
                    UInt32 __gc* modopt(IsLong __gc*) num10 = (<Module>::libBase + 0x1190);
                    <Module>::isdetour = false;
                    void __gc** voidPtr3 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num10, 0, 0, 0);
                    <Module>::WaitForSingleObject(voidPtr3, UInt32::MaxValue);
                    <Module>::CloseHandle(voidPtr3);
                    this->checkBox1->ThreeState = false;
                }
                if (<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 4)))) != 0)
                {
                    this->checkBox1->Checked = false;
                    this->checkBox1->ThreeState = true;
                    UInt32 __gc* modopt(IsLong __gc*) num5 = (<Module>::PlayerPtr + 0x30);
                    UInt32 __gc* modopt(IsLong __gc*) num4 = (<Module>::PlayerPtr + 0x84);
                    UInt32 __gc* modopt(IsLong __gc*) num9 = (<Module>::libBase + 0x1190);
                    <Module>::isdetour = true;
                    void __gc** voidPtr2 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num9, 1, 0, 0);
                    <Module>::WaitForSingleObject(voidPtr2, UInt32::MaxValue);
                    <Module>::CloseHandle(voidPtr2);
                    if (<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 4)))) != 0)
                    {
                        do
                        {
                            <Module>::ReadProcessMemory(<Module>::hProcess, num5, *static_cast<__box void __gc***>(&num2), 4, 0);
                            <Module>::ReadProcessMemory(<Module>::hProcess, num4, *static_cast<__box void __gc***>(&num), 4, 0);
                            num2 -= *static_cast<__box Single*>(0.05);
                            num -= *static_cast<__box Single*>(0.05);
                            <Module>::WriteProcessMemory(<Module>::hProcess, num5, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&num2), 4, 0);
                            <Module>::WriteProcessMemory(<Module>::hProcess, num4, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&num), 4, 0);
                            <Module>::Sleep(10);
                        }
                        while ((<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 4)))) != 0));
                    }
                    UInt32 __gc* modopt(IsLong __gc*) num8 = (<Module>::libBase + 0x1190);
                    <Module>::isdetour = false;
                    void __gc** voidPtr = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num8, 0, 0, 0);
                    <Module>::WaitForSingleObject(voidPtr, UInt32::MaxValue);
                    <Module>::CloseHandle(voidPtr);
                    this->checkBox1->ThreeState = false;
                }
                if (<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 1)))) != 0)
                {
                    if (<Module>::currentSpeedMul < 11)
                    {
                        [email protected] __gc* [email protected];
                        <Module>::itoa(<Module>::currentSpeedMul, *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(&[email protected]), 10);
                        String __gc* str2 = __gc new String(*static_cast<__box SByte __gc***>(&[email protected]));
                        this->comboBox1->Text = str2;
                        this->btnApply->PerformClick();
                        <Module>::currentSpeedMul++;
                    }
                    while ((<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 1)))) != 0))
                    {
                    }
                }
                if (<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 2)))) != 0)
                {
                    if (<Module>::currentSpeedMul >= 1)
                    {
                        [email protected] __gc* [email protected];
                        <Module>::itoa(<Module>::currentSpeedMul, *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(&[email protected]), 10);
                        String __gc* str = __gc new String(*static_cast<__box SByte __gc***>(&[email protected]));
                        this->comboBox1->Text = str;
                        this->btnApply->PerformClick();
                        <Module>::currentSpeedMul--;
                    }
                    while ((<Module>::GetAsyncKeyState(*(*static_cast<__box Byte __gc***>((&<Module>::keys + 2)))) != 0))
                    {
                    }
                }
                <Module>::Sleep(10);
            }
        }

        private: void __gc* btnApply_Click(Object __gc* sender, EventArgs __gc* e)
        {
            UInt32 __gc* modopt(IsLong __gc*) num;
            UInt32 __gc* modopt(IsLong __gc*) num5 = (<Module>::libBase + 0x1270);
            UInt32 __gc* modopt(IsLong __gc*) num4 = (<Module>::libBase + 0x1000);
            if (!<Module>::active)
            {
                void __gc** voidPtr2 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num5, 0, 0, 0);
                <Module>::WaitForSingleObject(voidPtr2, UInt32::MaxValue);
                <Module>::CloseHandle(voidPtr2);
                <Module>::active = true;
            }
            UInt32 __gc* num2 = (<Module>::baseAddr + 0x320d67);
            Single __gc* num3 = *static_cast<__box Single*>(<Module>::atof(*static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*) modopt(IsConst __gc*)**>(Marshal::StringToHGlobalAnsi(this->comboBox1->Text))));
            void __gc** voidPtr = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num4, 0, 0, 0);
            <Module>::WaitForSingleObject(voidPtr, UInt32::MaxValue);
            <Module>::GetExitCodeThread(voidPtr, &num);
            num += 560;
            <Module>::ReadProcessMemory(<Module>::hProcess, num, *static_cast<__box void __gc***>(&num2), 4, 0);
            num2 += 220;
            Single __gc* num6 = (num3 * 0.6);
            <Module>::WriteProcessMemory(<Module>::hProcess, *static_cast<__box void __gc***>(num2), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&num6), 4, 0);
            <Module>::CloseHandle(voidPtr);
        }

        private: void __gc* btnExit_Click(Object __gc* sender, EventArgs __gc* e)
        {
            UInt32 __gc* modopt(IsLong __gc*) num2 = (<Module>::libBase + 0x1190);
            <Module>::isdetour = false;
            void __gc** voidPtr3 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num2, 0, 0, 0);
            <Module>::WaitForSingleObject(voidPtr3, UInt32::MaxValue);
            <Module>::CloseHandle(voidPtr3);
            UInt32 __gc* modopt(IsLong __gc*) num = (<Module>::libBase + 0x12a0);
            void __gc** voidPtr2 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num, 0, 0, 0);
            <Module>::WaitForSingleObject(voidPtr2, UInt32::MaxValue);
            <Module>::CloseHandle(voidPtr2);
            void __gc** voidPtr = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, <Module>::GetProcAddress(<Module>::GetModuleHandleA(&<Module>::[email protected][email protected][email protected]), &<Module>::[email protected][email protected]@[email protected]), <Module>::libBase, 0, 0);
            <Module>::WaitForSingleObject(voidPtr, UInt32::MaxValue);
            <Module>::CloseHandle(voidPtr);
            <Module>::VirtualFreeEx(<Module>::hProcess, <Module>::cavebase, 0, 0x8000);
            <Module>::CloseHandle(<Module>::hProcess);
            Application::Exit();
        }

        private: void __gc* btnGo_Click(Object __gc* sender, EventArgs __gc* e)
        {
            UInt32 __gc* modopt(IsLong __gc*) num4;
            pposition __gc* pposition;
            pposition __gc* pposition2;
            teleport_job __gc* _job;
            UInt32 __gc* modopt(IsLong __gc*) num8 = (<Module>::libBase + 0x1000);
            this->checkBox1->Checked = false;
            this->checkBox2->Checked = false;
            this->checkBox1->ThreeState = false;
            this->checkBox2->ThreeState = false;
            UInt32 __gc* num2 = (<Module>::baseAddr + 0x2ccfcd);
            UInt32 __gc* num = 5;
            do
            {
                Byte __gc* num9 = 0x90;
                <Module>::WriteProcessMemory(<Module>::hProcess, *static_cast<__box void __gc***>(num2), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&num9), 1, 0);
                num2++;
                num--;
            }
            while ((num > 0));
            *(*static_cast<__box SByte __gc***>((&_job + 12))) = 0;
            *(*static_cast<__box SByte __gc***>((&_job + 13))) = 0;
            *(*static_cast<__box SByte __gc***>((&_job + 14))) = 0;
            void __gc** voidPtr = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num8, 0, 0, 0);
            <Module>::WaitForSingleObject(voidPtr, UInt32::MaxValue);
            <Module>::GetExitCodeThread(voidPtr, &num4);
            <Module>::CloseHandle(voidPtr);
            UInt32 __gc* modopt(IsLong __gc*) num3 = (num4 + 0x2c);
            UInt32 __gc* modopt(IsLong __gc*) num7 = (num4 + 0x80);
            UInt32 __gc* modopt(IsLong __gc*) num6 = (<Module>::libBase + 0x1190);
            <Module>::isdetour = true;
            void __gc** voidPtr3 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num6, 1, 0, 0);
            <Module>::WaitForSingleObject(voidPtr3, UInt32::MaxValue);
            <Module>::CloseHandle(voidPtr3);
            SByte __gc* modopt(IsSignUnspecifiedByte __gc*)* numPtr3 = *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(Marshal::StringToHGlobalAnsi(this->textBox1->Text));
            SByte __gc* modopt(IsSignUnspecifiedByte __gc*)* numPtr2 = *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(Marshal::StringToHGlobalAnsi(this->textBox2->Text));
            SByte __gc* modopt(IsSignUnspecifiedByte __gc*)* numPtr = *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(Marshal::StringToHGlobalAnsi(this->textBox3->Text));
            *(*static_cast<__box Single __gc***>(&pposition2)) = *static_cast<__box Single*>(<Module>::atof(numPtr3));
            *(*static_cast<__box Single __gc***>((&pposition2 + 4))) = *static_cast<__box Single*>(<Module>::atof(numPtr2));
            *(*static_cast<__box Single __gc***>((&pposition2 + 8))) = *static_cast<__box Single*>(<Module>::atof(numPtr));
            *(*static_cast<__box Single __gc***>((&_job + 0x10))) = *(*static_cast<__box Single __gc***>(&pposition2));
            *(*static_cast<__box Single __gc***>((&_job + 20))) = *(*static_cast<__box Single __gc***>((&pposition2 + 4)));
            *(*static_cast<__box Single __gc***>((&_job + 0x18))) = *(*static_cast<__box Single __gc***>((&pposition2 + 8)));
            <Module>::ReadProcessMemory(<Module>::hProcess, num3, *static_cast<__box void __gc***>(&pposition), 12, 0);
            <Module>::teleport_job.setTypes(&_job, &pposition);
            if (<Module>::teleport_job.move(&_job, &pposition) == 0)
            {
                do
                {
                    <Module>::WriteProcessMemory(<Module>::hProcess, num3, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&pposition), 12, 0);
                    <Module>::WriteProcessMemory(<Module>::hProcess, num7, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&pposition), 12, 0);
                    <Module>::Sleep(10);
                }
                while ((<Module>::teleport_job.move(&_job, &pposition) == 0));
            }
            this->checkBox1->ThreeState = true;
            this->checkBox2->ThreeState = false;
            UInt32 __gc* modopt(IsLong __gc*) num5 = (<Module>::libBase + 0x1190);
            <Module>::isdetour = false;
            void __gc** voidPtr2 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num5, 0, 0, 0);
            <Module>::WaitForSingleObject(voidPtr2, UInt32::MaxValue);
            <Module>::CloseHandle(voidPtr2);
            <Module>::WriteProcessMemory(<Module>::hProcess, *static_cast<__box void __gc***>((<Module>::baseAddr + 0x2ccfcd)), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&<Module>::byteGravityBuffer), 5, 0);
        }

        private: void __gc* btnSave_Click(Object __gc* sender, EventArgs __gc* e)
        {
        }

        private: void __gc* button1_Click(Object __gc* sender, EventArgs __gc* e)
        {
            SByte __gc* modopt(IsSignUnspecifiedByte __gc*)* numPtr4 = *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(Marshal::StringToHGlobalAnsi(this->textBox12->Text));
            SByte __gc* modopt(IsSignUnspecifiedByte __gc*)* numPtr3 = *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(Marshal::StringToHGlobalAnsi(this->textBox11->Text));
            SByte __gc* modopt(IsSignUnspecifiedByte __gc*)* numPtr2 = *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(Marshal::StringToHGlobalAnsi(this->textBox9->Text));
            SByte __gc* modopt(IsSignUnspecifiedByte __gc*)* numPtr = *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(Marshal::StringToHGlobalAnsi(this->textBox10->Text));
            *(*static_cast<__box SByte __gc***>((&<Module>::keys + 3))) = <Module>::VkKeyScanA(numPtr4[0]);
            *(*static_cast<__box SByte __gc***>((&<Module>::keys + 4))) = <Module>::VkKeyScanA(numPtr3[0]);
            *(*static_cast<__box SByte __gc***>((&<Module>::keys + 1))) = <Module>::VkKeyScanA(numPtr2[0]);
            *(*static_cast<__box SByte __gc***>((&<Module>::keys + 2))) = <Module>::VkKeyScanA(numPtr[0]);
        }

        private: void __gc* button2_Click(Object __gc* sender, EventArgs __gc* e)
        {
            basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* local9;
            UInt32 __gc* num = 0;
            UInt32 __gc* modopt(IsLong __gc*) num2 = (<Module>::PlayerPtr + 0x2c);
            *(*static_cast<__box Int32 __gc***>(&local9)) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
            <Module>::std.basic_ios<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 80)));
            try
            {
                num = 1;
                <Module>::std.basic_ostream<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local9), *static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc***>((&local9 + 4)), false, 0);
                try
                {
                    *(*static_cast<__box Int32 __gc***>(&local9))[4][*static_cast<__box Int32*>(&local9)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                    <Module>::std.basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >.{ctor}(*static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 4)), 2);
                }
                fault
                {
                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local9 + 8)));
                }
            }
            fault
            {
                if ((num & 1) != 0)
                {
                    num &= 0xfffffffe;
                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local9 + 80)));
                }
            }
            try
            {
                basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local8;
                *(*static_cast<__box Int32 __gc***>((&local8 + 20))) = 15;
                *(*static_cast<__box Int32 __gc***>((&local8 + 0x10))) = 0;
                *(*static_cast<__box SByte __gc***>(&local8)) = 0;
                try
                {
                    Single __gc* num3;
                    basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* local6;
                    basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local7;
                    <Module>::ReadProcessMemory(<Module>::hProcess, num2, *static_cast<__box void __gc***>(&num3), 4, 0);
                    <Module>::std.basic_ostream<char,std::char_traits<char> >.<<(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local9), num3);
                    basic_string<char,std::char_traits<char>,std::allocator<char> > __gc** localPtr3 = <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.str(*static_cast<__box basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* modopt(IsConst __gc*)* modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local9), &local7);
                    try
                    {
                        <Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.assign(&local8, localPtr3);
                    }
                    fault
                    {
                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local7));
                    }
                    if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local7 + 20))))
                    {
                        <Module>::delete(*(*static_cast<__box void __gc****>(&local7)));
                    }
                    String __gc* str3 = __gc new String(((0x10 > *(*static_cast<__box Int32 __gc***>((&local8 + 20)))) ? *static_cast<__box SByte __gc***>(&local8) : *static_cast<__box SByte __gc***>(*(*static_cast<__box Int32 __gc***>(&local8)))));
                    this->textBox4->Text = str3;
                    *(*static_cast<__box Int32 __gc***>(&local6)) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                    <Module>::std.basic_ios<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 80)));
                    try
                    {
                        num = 3;
                        <Module>::std.basic_ostream<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local6), *static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc***>((&local6 + 4)), false, 0);
                        try
                        {
                            *(*static_cast<__box Int32 __gc***>(&local6))[4][*static_cast<__box Int32*>(&local6)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                            <Module>::std.basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >.{ctor}(*static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 4)), 2);
                        }
                        fault
                        {
                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local6 + 8)));
                        }
                    }
                    fault
                    {
                        if ((num & 2) != 0)
                        {
                            num &= 0xfffffffd;
                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local6 + 80)));
                        }
                    }
                    try
                    {
                        basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local5;
                        *(*static_cast<__box Int32 __gc***>((&local5 + 20))) = 15;
                        *(*static_cast<__box Int32 __gc***>((&local5 + 0x10))) = 0;
                        *(*static_cast<__box SByte __gc***>(&local5)) = 0;
                        try
                        {
                            basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* local3;
                            basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local4;
                            num2 += 4;
                            <Module>::ReadProcessMemory(<Module>::hProcess, num2, *static_cast<__box void __gc***>(&num3), 4, 0);
                            <Module>::std.basic_ostream<char,std::char_traits<char> >.<<(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local6), num3);
                            basic_string<char,std::char_traits<char>,std::allocator<char> > __gc** localPtr2 = <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.str(*static_cast<__box basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* modopt(IsConst __gc*)* modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local6), &local4);
                            try
                            {
                                <Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.assign(&local5, localPtr2);
                            }
                            fault
                            {
                                <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local4));
                            }
                            if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local4 + 20))))
                            {
                                <Module>::delete(*(*static_cast<__box void __gc****>(&local4)));
                            }
                            String __gc* str2 = __gc new String(((0x10 > *(*static_cast<__box Int32 __gc***>((&local5 + 20)))) ? *static_cast<__box SByte __gc***>(&local5) : *static_cast<__box SByte __gc***>(*(*static_cast<__box Int32 __gc***>(&local5)))));
                            this->textBox5->Text = str2;
                            *(*static_cast<__box Int32 __gc***>(&local3)) = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                            <Module>::std.basic_ios<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 80)));
                            try
                            {
                                num = 7;
                                <Module>::std.basic_ostream<char,std::char_traits<char> >.{ctor}(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local3), *static_cast<__box basic_streambuf<char,std::char_traits<char> > __gc***>((&local3 + 4)), false, 0);
                                try
                                {
                                    *(*static_cast<__box Int32 __gc***>(&local3))[4][*static_cast<__box Int32*>(&local3)] = &<Module>::[email protected][email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected];
                                    <Module>::std.basic_stringbuf<char,std::char_traits<char>,std::allocator<char> >.{ctor}(*static_cast<__box basic_stringbuf<char,std::char_traits<char>,std::allocator<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 4)), 2);
                                }
                                fault
                                {
                                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostream<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local3 + 8)));
                                }
                            }
                            fault
                            {
                                if ((num & 4) != 0)
                                {
                                    num &= 0xfffffffb;
                                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}, *static_cast<__box void __gc***>((&local3 + 80)));
                                }
                            }
                            try
                            {
                                basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local2;
                                *(*static_cast<__box Int32 __gc***>((&local2 + 20))) = 15;
                                *(*static_cast<__box Int32 __gc***>((&local2 + 0x10))) = 0;
                                *(*static_cast<__box SByte __gc***>(&local2)) = 0;
                                try
                                {
                                    basic_string<char,std::char_traits<char>,std::allocator<char> > __gc* local;
                                    num2 += 4;
                                    <Module>::ReadProcessMemory(<Module>::hProcess, num2, *static_cast<__box void __gc***>(&num3), 4, 0);
                                    <Module>::std.basic_ostream<char,std::char_traits<char> >.<<(*static_cast<__box basic_ostream<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local3), num3);
                                    basic_string<char,std::char_traits<char>,std::allocator<char> > __gc** localPtr = <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.str(*static_cast<__box basic_ostringstream<char,std::char_traits<char>,std::allocator<char> > __gc* modopt(IsConst __gc*)* modopt(IsConst __gc*) modopt(IsConst __gc*)*>(&local3), &local);
                                    try
                                    {
                                        <Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.assign(&local2, localPtr);
                                    }
                                    fault
                                    {
                                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local));
                                    }
                                    if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local + 20))))
                                    {
                                        <Module>::delete(*(*static_cast<__box void __gc****>(&local)));
                                    }
                                    String __gc* str = __gc new String(((0x10 > *(*static_cast<__box Int32 __gc***>((&local2 + 20)))) ? *static_cast<__box SByte __gc***>(&local2) : *static_cast<__box SByte __gc***>(*(*static_cast<__box Int32 __gc***>(&local2)))));
                                    this->textBox6->Text = str;
                                }
                                fault
                                {
                                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local2));
                                }
                                if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local2 + 20))))
                                {
                                    <Module>::delete(*(*static_cast<__box void __gc****>(&local2)));
                                }
                                *(*static_cast<__box Int32 __gc***>((&local2 + 20))) = 15;
                                *(*static_cast<__box Int32 __gc***>((&local2 + 0x10))) = 0;
                                *(*static_cast<__box SByte __gc***>(&local2)) = 0;
                            }
                            fault
                            {
                                <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.__vbaseDtor, *static_cast<__box void __gc***>(&local3));
                            }
                            <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.{dtor}((&local3 + 80));
                            <Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local3 + 80)));
                        }
                        fault
                        {
                            <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local5));
                        }
                        if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local5 + 20))))
                        {
                            <Module>::delete(*(*static_cast<__box void __gc****>(&local5)));
                        }
                        *(*static_cast<__box Int32 __gc***>((&local5 + 20))) = 15;
                        *(*static_cast<__box Int32 __gc***>((&local5 + 0x10))) = 0;
                        *(*static_cast<__box SByte __gc***>(&local5)) = 0;
                    }
                    fault
                    {
                        <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.__vbaseDtor, *static_cast<__box void __gc***>(&local6));
                    }
                    <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.{dtor}((&local6 + 80));
                    <Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local6 + 80)));
                }
                fault
                {
                    <Module>::___CxxCallUnwindDtor(<Module>::std.basic_string<char,std::char_traits<char>,std::allocator<char> >.{dtor}, *static_cast<__box void __gc***>(&local8));
                }
                if (0x10 <= *(*static_cast<__box Int32 __gc***>((&local8 + 20))))
                {
                    <Module>::delete(*(*static_cast<__box void __gc****>(&local8)));
                }
                *(*static_cast<__box Int32 __gc***>((&local8 + 20))) = 15;
                *(*static_cast<__box Int32 __gc***>((&local8 + 0x10))) = 0;
                *(*static_cast<__box SByte __gc***>(&local8)) = 0;
            }
            fault
            {
                <Module>::___CxxCallUnwindDtor(<Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.__vbaseDtor, *static_cast<__box void __gc***>(&local9));
            }
            <Module>::std.basic_ostringstream<char,std::char_traits<char>,std::allocator<char> >.{dtor}((&local9 + 80));
            <Module>::std.basic_ios<char,std::char_traits<char> >.{dtor}(*static_cast<__box basic_ios<char,std::char_traits<char> > __gc** modopt(IsConst __gc*) modopt(IsConst __gc*)*>((&local9 + 80)));
        }

        private: void __gc* checkBox1_CheckedChanged(Object __gc* sender, EventArgs __gc* e)
        {
            if (this->checkBox1->Checked)
            {
                UInt32 __gc* modopt(IsLong __gc*) num2 = (<Module>::libBase + 0x1190);
                <Module>::isdetour = true;
                void __gc** voidPtr2 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num2, 1, 0, 0);
                <Module>::WaitForSingleObject(voidPtr2, UInt32::MaxValue);
                <Module>::CloseHandle(voidPtr2);
            }
            else
            {
                UInt32 __gc* modopt(IsLong __gc*) num = (<Module>::libBase + 0x1190);
                <Module>::isdetour = false;
                void __gc** voidPtr = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num, 0, 0, 0);
                <Module>::WaitForSingleObject(voidPtr, UInt32::MaxValue);
                <Module>::CloseHandle(voidPtr);
            }
        }

        private: void __gc* checkBox2_CheckedChanged(Object __gc* sender, EventArgs __gc* e)
        {
            if (this->checkBox2->Checked)
            {
                UInt32 __gc* num2 = (<Module>::baseAddr + 0x2ccfcd);
                UInt32 __gc* num = 5;
                do
                {
                    Byte __gc* num3 = 0x90;
                    <Module>::WriteProcessMemory(<Module>::hProcess, *static_cast<__box void __gc***>(num2), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&num3), 1, 0);
                    num2++;
                    num--;
                }
                while ((num > 0));
            }
            else
            {
                <Module>::WriteProcessMemory(<Module>::hProcess, *static_cast<__box void __gc***>((<Module>::baseAddr + 0x2ccfcd)), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&<Module>::byteGravityBuffer), 5, 0);
            }
        }

        private: void __gc* checkBox3_CheckedChanged(Object __gc* sender, EventArgs __gc* e)
        {
            if (this->checkBox3->Checked)
            {
                <Module>::ToggleSuperfly(1);
            }
            else
            {
                <Module>::WriteProcessMemory(<Module>::hProcess, *static_cast<__box void __gc***>((<Module>::baseAddr + 0x2ccfcd)), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&<Module>::byteGravityBuffer), 5, 0);
                <Module>::WriteProcessMemory(<Module>::hProcess, *static_cast<__box void __gc***>((<Module>::baseAddr + 0x6de930)), *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&<Module>::byteBufferFallSpeed), 5, 0);
            }
        }

        [HandleProcessCorruptedStateExceptions]
        protected: override void __gc* Dispose([MarshalAs(UnmanagedType::U1)] Boolean __gc* flag1)
        {
            if (flag1)
            {
                try
                {
                    this->~Form1();
                    return;
                }
                finally
                {
                    base->Dispose(true);
                }
            }
            base->Dispose(false);
        }

        private: void __gc* Form1_Load(Object __gc* sender, EventArgs __gc* e)
        {
            [email protected] __gc* [email protected];
            this->comboBox1->Items->Add(S"1");
            this->comboBox1->Items->Add(S"2");
            this->comboBox1->Items->Add(S"3");
            this->comboBox1->Items->Add(S"4");
            this->comboBox1->Items->Add(S"5");
            this->comboBox1->Items->Add(S"6");
            this->comboBox1->Items->Add(S"7");
            this->comboBox1->Items->Add(S"8");
            this->comboBox1->Items->Add(S"9");
            this->comboBox1->Items->Add(S"10");
            UInt32 __gc* num3 = (<Module>::baseAddr + 0x2ccfcd);
            <Module>::GetModuleFileNameA(<Module>::library, *static_cast<__box SByte __gc* modopt(IsSignUnspecifiedByte __gc*)**>(&[email protected]), 0x100);
            <Module>::cavebase = <Module>::VirtualAllocEx(<Module>::hProcess, 0, 0x100, 0x1000, 0x40);
            <Module>::WriteProcessMemory(<Module>::hProcess, <Module>::cavebase, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(&[email protected]), 0x100, 0);
            void __gc** voidPtr2 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, <Module>::GetProcAddress(<Module>::GetModuleHandleA(&<Module>::[email protected][email protected][email protected]), &<Module>::[email protected][email protected][email protected][email protected]), <Module>::cavebase, 0, 0);
            <Module>::WaitForSingleObject(voidPtr2, UInt32::MaxValue);
            <Module>::GetExitCodeThread(voidPtr2, &<Module>::libBase);
            <Module>::CloseHandle(voidPtr2);
            UInt32 __gc* modopt(IsLong __gc*) num2 = (<Module>::libBase + 0x1070);
            UInt32 __gc* modopt(IsLong __gc*) num = (<Module>::libBase + 0x1000);
            void __gc** voidPtr3 = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num2, 0, 0, 0);
            <Module>::WaitForSingleObject(voidPtr3, UInt32::MaxValue);
            <Module>::CloseHandle(voidPtr3);
            <Module>::Sleep(0x5dc);
            void __gc** voidPtr = <Module>::CreateRemoteThread(<Module>::hProcess, 0, 0, num, 0, 0, 0);
            <Module>::WaitForSingleObject(voidPtr, UInt32::MaxValue);
            <Module>::GetExitCodeThread(voidPtr, &<Module>::PlayerPtr);
            <Module>::CloseHandle(voidPtr);
            <Module>::ReadProcessMemory(<Module>::hProcess, *static_cast<__box void __gc* modopt(IsConst __gc*)**>(num3), *static_cast<__box void __gc***>(&<Module>::byteGravityBuffer), 5, 0);
            this->backgroundWorker2->RunWorkerAsync();
        }

        private: void __gc* InitializeComponent()
        {
            ComponentResourceManager __gc* manager = __gc new ComponentResourceManager(__typeof(Form1));
            this->btnExit = __gc new Button();
            this->btnGo = __gc new Button();
            this->comboBox1 = __gc new ComboBox();
            this->btnApply = __gc new Button();
            this->label2 = __gc new Label();
            this->checkBox1 = __gc new CheckBox();
            this->label4 = __gc new Label();
            this->label5 = __gc new Label();
            this->textBox1 = __gc new TextBox();
            this->textBox2 = __gc new TextBox();
            this->textBox3 = __gc new TextBox();
            this->label1 = __gc new Label();
            this->label3 = __gc new Label();
            this->label6 = __gc new Label();
            this->backgroundWorker1 = __gc new BackgroundWorker();
            this->textBox4 = __gc new TextBox();
            this->textBox5 = __gc new TextBox();
            this->textBox6 = __gc new TextBox();
            this->checkBox2 = __gc new CheckBox();
            this->groupBox1 = __gc new GroupBox();
            this->textBox12 = __gc new TextBox();
            this->label12 = __gc new Label();
            this->label11 = __gc new Label();
            this->textBox11 = __gc new TextBox();
            this->button1 = __gc new Button();
            this->label10 = __gc new Label();
            this->textBox10 = __gc new TextBox();
            this->textBox9 = __gc new TextBox();
            this->label9 = __gc new Label();
            this->checkBox3 = __gc new CheckBox();
            this->button2 = __gc new Button();
            this->backgroundWorker2 = __gc new BackgroundWorker();
            this->groupBox1->SuspendLayout();
            base->SuspendLayout();
            this->btnExit->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point30 = (0x13d, 0x9f);
            this->btnExit->Location = point30;
            this->btnExit->Name = S"btnExit";
            Size __gc* size31 = (0x4b, 0x17);
            this->btnExit->Size = size31;
            this->btnExit->TabIndex = 0;
            this->btnExit->Text = S"Exit";
            this->btnExit->UseVisualStyleBackColor = true;
            this->btnExit->Click += new EventHandler __gc*(this.btnExit_Click);
            this->btnGo->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point29 = (0xd7, 0x83);
            this->btnGo->Location = point29;
            this->btnGo->Name = S"btnGo";
            Size __gc* size30 = (0x4b, 0x17);
            this->btnGo->Size = size30;
            this->btnGo->TabIndex = 2;
            this->btnGo->Text = S"Go ->";
            this->btnGo->UseVisualStyleBackColor = true;
            this->btnGo->Click += new EventHandler __gc*(this.btnGo_Click);
            this->comboBox1->FormattingEnabled = true;
            Point __gc* point28 = (12, 0x79);
            this->comboBox1->Location = point28;
            this->comboBox1->Name = S"comboBox1";
            Size __gc* size29 = (0x39, 0x15);
            this->comboBox1->Size = size29;
            this->comboBox1->TabIndex = 4;
            this->btnApply->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point27 = (12, 0x9f);
            this->btnApply->Location = point27;
            this->btnApply->Name = S"btnApply";
            Size __gc* size28 = (0x4b, 0x17);
            this->btnApply->Size = size28;
            this->btnApply->TabIndex = 5;
            this->btnApply->Text = S"Apply";
            this->btnApply->UseVisualStyleBackColor = true;
            this->btnApply->Click += new EventHandler __gc*(this.btnApply_Click);
            this->label2->AutoSize = true;
            this->label2->Font = __gc new Font(S"Constantia", 9, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point26 = (9, 0x68);
            this->label2->Location = point26;
            this->label2->Name = S"label2";
            Size __gc* size27 = (0x60, 14);
            this->label2->Size = size27;
            this->label2->TabIndex = 6;
            this->label2->Text = S"Speed multiplier:";
            this->checkBox1->AutoSize = true;
            this->checkBox1->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point25 = (2, 9);
            this->checkBox1->Location = point25;
            this->checkBox1->Name = S"checkBox1";
            Size __gc* size26 = (0x39, 0x11);
            this->checkBox1->Size = size26;
            this->checkBox1->TabIndex = 8;
            this->checkBox1->Text = S"Noclip";
            this->checkBox1->UseVisualStyleBackColor = true;
            this->checkBox1->CheckedChanged += new EventHandler __gc*(this.checkBox1_CheckedChanged);
            this->label4->AutoSize = true;
            this->label4->Font = __gc new Font(S"Constantia", 12, FontStyle::Regular, GraphicsUnit::Point, 0);
            Color __gc* maroon = Color::Maroon;
            this->label4->ForeColor = maroon;
            Point __gc* point24 = (0x166, 5);
            this->label4->Location = point24;
            this->label4->Name = S"label4";
            Size __gc* size25 = (0x22, 0x13);
            this->label4->Size = size25;
            this->label4->TabIndex = 12;
            this->label4->Text = S"Lyn";
            this->label5->AutoSize = true;
            this->label5->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point23 = (0x14f, 0x18);
            this->label5->Location = point23;
            this->label5->Name = S"label5";
            Size __gc* size24 = (0x39, 13);
            this->label5->Size = size24;
            this->label5->TabIndex = 13;
            this->label5->Text = S"by everdox";
            this->label5->Click += new EventHandler __gc*(this.label5_Click);
            Point __gc* point22 = (0xab, 0x55);
            this->textBox1->Location = point22;
            this->textBox1->Name = S"textBox1";
            Size __gc* size23 = (50, 20);
            this->textBox1->Size = size23;
            this->textBox1->TabIndex = 14;
            Point __gc* point21 = (0xe3, 0x55);
            this->textBox2->Location = point21;
            this->textBox2->Name = S"textBox2";
            Size __gc* size22 = (0x31, 20);
            this->textBox2->Size = size22;
            this->textBox2->TabIndex = 15;
            Point __gc* point20 = (0x11a, 0x55);
            this->textBox3->Location = point20;
            this->textBox3->Name = S"textBox3";
            Size __gc* size21 = (50, 20);
            this->textBox3->Size = size21;
            this->textBox3->TabIndex = 0x10;
            this->label1->AutoSize = true;
            Point __gc* point19 = (0xbb, 0x6c);
            this->label1->Location = point19;
            this->label1->Name = S"label1";
            Size __gc* size20 = (14, 13);
            this->label1->Size = size20;
            this->label1->TabIndex = 0x11;
            this->label1->Text = S"X";
            this->label3->AutoSize = true;
            Point __gc* point18 = (0x12d, 0x6c);
            this->label3->Location = point18;
            this->label3->Name = S"label3";
            Size __gc* size19 = (14, 13);
            this->label3->Size = size19;
            this->label3->TabIndex = 0x12;
            this->label3->Text = S"Y";
            this->label6->AutoSize = true;
            Point __gc* point17 = (0xf5, 0x6c);
            this->label6->Location = point17;
            this->label6->Name = S"label6";
            Size __gc* size18 = (14, 13);
            this->label6->Size = size18;
            this->label6->TabIndex = 0x13;
            this->label6->Text = S"Z";
            this->backgroundWorker1->DoWork += new DoWorkEventHandler __gc*(this.backgroundWorker1_DoWork);
            Color __gc* inactiveBorder = SystemColors::InactiveBorder;
            this->textBox4->BackColor = inactiveBorder;
            Point __gc* point16 = (0xab, 0x3b);
            this->textBox4->Location = point16;
            this->textBox4->Name = S"textBox4";
            this->textBox4->ReadOnly = true;
            Size __gc* size17 = (50, 20);
            this->textBox4->Size = size17;
            this->textBox4->TabIndex = 20;
            Color __gc* color2 = SystemColors::InactiveBorder;
            this->textBox5->BackColor = color2;
            Point __gc* point15 = (0xe3, 0x3b);
            this->textBox5->Location = point15;
            this->textBox5->Name = S"textBox5";
            this->textBox5->ReadOnly = true;
            Size __gc* size16 = (0x31, 20);
            this->textBox5->Size = size16;
            this->textBox5->TabIndex = 0x15;
            Color __gc* color = SystemColors::InactiveBorder;
            this->textBox6->BackColor = color;
            Point __gc* point14 = (0x11a, 0x3b);
            this->textBox6->Location = point14;
            this->textBox6->Name = S"textBox6";
            this->textBox6->ReadOnly = true;
            Size __gc* size15 = (0x31, 20);
            this->textBox6->Size = size15;
            this->textBox6->TabIndex = 0x16;
            this->checkBox2->AutoSize = true;
            this->checkBox2->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point13 = (2, 0x20);
            this->checkBox2->Location = point13;
            this->checkBox2->Name = S"checkBox2";
            Size __gc* size14 = (0x4b, 0x11);
            this->checkBox2->Size = size14;
            this->checkBox2->TabIndex = 0x17;
            this->checkBox2->Text = S"No gravity";
            this->checkBox2->UseVisualStyleBackColor = true;
            this->checkBox2->CheckedChanged += new EventHandler __gc*(this.checkBox2_CheckedChanged);
            this->groupBox1->Controls->Add(this->textBox12);
            this->groupBox1->Controls->Add(this->label12);
            this->groupBox1->Controls->Add(this->label11);
            this->groupBox1->Controls->Add(this->textBox11);
            this->groupBox1->Controls->Add(this->button1);
            this->groupBox1->Controls->Add(this->label10);
            this->groupBox1->Controls->Add(this->textBox10);
            this->groupBox1->Controls->Add(this->textBox9);
            this->groupBox1->Controls->Add(this->label9);
            this->groupBox1->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point12 = (12, 0xbc);
            this->groupBox1->Location = point12;
            this->groupBox1->Name = S"groupBox1";
            Size __gc* size13 = (370, 0x54);
            this->groupBox1->Size = size13;
            this->groupBox1->TabIndex = 0x18;
            this->groupBox1->TabStop = false;
            this->groupBox1->Text = S"Hotkeys";
            Point __gc* point11 = (0x34, 0x2d);
            this->textBox12->Location = point11;
            this->textBox12->Name = S"textBox12";
            Size __gc* size12 = (0x1f, 0x15);
            this->textBox12->Size = size12;
            this->textBox12->TabIndex = 12;
            this->label12->AutoSize = true;
            Point __gc* point10 = (0x74, 0x33);
            this->label12->Location = point10;
            this->label12->Name = S"label12";
            Size __gc* size11 = (0x2d, 13);
            this->label12->Size = size11;
            this->label12->TabIndex = 11;
            this->label12->Text = S"Z down:";
            this->label11->AutoSize = true;
            Point __gc* point9 = (15, 0x30);
            this->label11->Location = point9;
            this->label11->Name = S"label11";
            Size __gc* size10 = (0x1f, 13);
            this->label11->Size = size10;
            this->label11->TabIndex = 10;
            this->label11->Text = S"Z up:";
            Point __gc* point8 = (0xa7, 0x30);
            this->textBox11->Location = point8;
            this->textBox11->Name = S"textBox11";
            Size __gc* size9 = (0x1f, 0x15);
            this->textBox11->Size = size9;
            this->textBox11->TabIndex = 9;
            Point __gc* point7 = (0x56, 14);
            this->button1->Location = point7;
            this->button1->Name = S"button1";
            Size __gc* size8 = (0x4b, 0x17);
            this->button1->Size = size8;
            this->button1->TabIndex = 8;
            this->button1->Text = S"Save keys";
            this->button1->UseVisualStyleBackColor = true;
            this->button1->Click += new EventHandler __gc*(this.button1_Click);
            this->label10->AutoSize = true;
            Point __gc* point6 = (0xdf, 0x35);
            this->label10->Location = point6;
            this->label10->Name = S"label10";
            Size __gc* size7 = (80, 13);
            this->label10->Size = size7;
            this->label10->TabIndex = 7;
            this->label10->Text = S"Speed decrease:";
            Point __gc* point5 = (0x134, 0x33);
            this->textBox10->Location = point5;
            this->textBox10->Name = S"textBox10";
            Size __gc* size6 = (0x1f, 0x15);
            this->textBox10->Size = size6;
            this->textBox10->TabIndex = 6;
            Point __gc* point4 = (0x134, 14);
            this->textBox9->Location = point4;
            this->textBox9->Name = S"textBox9";
            Size __gc* size5 = (0x1f, 0x15);
            this->textBox9->Size = size5;
            this->textBox9->TabIndex = 5;
            this->label9->AutoSize = true;
            Point __gc* point3 = (0xe1, 0x11);
            this->label9->Location = point3;
            this->label9->Name = S"label9";
            Size __gc* size4 = (0x4e, 13);
            this->label9->Size = size4;
            this->label9->TabIndex = 2;
            this->label9->Text = S"Speed increase:";
            this->checkBox3->AutoSize = true;
            this->checkBox3->Font = __gc new Font(S"Constantia", 8.25, FontStyle::Regular, GraphicsUnit::Point, 0);
            Point __gc* point2 = (2, 0x37);
            this->checkBox3->Location = point2;
            this->checkBox3->Name = S"checkBox3";
            Size __gc* size3 = (0x40, 0x11);
            this->checkBox3->Size = size3;
            this->checkBox3->TabIndex = 0x19;
            this->checkBox3->Text = S"Superfly";
            this->checkBox3->UseVisualStyleBackColor = true;
            this->checkBox3->CheckedChanged += new EventHandler __gc*(this.checkBox3_CheckedChanged);
            Point __gc* point = (200, 0x1b);
            this->button2->Location = point;
            this->button2->Name = S"button2";
            Size __gc* size2 = (0x61, 0x17);
            this->button2->Size = size2;
            this->button2->TabIndex = 0x1a;
            this->button2->Text = S"Get position ->";
            this->button2->UseVisualStyleBackColor = true;
            this->button2->Click += new EventHandler __gc*(this.button2_Click);
            this->backgroundWorker2->DoWork += new DoWorkEventHandler __gc*(this.backgroundWorker2_DoWork);
            SizeF __gc* ef = (6, 13);
            base->AutoScaleDimensions = ef;
            base->AutoScaleMode = AutoScaleMode::Font;
            Size __gc* size = (0x18a, 0x11c);
            base->ClientSize = size;
            base->ControlBox = false;
            base->Controls->Add(this->button2);
            base->Controls->Add(this->checkBox3);
            base->Controls->Add(this->groupBox1);
            base->Controls->Add(this->checkBox2);
            base->Controls->Add(this->textBox6);
            base->Controls->Add(this->textBox5);
            base->Controls->Add(this->textBox4);
            base->Controls->Add(this->label6);
            base->Controls->Add(this->label3);
            base->Controls->Add(this->label1);
            base->Controls->Add(this->textBox3);
            base->Controls->Add(this->textBox2);
            base->Controls->Add(this->textBox1);
            base->Controls->Add(this->label5);
            base->Controls->Add(this->label4);
            base->Controls->Add(this->checkBox1);
            base->Controls->Add(this->label2);
            base->Controls->Add(this->btnApply);
            base->Controls->Add(this->comboBox1);
            base->Controls->Add(this->btnGo);
            base->Controls->Add(this->btnExit);
            base->Icon = *static_cast<__box Icon*>(manager->GetObject(S"$this.Icon"));
            base->Name = S"Form1";
            this->Text = S"Lyn";
            base->Load += new EventHandler __gc*(this.Form1_Load);
            this->groupBox1->ResumeLayout(false);
            this->groupBox1->PerformLayout();
            base->ResumeLayout(false);
            base->PerformLayout();
        }

        private: void __gc* label5_Click(Object __gc* sender, EventArgs __gc* e)
        {
        }


        // Fields
        private: BackgroundWorker __gc* backgroundWorker1;
        private: BackgroundWorker __gc* backgroundWorker2;
        private: Button __gc* btnApply;
        private: Button __gc* btnExit;
        private: Button __gc* btnGo;
        private: Button __gc* button1;
        private: Button __gc* button2;
        private: CheckBox __gc* checkBox1;
        private: CheckBox __gc* checkBox2;
        private: CheckBox __gc* checkBox3;
        private: ComboBox __gc* comboBox1;
        private: Container __gc* components;
        private: GroupBox __gc* groupBox1;
        private: Label __gc* label1;
        private: Label __gc* label10;
        private: Label __gc* label11;
        private: Label __gc* label12;
        private: Label __gc* label2;
        private: Label __gc* label3;
        private: Label __gc* label4;
        private: Label __gc* label5;
        private: Label __gc* label6;
        private: Label __gc* label9;
        private: TextBox __gc* textBox1;
        private: TextBox __gc* textBox10;
        private: TextBox __gc* textBox11;
        private: TextBox __gc* textBox12;
        private: TextBox __gc* textBox2;
        private: TextBox __gc* textBox3;
        private: TextBox __gc* textBox4;
        private: TextBox __gc* textBox5;
        private: TextBox __gc* textBox6;
        private: TextBox __gc* textBox9;
    };
}
Attached Files
File Type: rar Lyn.rar (352.4 KB, 33 views)


mrkoykang is offline  
Thanks
2 Users
Reply



« Previous Thread | Next Thread »



All times are GMT +2. The time now is 23:16.


Powered by vBulletin®
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.

Support | Contact Us | FAQ | Advertising | Privacy Policy | Abuse
Copyright ©2017 elitepvpers All Rights Reserved.