Decompile Lyn menu

These ads disappear when you log in.

Page 1 of 2 12 LastLast
Results 1 to 15 of 30
  1. #1
    mrkoykang's Avatar Private
    Reputation
    5
    Join Date
    Sep 2008
    Posts
    9
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)

    Decompile Lyn

    I don't know if this is even allowed but this is my first attempt to decompile lyn itself. here is some 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]@[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]), <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;
        };
    }

    here is the complete decompile of lyn.exe
    Lyn.rar

    Full source code for lyn.exe and lyn.dll
    Lyn Source code
    Lyn.dll source code
    if this is not allow pls contact me and i'll delete the post
    Last edited by mrkoykang; 03-03-2012 at 02:25 AM.

    These ads disappear when you log in.

  2. #2
    Reffotsirk's Avatar Sergeant
    Reputation
    16
    Join Date
    Jan 2012
    Posts
    48
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    I don't think this is allowed, but i haven't heard of LYN in a while so w/e ;D

  3. #3
    sitnspinlock's Avatar Elite User CoreCoins User
    Reputation
    398
    Join Date
    Sep 2010
    Posts
    439
    Thanks G/R
    0/1
    Trade Feedback
    0 (0%)
    or you could just analyze the game and make more headway ;p

  4. #4
    armanator's Avatar Site Donator CoreCoins User
    Reputation
    5
    Join Date
    Jan 2008
    Posts
    21
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    I do understand where everdox is coming from for not releasing the source code. It becomes easier to patch and harder to find a fix when you don't know HOW you got there in the first place.

    Plus how can everdox know if someone is going to just take his work and profit from it, or are with swtor devs themselves?

    I loved the hack and donated for it, so I really wish everdox could just change the offsets himself and release it for the meantime until someone gets smart.

  5. #5
    assasin01's Avatar Master Sergeant
    Reputation
    4
    Join Date
    Jun 2009
    Posts
    93
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    everdox and darklinux already said they will leave swtor because they got an angry letter......no more lynn....

  6. #6
    Paranoiaaa123's Avatar Private
    Reputation
    1
    Join Date
    Oct 2009
    Posts
    3
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    Good job.
    This can be used to make a teleport / nogravity-hack.
    The Noclip detour is in the Lyn.dll. So the dll needs to be decompiled too.

  7. #7
    mrkoykang's Avatar Private
    Reputation
    5
    Join Date
    Sep 2008
    Posts
    9
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    Originally Posted by Paranoiaaa123 View Post
    Good job.
    This can be used to make a teleport / nogravity-hack.
    The Noclip detour is in the Lyn.dll. So the dll needs to be decompiled too.
    since lyn.dll was written purely in c++ I could disassemble it, but reconstruction would take a while. unless creator release it a save me the trouble lol.

  8. #8
    mrkoykang's Avatar Private
    Reputation
    5
    Join Date
    Sep 2008
    Posts
    9
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    I finally got a hold of lyn.exe full source code. still do not have lyn.dll source. as to lyn.exe source code this is the complete project in visual c++ and not a decompile version.

  9. #9
    DarkLinux's Avatar ★ Elder ★ CoreCoins User Authenticator enabled
    Reputation
    1389
    Join Date
    May 2010
    Posts
    1,596
    Thanks G/R
    118/401
    Trade Feedback
    13 (100%)
    Its funny we release some methods for another hack (aka Cheata) and we get ridiculed for it. I am starting to think there is a double standard for this forum. Anyone can run IDA so I don't give a shit about this post but it funny that's all...

  10. #10
    sitnspinlock's Avatar Elite User CoreCoins User
    Reputation
    398
    Join Date
    Sep 2010
    Posts
    439
    Thanks G/R
    0/1
    Trade Feedback
    0 (0%)
    this is the swtor section! anything goes ;p

  11. #11
    sitnspinlock's Avatar Elite User CoreCoins User
    Reputation
    398
    Join Date
    Sep 2010
    Posts
    439
    Thanks G/R
    0/1
    Trade Feedback
    0 (0%)
    i'd like to add, i see that you actually do have my source code (and i don't care) but that is not the reason I refrained from formally giving it to you. I did that because I literally shit Lyn together in a single afternoon (granted the reversing of swtor itself took a few days) it was not meant to be released on the basis that there are zero comments and would be very difficult to follow and altogether a more negative learning experience then a positive one.

    If you would like the dll you may send me a pm, but keep in mind that I have warned you ahead of time that attempting to learn by copying my code will get you nowhere fast.
    Last edited by sitnspinlock; 02-22-2012 at 08:13 PM.

  12. #12
    sitnspinlock's Avatar Elite User CoreCoins User
    Reputation
    398
    Join Date
    Sep 2010
    Posts
    439
    Thanks G/R
    0/1
    Trade Feedback
    0 (0%)
    Originally Posted by assasin01 View Post
    most likely because we lost all respect for you and everdox....why should we....you certainly don't...

  13. #13
    unclesam77's Avatar Sergeant
    Reputation
    7
    Join Date
    Mar 2009
    Posts
    55
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    Originally Posted by DarkLinux View Post
    Its funny we release some methods for another hack (aka Cheata) and we get ridiculed for it. I am starting to think there is a double standard for this forum. Anyone can run IDA so I don't give a shit about this post but it funny that's all...
    oh hey!.. i was one of the people in the private membership during cheatah was released.. i remember people were bashing you and even though other hack makers couldn't come up with the speedhack for wow (at that time you were the only one that came out with it).. oh and the force leap thinghy, that was brilliant...

    i sure miss lyn i tell u...

  14. #14
    Feldeath's Avatar Member CoreCoins User
    Reputation
    12
    Join Date
    Feb 2011
    Posts
    75
    Thanks G/R
    1/0
    Trade Feedback
    0 (0%)
    I don't understand why everyone is shitting on Everdox now, when he was giving us Lyn for 5$ Lifetime who was bitching? Nobody !
    The guy stopped his work, ok he could have said a simple "This is the end of Lyn" or something on the forum but hey this is HIS time that
    was getting on the programming, so if he wants to stop, that's his life.

    Stop crying and move on.

  15. #15
    assasin01's Avatar Master Sergeant
    Reputation
    4
    Join Date
    Jun 2009
    Posts
    93
    Thanks G/R
    0/0
    Trade Feedback
    0 (0%)
    Originally Posted by Feldeath View Post
    I don't understand why everyone is shitting on Everdox now, when he was giving us Lyn for 5$ Lifetime who was bitching? Nobody !
    The guy stopped his work, ok he could have said a simple "This is the end of Lyn" or something on the forum but hey this is HIS time that
    was getting on the programming, so if he wants to stop, that's his life.

    Stop crying and move on.
    a bit too easy...you only gave 5$ but a lot of peeps gave a LOT more......and they heard here that they would stop developement...not a single word on their own site even after repeated requests for a simple answer.
    I don't mind them stopping developement..i get that...but the least they could have done is put up a notice and offer to give the money back to those who had joined less than,say, 2 weeks before the end.
    Instead they vanished from the site( everdox even pointed the finger towards darklinux,sadly no more proof since the forum got whiped) and left with the money. I was glad to see some got their money back from paypal...but it was simply not the way to go..
    I have provoked a reply from them(not very nice...i know) and all i got was another serving of BS.....
    How hard would it be to step up and be a man about it and post a notice on the forum explaining what happened ?

Page 1 of 2 12 LastLast

Similar Threads

  1. ?Lua Decompiler?
    By KingYoshi9 in forum Programming
    Replies: 19
    Last Post: 07-17-2008, 06:55 PM
  2. I Have a voting bot for WoW Emulated Servers, I need to decompile it, HELP
    By mafiaboy in forum World of Warcraft Emulator Servers
    Replies: 11
    Last Post: 12-04-2007, 12:04 PM
  3. strange command in decompile of wow.exe
    By vivec45 in forum World of Warcraft General
    Replies: 1
    Last Post: 08-25-2007, 07:35 AM
  4. PiroX's AntiAFK Bot Decompiled Source.
    By bind in forum World of Warcraft Bots and Programs
    Replies: 9
    Last Post: 04-11-2007, 04:17 PM
All times are GMT -5. The time now is 06:38 PM. Powered by vBulletin® Version 4.2.3
Copyright © 2018 vBulletin Solutions, Inc. All rights reserved. Digital Point modules: Sphinx-based search