/// <summary>
        /// Primitive patching. Inserts a jump to 'target' at 'site'. Works even if both methods'
        /// callers have already been compiled.
        /// </summary>
        /// <param name="site"></param>
        /// <param name="target"></param>
        private static DetourCallsState PatchJumpTo(IntPtr site, IntPtr target)
        {
            DetourCallsState state = new DetourCallsState();

            // R11 is volatile.
            unsafe
            {
                byte *sitePtr = (byte *)site.ToPointer();
                state.a = *sitePtr;
                state.b = *(sitePtr + 1);
                state.c = *(sitePtr + 10);
                state.d = *(sitePtr + 11);
                state.e = *(sitePtr + 12);
                state.f = *((ulong *)(sitePtr + 2));

                *sitePtr = 0x49; // mov r11, target
                *(sitePtr + 1)            = 0xBB;
                *((ulong *)(sitePtr + 2)) = (ulong)target.ToInt64();
                *(sitePtr + 10)           = 0x41; // jmp r11
                *(sitePtr + 11)           = 0xFF;
                *(sitePtr + 12)           = 0xE3;
            }

            return(state);
        }
 private static void RevertJumpTo(IntPtr site, DetourCallsState state)
 {
     unsafe
     {
         byte *sitePtr = (byte *)site.ToPointer();
         *     sitePtr = state.a; // mov r11, target
         *(sitePtr + 1)            = state.b;
         *((ulong *)(sitePtr + 2)) = state.f;
         *(sitePtr + 10)           = state.c; // jmp r11
         *(sitePtr + 11)           = state.d;
         *(sitePtr + 12)           = state.e;
     }
 }
        /// <summary>
        /// Reverts a redirect.
        /// </summary>
        /// <param name="from">The method to revert the redirect.</param>
        /// <param name="state">The state.</param>
        public static void RevertRedirect(MethodInfo from, DetourCallsState state)
        {
            var fptr1 = from.MethodHandle.GetFunctionPointer();

            RevertJumpTo(fptr1, state);
        }