BO2 1.16 Fixed RPC

public class RPC
    {
        private static PS3API DEX = new PS3API();

        #region Functions
        private static uint function_address;
        public static byte[] GetMemory5(uint Address, byte[] length)
        {
            DEX.GetMemory(Address, length);
            return length;
        }
        public static void Connect()
        {
            DEX.ChangeAPI(SelectAPI.ControlConsole);
            DEX.ConnectTarget();
            DEX.AttachProcess();
        }
        public static byte[] GetMemory(uint address, int length)
        {
            byte[] buffer = new byte[length];
            DEX.GetMemory(address, buffer);
            return buffer;
        }
        public static void SetMemory(uint Address, byte[] Bytes)
        {
            DEX.SetMemory(Address, Bytes);
        }
        #endregion

using PS3Lib;

        #region RPC
        public static uint Call(uint func_address, params object[] parameters)
        {
            int length = parameters.Length;
            for (uint i = 0; i < length; i++)
            {
                if (parameters[i] is int)
                {
                    byte[] array = BitConverter.GetBytes((int)parameters[i]);
                    Array.Reverse(array);
                    SetMemory(0x10050008 + (i * 4), array);
                }
                else if (parameters[i] is uint)
                {
                    byte[] buffer2 = BitConverter.GetBytes((uint)parameters[i]);
                    Array.Reverse(buffer2);
                    SetMemory(0x10050008 + (i * 4), buffer2);
                }
                else if (parameters[i] is string)
                {
                    byte[] buffer3 = Encoding.UTF8.GetBytes(Convert.ToString(parameters[i]) + "\0");
                    SetMemory(0x1005002c + (i * 0x150), buffer3);
                    uint num3 = 0x1005002c + (i * 0x150);
                    byte[] buffer4 = BitConverter.GetBytes(num3);
                    Array.Reverse(buffer4);
                    SetMemory(0x10050008 + (i * 4), buffer4);
                }
            }
            for (int j = 9 - length; j <= 9; j++)
            {
                SetMemory((uint)(0x10050008 + (j * 4)), new byte[4]);
            }
            byte[] bytes = BitConverter.GetBytes(func_address);
            Array.Reverse(bytes);
            SetMemory(0x10050000, bytes);
            System.Threading.Thread.Sleep(20);
            byte[] GetX = new byte[4];
            byte[] memory = GetMemory(0x10050004, 4);
            Array.Reverse(memory);
            return BitConverter.ToUInt32(memory, 0);
        }

        public static void Enable_RPC()
        {
            SetMemory(function_address, new byte[] { 0x4e, 0x80, 0, 0x20 });
            byte[] memory = new byte[] {
                0x7c, 8, 2, 0xa6, 0xf8, 1, 0, 0xd0, 0xdb, 0x21, 0, 0x88, 0xdb, 0x41, 0, 0x90,
                0xdb, 0x61, 0, 0x98, 0xdb, 0x81, 0, 160, 0xdb, 0xa1, 0, 0xa8, 0xdb, 0xc1, 0, 0xb0,
                0xdb, 0xe1, 0, 0xb8, 0xfb, 0xa1, 0, 0x70, 0xfb, 0xc1, 0, 120, 0xfb, 0xe1, 0, 0x80,
                0x3d, 0x60, 0x10, 5, 0x80, 0x6b, 0, 0, 0x2c, 3, 0, 0, 0x41, 130, 0, 60,
                0x80, 0x6b, 0, 8, 0x80, 0x8b, 0, 12, 0x80, 0xab, 0, 0x10, 0x80, 0xcb, 0, 20,
                0x80, 0xeb, 0, 0x18, 0x81, 11, 0, 0x1c, 0x81, 0x2b, 0, 0x20, 0x81, 0x4b, 0, 0x24,
                0x81, 0x6b, 0, 40, 0x48, 0, 0, 0x4d, 60, 0x80, 0x10, 5, 0x80, 100, 0, 4,
                0x38, 160, 0, 0, 0x90, 0xa4, 0, 0, 0xe8, 1, 0, 0xd0, 0x7c, 8, 3, 0xa6,
                0xcb, 0x21, 0, 0x88, 0xcb, 0x41, 0, 0x90, 0xcb, 0x61, 0, 0x98, 0xcb, 0x81, 0, 160,
                0xcb, 0xa1, 0, 0xa8, 0xcb, 0xc1, 0, 0xb0, 0xcb, 0xe1, 0, 0xb8, 0xeb, 0xa1, 0, 0x70,
                0xeb, 0xc1, 0, 120, 0xeb, 0xe1, 0, 0x80, 0x38, 0x21, 0, 0xc0, 0x4e, 0x80, 0, 0x20,
                0x3d, 0x80, 0x10, 5, 0x81, 140, 0, 0, 0x7c, 8, 2, 0xa6, 0xf8, 1, 0, 0x20,
                0x7d, 0x89, 3, 0xa6, 0x4e, 0x80, 4, 0x21, 0xe8, 1, 0, 0x20, 0x7c, 8, 3, 0xa6,
                0x4e, 0x80, 0, 0x20, 0x60, 0, 0, 0
             };
            SetMemory(function_address + 4, memory);
            SetMemory(0x10050000, new byte[0xaac]);
            SetMemory(function_address, new byte[] { 0xf8, 0x21, 0xff, 0x41 });
        }

        public static uint Get_func_address()
        {
            for (uint i = 0x7a8e48; i < 0x1000000; i += 4)
            {
                byte[] GetX2 = new byte[9];
                byte[] memory = GetMemory5(i, GetX2);
                if ((((memory[0] == 0x42) && (memory[1] == 200)) && ((memory[2] == 0) && (memory[3] == 0))) && (((memory[4] == 0x40) && (memory[5] == 0)) && ((memory[6] == 0) && (memory[7] == 0))))
                {
                    return (i + 8);
                }
            }
            return 0;
        }

        public static int Init()
        {
            function_address = Get_func_address();
            if (function_address == 0)
            {
                return -1;
            }
            Enable_RPC();
            DEX.SetMemory(0x7AA240, new byte[] { 0x90, 0x64, 0x00, 0x04 });
            return 0;
        }
        #endregion
    }
}