public static class RPC
{
                private static uint function_address = 0x007AA050;
                    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()
                    {
                        byte[] CheckRPC = new byte[1];
                        if (CheckRPC[0] == 0x4e)
                        {
 
                        }
                        else
                        {
                            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 byte[] GetMemory(uint address, int length)
                {
                    byte[] buffer = new byte[length];
                    PS3.GetMemory(address, buffer);
                    return buffer;
                }
                public static void SetMemory(uint Address, byte[] Bytes)
                {
                    PS3.SetMemory(Address, Bytes);
                }
}