public IL2Object PInvokeOriginal(IntPtr arg1, IntPtr arg2, IntPtr arg3, IntPtr arg4, IntPtr arg5, IntPtr arg6, IntPtr arg7, IntPtr arg8, IntPtr arg9)
        {
            IntPtr result = IL2Import.VRC_PInvoke(OriginalMethod, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

            if (result == IntPtr.Zero)
            {
                return(null);
            }

            return(new IL2Object(result, TargetMethod.GetReturnType()));
        }
        public static void Start()
        {
            IL2Method method = VRC.Player.Instance_Class.GetMethod("OnNetworkReady");

            try
            {
                unsafe
                {
                    var    disasm      = new Disassembler(*(IntPtr *)method.ptr, 16, ArchitectureMode.x86_64, unchecked ((ulong)(*(IntPtr *)method.ptr).ToInt64()), true, Vendor.Intel);
                    var    instruction = disasm.Disassemble().First(x => x.ToString().StartsWith("jmp "));
                    IntPtr addr        = new IntPtr((long)instruction.Offset + instruction.Length + instruction.Operands[0].LvalSDWord);

                    VRC.Player.methodUpdateModeration = VRC.Player.Instance_Class.GetMethods().First(x => *(IntPtr *)x.ptr == addr);
                    if (VRC.Player.methodUpdateModeration == null)
                    {
                        throw new Exception();
                    }

                    // UpdateModeration()

                    disasm = new Disassembler(*(IntPtr *)VRC.Player.methodUpdateModeration.ptr, 0x1000, ArchitectureMode.x86_64, unchecked ((ulong)(*(IntPtr *)VRC.Player.methodUpdateModeration.ptr).ToInt64()), true, Vendor.Intel);
                    // disasm.Disassemble().ToList().ForEach(x => { Console.WriteLine(x.ToString()); });
                    var instructions = disasm.Disassemble().TakeWhile(x => x.Mnemonic != ud_mnemonic_code.UD_Iint3);

                    foreach (var instruction1 in instructions)
                    {
                        if (!instruction1.ToString().StartsWith("call "))
                        {
                            continue;
                        }

                        try
                        {
                            addr   = new IntPtr((long)instruction1.Offset + instruction1.Length + instruction1.Operands[0].LvalSDWord);
                            method = ModerationManager.Instance_Class.GetMethods().First(x => *(IntPtr *)x.ptr == addr);

                            if (method.GetParameters().Length != 1 || method.GetReturnType().Name != "System.Boolean")
                            {
                                continue;
                            }

                            if (method.GetParameters()[0].typeName != "System.String")
                            {
                                continue;
                            }

                            pAntiBlock = IL2Ch.Patch(method, typeof(patch_AntiBlock).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
                            break;
                        }
                        catch { continue; }
                    }
                }

                foreach (var ass in BlazeSDK.Main.listAssembly)
                {
                    ConSole.Debug(ass.FullName);
                }

                if (pAntiBlock == null)
                {
                    throw new Exception();
                }

                ConSole.Success("Patch: Anti-Block");
            }
            catch
            {
                ConSole.Error("Patch: Anti-Block");
            }
        }