text:
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>0Harmony</name>
    </assembly>
    <members>
        <member name="T:Harmony.MethodType">
            Specifies the type of method
        </member>
        <member name="F:Harmony.MethodType.Normal">
            This is a normal method
        </member>
        <member name="F:Harmony.MethodType.Getter">
            This is a getter
        </member>
        <member name="F:Harmony.MethodType.Setter">
            This is a setter
        </member>
        <member name="F:Harmony.MethodType.Constructor">
            This is a constructor
        </member>
        <member name="F:Harmony.MethodType.StaticConstructor">
            This is a static constructor
        </member>
        <member name="T:Harmony.PropertyMethod">
            [Obsolete] Specifies the type of property
        </member>
        <member name="F:Harmony.PropertyMethod.Getter">
            [Obsolete] This is a getter
        </member>
        <member name="F:Harmony.PropertyMethod.Setter">
            [Obsolete] This is a setter
        </member>
        <member name="T:Harmony.ArgumentType">
            Specifies the type of argument
        </member>
        <member name="F:Harmony.ArgumentType.Normal">
            This is a normal argument
        </member>
        <member name="F:Harmony.ArgumentType.Ref">
            This is a reference argument (ref)
        </member>
        <member name="F:Harmony.ArgumentType.Out">
            This is an out argument (out)
        </member>
        <member name="F:Harmony.ArgumentType.Pointer">
            This is a pointer argument (&)
        </member>
        <member name="T:Harmony.HarmonyPatchType">
            Specifies the type of patch
        </member>
        <member name="F:Harmony.HarmonyPatchType.All">
            Any patch
        </member>
        <member name="F:Harmony.HarmonyPatchType.Prefix">
            A prefix patch
        </member>
        <member name="F:Harmony.HarmonyPatchType.Postfix">
            A postfix patch
        </member>
        <member name="F:Harmony.HarmonyPatchType.Transpiler">
            A transpiler
        </member>
        <member name="T:Harmony.HarmonyAttribute">
            The base class for all Harmony annotations (not meant to be used directly)
        </member>
        <member name="F:Harmony.HarmonyAttribute.info">
            The common information for all attributes
        </member>
        <member name="T:Harmony.HarmonyPatch">
            The main Harmony annotation class
        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor">
             An empty annotation can be used together with TargetMethod(s)

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type)">
             An annotation that specifies a class to patch
             <param name="declaringType">The declaring class</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,System.Type[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="argumentTypes">The argument types of the method or constructor to patch</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,System.String)">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="methodName">The name of the method, property or constructor to patch</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,System.String,System.Type[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="methodName">The name of the method, property or constructor to patch</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,System.String,System.Type[],Harmony.ArgumentType[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="methodName">The name of the method, property or constructor to patch</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>
             <param name="argumentVariations">An array of extra argument subtypes (ref, out, pointer)</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,Harmony.MethodType)">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,Harmony.MethodType,System.Type[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,Harmony.MethodType,System.Type[],Harmony.ArgumentType[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>
             <param name="argumentVariations">An array of extra argument subtypes (ref, out, pointer)</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type,System.String,Harmony.MethodType)">
             An annotation that specifies a method, property or constructor to patch
             <param name="declaringType">The declaring class</param>
             <param name="methodName">The name of the method, property or constructor to patch</param>
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.String)">
             An annotation that specifies a method, property or constructor to patch
             <param name="methodName">The name of the method, property or constructor to patch</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.String,System.Type[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="methodName">The name of the method, property or constructor to patch</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.String,System.Type[],Harmony.ArgumentType[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="methodName">The name of the method, property or constructor to patch</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>
             <param name="argumentVariations">An array of extra argument subtypes (ref, out, pointer)</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.String,Harmony.MethodType)">
             An annotation that specifies a method, property or constructor to patch
             <param name="methodName">The name of the method, property or constructor to patch</param>
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(Harmony.MethodType)">
             An annotation that specifies a method, property or constructor to patch
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(Harmony.MethodType,System.Type[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(Harmony.MethodType,System.Type[],Harmony.ArgumentType[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="methodType">The type of entry: method, getter, setter or constructor</param>
             <param name="argumentTypes">An array of argument types to target overloads</param>
             <param name="argumentVariations">An array of extra argument subtypes (ref, out, pointer)</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="argumentTypes">An array of argument types to target overloads</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.Type[],Harmony.ArgumentType[])">
             An annotation that specifies a method, property or constructor to patch
             <param name="argumentTypes">An array of argument types to target overloads</param>
             <param name="argumentVariations">An array of extra argument subtypes (ref, out, pointer)</param>

        </member>
        <member name="M:Harmony.HarmonyPatch.#ctor(System.String,Harmony.PropertyMethod)">
             [Obsolete] An annotation that specifies a property to patch
             <param name="propertyName">Name of the property</param>
             <param name="type">The type</param>

        </member>
        <member name="T:Harmony.HarmonyPatchAll">
            A Harmony annotation
        </member>
        <member name="M:Harmony.HarmonyPatchAll.#ctor">
            A Harmony annotation to define that all methods in a class are to be patched
        </member>
        <member name="T:Harmony.HarmonyPriority">
            A Harmony annotation
        </member>
        <member name="M:Harmony.HarmonyPriority.#ctor(System.Int32)">
             A Harmony annotation to define patch priority
             <param name="priority">The priority</param>

        </member>
        <member name="T:Harmony.HarmonyBefore">
            A Harmony annotation
        </member>
        <member name="M:Harmony.HarmonyBefore.#ctor(System.String[])">
             A Harmony annotation to define that a patch comes before another patch
             <param name="before">The harmony ID of the other patch</param>

        </member>
        <member name="T:Harmony.HarmonyAfter">
            A Harmony annotation
        </member>
        <member name="M:Harmony.HarmonyAfter.#ctor(System.String[])">
             A Harmony annotation to define that a patch comes after another patch
             <param name="after">The harmony ID of the other patch</param>

        </member>
        <member name="T:Harmony.HarmonyPrepare">
            Specifies the Prepare function in a patch class
        </member>
        <member name="T:Harmony.HarmonyCleanup">
            Specifies the Cleanup function in a patch class
        </member>
        <member name="T:Harmony.HarmonyTargetMethod">
            Specifies the TargetMethod function in a patch class
        </member>
        <member name="T:Harmony.HarmonyTargetMethods">
            Specifies the TargetMethods function in a patch class
        </member>
        <member name="T:Harmony.HarmonyPrefix">
            Specifies the Prefix function in a patch class
        </member>
        <member name="T:Harmony.HarmonyPostfix">
            Specifies the Postfix function in a patch class
        </member>
        <member name="T:Harmony.HarmonyTranspiler">
            Specifies the Transpiler function in a patch class
        </member>
        <member name="T:Harmony.HarmonyArgument">
            A Harmony annotation
        </member>
        <member name="P:Harmony.HarmonyArgument.OriginalName">
            The name of the original argument
        </member>
        <member name="P:Harmony.HarmonyArgument.Index">
            The index of the original argument
        </member>
        <member name="P:Harmony.HarmonyArgument.NewName">
            The new name of the original argument
        </member>
        <member name="M:Harmony.HarmonyArgument.#ctor(System.String)">
            An annotation to declare injected arguments by name
        </member>
        <member name="M:Harmony.HarmonyArgument.#ctor(System.Int32)">
             An annotation to declare injected arguments by index
             <param name="index">Zero-based index</param>

        </member>
        <member name="M:Harmony.HarmonyArgument.#ctor(System.String,System.String)">
             An annotation to declare injected arguments by renaming them
             <param name="originalName">Name of the original argument</param>
             <param name="newName">New name</param>

        </member>
        <member name="M:Harmony.HarmonyArgument.#ctor(System.Int32,System.String)">
             An annotation to declare injected arguments by index and renaming them
             <param name="index">Zero-based index</param>
             <param name="name">New name</param>

        </member>
        <member name="F:Harmony.UpgradeToLatestVersion.version">
            The version.
        </member>
        <member name="T:Harmony.CodeInstruction">
            An abstract wrapper around OpCode and their operands. Used by transpilers
        </member>
        <member name="F:Harmony.CodeInstruction.opcode">
            The opcode
        </member>
        <member name="F:Harmony.CodeInstruction.operand">
            The operand
        </member>
        <member name="F:Harmony.CodeInstruction.labels">
            All labels defined on this instruction
        </member>
        <member name="F:Harmony.CodeInstruction.blocks">
            All exception block boundaries defined on this instruction
        </member>
        <member name="M:Harmony.CodeInstruction.#ctor(System.Reflection.Emit.OpCode,System.Object)">
             Creates a new CodeInstruction with a given opcode and optional operand
             <param name="opcode">The code</param>
             <param name="operand">The operand</param>

        </member>
        <member name="M:Harmony.CodeInstruction.#ctor(Harmony.CodeInstruction)">
             Create a full copy (including labels and exception blocks) of a CodeInstruction
             <param name="instruction">The instruction to copy</param>

        </member>
        <member name="M:Harmony.CodeInstruction.Clone">
             Clones a CodeInstruction and resets its labels and exception blocks
             <returns>A lightweight copy of this code instruction</returns>

        </member>
        <member name="M:Harmony.CodeInstruction.Clone(System.Reflection.Emit.OpCode)">
             Clones a CodeInstruction, resets labels and exception blocks and sets its opcode
             <param name="opcode">The opcode</param>
             <returns>A copy of this CodeInstruction with a new opcode</returns>

        </member>
        <member name="M:Harmony.CodeInstruction.Clone(System.Object)">
             Clones a CodeInstruction, resets labels and exception blocks and sets its operand
             <param name="operand">The opcode</param>
             <returns>A copy of this CodeInstruction with a new operand</returns>

        </member>
        <member name="M:Harmony.CodeInstruction.ToString">
             Returns a string representation of the code instruction
             <returns>A string representation of the code instruction</returns>

        </member>
        <member name="T:Harmony.CodeMatch">
            A CodeInstruction match
        </member>
        <member name="F:Harmony.CodeMatch.name">
            The name of the match
        </member>
        <member name="F:Harmony.CodeMatch.opcodes">
            The matched opcodes
        </member>
        <member name="F:Harmony.CodeMatch.operands">
            The matched operands
        </member>
        <member name="F:Harmony.CodeMatch.labels">
            The matched labels
        </member>
        <member name="F:Harmony.CodeMatch.blocks">
            The matched blocks
        </member>
        <member name="F:Harmony.CodeMatch.jumpsFrom">
            The jumps from the match
        </member>
        <member name="F:Harmony.CodeMatch.jumpsTo">
            The jumps to the match
        </member>
        <member name="F:Harmony.CodeMatch.predicate">
            The match predicate
        </member>
        <member name="M:Harmony.CodeMatch.#ctor(System.Nullable{System.Reflection.Emit.OpCode},System.Object,System.String)">
             Creates a code match
             <param name="opcode">The optional opcode</param>
             <param name="operand">The optional operand</param>
             <param name="name">The optional name</param>

        </member>
        <member name="M:Harmony.CodeMatch.#ctor(Harmony.CodeInstruction,System.String)">
             Creates a code match
             <param name="instruction">The CodeInstruction</param>
             <param name="name">An optional name</param>

        </member>
        <member name="M:Harmony.CodeMatch.#ctor(System.Func{Harmony.CodeInstruction,System.Boolean},System.String)">
             Creates a code match
             <param name="predicate">The predicate</param>
             <param name="name">An optional name</param>

        </member>
        <member name="M:Harmony.CodeMatch.ToString">
             Returns a string that represents the match
             <returns>A string representation</returns>

        </member>
        <member name="T:Harmony.CodeMatcher">
            A CodeInstruction matcher
        </member>
        <member name="P:Harmony.CodeMatcher.Pos">
             The current position
             <value>The index or -1 if out of bounds</value>

        </member>
        <member name="P:Harmony.CodeMatcher.Length">
             Gets the number of code instructions in this matcher
             <value>The count</value>

        </member>
        <member name="P:Harmony.CodeMatcher.IsValid">
             Checks whether the position of this CodeMatcher is within bounds
             <value>True if this CodeMatcher is valid</value>

        </member>
        <member name="P:Harmony.CodeMatcher.IsInvalid">
             Checks whether the position of this CodeMatcher is outside its bounds
             <value>True if this CodeMatcher is invalid</value>

        </member>
        <member name="P:Harmony.CodeMatcher.Remaining">
             Gets the remaining code instructions
             <value>The remaining count</value>

        </member>
        <member name="P:Harmony.CodeMatcher.Opcode">
             Gets the opcode at the current position
             <value>The opcode</value>

        </member>
        <member name="P:Harmony.CodeMatcher.Operand">
             Gets the operand at the current position
             <value>The operand</value>

        </member>
        <member name="P:Harmony.CodeMatcher.Labels">
             Gets the labels at the current position
             <value>The labels</value>

        </member>
        <member name="P:Harmony.CodeMatcher.Blocks">
             Gets the exception blocks at the current position
             <value>The blocks</value>

        </member>
        <member name="M:Harmony.CodeMatcher.#ctor">
            Creates an empty code matcher
        </member>
        <member name="M:Harmony.CodeMatcher.#ctor(System.Collections.Generic.IEnumerable{Harmony.CodeInstruction},System.Reflection.Emit.ILGenerator)">
             Creates a code matcher from an enumeration of instructions
             <param name="instructions">The instructions (transpiler argument)</param>
             <param name="generator">An optional IL generator</param>

        </member>
        <member name="M:Harmony.CodeMatcher.Clone">
             Makes a clone of this instruction matcher
             <returns>A copy of this matcher</returns>

        </member>
        <member name="P:Harmony.CodeMatcher.Instruction">
             Gets instructions at the current position
             <value>The instruction</value>

        </member>
        <member name="M:Harmony.CodeMatcher.InstructionAt(System.Int32)">
             Gets instructions at the current position with offset
             <param name="offset">The offset</param>
             <returns>The instruction</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Instructions">
             Gets all instructions
             <returns>A list of instructions</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Instructions(System.Int32)">
             Gets some instructions counting from current position
             <param name="count">Number of instructions</param>
             <returns>A list of instructions</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.InstructionsInRange(System.Int32,System.Int32)">
             Gets all instructions within a range
             <param name="start">The start index</param>
             <param name="end">The end index</param>
             <returns>A list of instructions</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.InstructionsWithOffsets(System.Int32,System.Int32)">
             Gets all instructions within a range (relative to current position)
             <param name="startOffset">The start offset</param>
             <param name="endOffset">The end offset</param>
             <returns>A list of instructions</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.DistinctLabels(System.Collections.Generic.IEnumerable{Harmony.CodeInstruction})">
             Gets a list of all distinct labels
             <param name="instructions">The instructions (transpiler argument)</param>
             <returns>A list of Labels</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.ReportFailure(System.Reflection.MethodBase,System.Action{System.String})">
             Reports a failure
             <param name="method">The method involved</param>
             <param name="logger">The logger</param>
             <returns>True if current position is invalid and error was logged</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SetInstruction(Harmony.CodeInstruction)">
             Sets an instruction at current position
             <param name="instruction">The instruction to set</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SetInstructionAndAdvance(Harmony.CodeInstruction)">
             Sets instruction at current position and advances
             <param name="instruction">The instruction</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Set(System.Reflection.Emit.OpCode,System.Object)">
             Sets opcode and operand at current position
             <param name="opcode">The opcode</param>
             <param name="operand">The operand</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SetAndAdvance(System.Reflection.Emit.OpCode,System.Object)">
             Sets opcode and operand at current position and advances
             <param name="opcode">The opcode</param>
             <param name="operand">The operand</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SetOpcodeAndAdvance(System.Reflection.Emit.OpCode)">
             Sets opcode at current position and advances
             <param name="opcode">The opcode</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SetOperandAndAdvance(System.Object)">
             Sets operand at current position and advances
             <param name="operand">The operand</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.CreateLabel(System.Reflection.Emit.Label@)">
             Creates a label at current position
             <param name="label">[out] The label</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.CreateLabelAt(System.Int32,System.Reflection.Emit.Label@)">
             Creates a label at a position
             <param name="position">The position</param>
             <param name="label">[out] The new label</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.AddLabels(System.Collections.Generic.IEnumerable{System.Reflection.Emit.Label})">
             Adds an enumeration of labels to current position
             <param name="labels">The labels</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.AddLabelsAt(System.Int32,System.Collections.Generic.IEnumerable{System.Reflection.Emit.Label})">
             Adds an enumeration of labels at a position
             <param name="position">The position</param>
             <param name="labels">The labels</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SetJumpTo(System.Reflection.Emit.OpCode,System.Int32,System.Reflection.Emit.Label@)">
             Sets jump to
             <param name="opcode">Branch instruction</param>
             <param name="destination">Destination for the jump</param>
             <param name="label">[out] The created label</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Insert(Harmony.CodeInstruction[])">
             Inserts some instructions
             <param name="instructions">The instructions</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Insert(System.Collections.Generic.IEnumerable{Harmony.CodeInstruction})">
             Inserts an enumeration of instructions
             <param name="instructions">The instructions</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.InsertBranch(System.Reflection.Emit.OpCode,System.Int32)">
             Inserts a branch
             <param name="opcode">The branch opcode</param>
             <param name="destination">Branch destination</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.InsertAndAdvance(Harmony.CodeInstruction[])">
             Inserts some instructions and advances the position
             <param name="instructions">The instructions</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.InsertAndAdvance(System.Collections.Generic.IEnumerable{Harmony.CodeInstruction})">
             Inserts an enumeration of instructions and advances the position
             <param name="instructions">The instructions</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.InsertBranchAndAdvance(System.Reflection.Emit.OpCode,System.Int32)">
             Inserts a branch and advances the position
             <param name="opcode">The branch opcode</param>
             <param name="destination">Branch destination</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.RemoveInstruction">
             Removes current instruction
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.RemoveInstructions(System.Int32)">
             Removes some instruction fro current position by count
             <param name="count">Number of instructions</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.RemoveInstructionsInRange(System.Int32,System.Int32)">
             Removes the instructions in a range
             <param name="start">The start</param>
             <param name="end">The end</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.RemoveInstructionsWithOffsets(System.Int32,System.Int32)">
             Removes the instructions in a offset range
             <param name="startOffset">The start offset</param>
             <param name="endOffset">The end offset</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Advance(System.Int32)">
             Advances the current position
             <param name="offset">The offset</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Start">
             Moves the current position to the start
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.End">
             Moves the current position to the end
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SearchForward(System.Func{Harmony.CodeInstruction,System.Boolean})">
             Searches forward with a predicate and advances position
             <param name="predicate">The predicate</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.SearchBack(System.Func{Harmony.CodeInstruction,System.Boolean})">
             Searches backwards with a predicate and reverses position
             <param name="predicate">The predicate</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.MatchForward(System.Boolean,Harmony.CodeMatch[])">
             Matches forward and advances position
             <param name="useEnd">True to set position to end of match, false to set it to the beginning of the match</param>
             <param name="matches">Some code matches</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.MatchBack(System.Boolean,Harmony.CodeMatch[])">
             Matches backwards and reverses position
             <param name="useEnd">True to set position to end of match, false to set it to the beginning of the match</param>
             <param name="matches">Some code matches</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.Repeat(System.Action{Harmony.CodeMatcher},System.Action{System.String})">
             Repeats a match action until boundaries are met
             <param name="matchAction">The match action</param>
             <param name="notFoundAction">An optional action that is executed when no match is found</param>
             <returns>The same code matcher</returns>

        </member>
        <member name="M:Harmony.CodeMatcher.NamedMatch(System.String)">
             Gets a match by its name
             <param name="name">The match name</param>
             <returns>An instruction</returns>

        </member>
        <member name="T:Harmony.CodeTranspiler">
            A helper class to transpile code
        </member>
        <member name="M:Harmony.CodeTranspiler.#ctor(System.Collections.Generic.List{Harmony.ILCopying.ILInstruction})">
             Create a code transpiler with an enumeration of instructions
             <param name="ilInstructions">The IL instructions</param>

        </member>
        <member name="M:Harmony.CodeTranspiler.Add(System.Reflection.MethodInfo)">
             Add a transpiler
             <param name="transpiler">The transpiler</param>

        </member>
        <member name="M:Harmony.CodeTranspiler.ConvertInstruction(System.Type,System.Object,System.Collections.Generic.Dictionary{System.String,System.Object}@)">
             Convert an instruction
             <param name="type">The instruction type</param>
             <param name="instruction">The instruction</param>
             <param name="unassigned">[out] Unassigned instructions</param>
             <returns>The converted instruction</returns>

        </member>
        <member name="M:Harmony.CodeTranspiler.ShouldAddExceptionInfo(System.Object,System.Int32,System.Collections.Generic.List{System.Object},System.Collections.Generic.List{System.Object},System.Collections.Generic.Dictionary{System.Object,System.Collections.Generic.Dictionary{System.String,System.Object}})">
             ShouldAddExceptionInfo is used to determine if CodeInstructions from an older Harmony version were duplicating
               exception information as well as to preserve the exception information from being dropped when piping through
               multiple transpilers with mixed Harmony versions.

             <param name="op">The operation</param>
             <param name="opIndex">Zero-based index</param>
             <param name="originalInstructions">Original instructions</param>
             <param name="newInstructions">New instructions</param>
             <param name="unassignedValues">[out] Unassigned instructions</param>
             <returns>True if exception info should be added</returns>

        </member>
        <member name="M:Harmony.CodeTranspiler.ConvertInstructionsAndUnassignedValues(System.Type,System.Collections.IEnumerable,System.Collections.Generic.Dictionary{System.Object,System.Collections.Generic.Dictionary{System.String,System.Object}}@)">
             Convert instructions and unassigned values
             <param name="type">The type</param>
             <param name="enumerable">The enumerable</param>
             <param name="unassignedValues">[out] The unassigned values</param>
             <returns>The instructions converted</returns>

        </member>
        <member name="M:Harmony.CodeTranspiler.ConvertToOurInstructions(System.Collections.IEnumerable,System.Collections.Generic.List{System.Object},System.Collections.Generic.Dictionary{System.Object,System.Collections.Generic.Dictionary{System.String,System.Object}})">
             Converts instructions to our own instructions
             <param name="instructions">The instructions to be converted</param>
             <param name="originalInstructions">The original instructions</param>
             <param name="unassignedValues">[out] The unassigned values</param>
             <returns>The converted instructions</returns>

        </member>
        <member name="M:Harmony.CodeTranspiler.ConvertToGeneralInstructions(System.Reflection.MethodInfo,System.Collections.IEnumerable,System.Collections.Generic.Dictionary{System.Object,System.Collections.Generic.Dictionary{System.String,System.Object}}@)">
             Converts instructions to general instructions
             <param name="transpiler">The transpiler</param>
             <param name="enumerable">The instructions</param>
             <param name="unassignedValues">[out] The unassigned values</param>
             <returns>The converted instructions</returns>

        </member>
        <member name="M:Harmony.CodeTranspiler.GetTranspilerCallParameters(System.Reflection.Emit.ILGenerator,System.Reflection.MethodInfo,System.Reflection.MethodBase,System.Collections.IEnumerable)">
             Gets transpiler call parameters
             <param name="generator">The generator</param>
             <param name="transpiler">The transpiler</param>
             <param name="method">The method</param>
             <param name="instructions">The instructions</param>
             <returns>The call parameters</returns>

        </member>
        <member name="M:Harmony.CodeTranspiler.GetResult(System.Reflection.Emit.ILGenerator,System.Reflection.MethodBase)">
             Gets a the final instructions
             <param name="generator">The generator</param>
             <param name="method">The original method</param>
             <returns>The final instruction</returns>

        </member>
        <member name="T:Harmony.DelegateTypeFactory">
            A factory to create delegate types
        </member>
        <member name="M:Harmony.DelegateTypeFactory.#ctor">
            Default constructor
        </member>
        <member name="M:Harmony.DelegateTypeFactory.CreateDelegateType(System.Reflection.MethodInfo)">
             Creates a delegate type for a method
             <param name="method">The method</param>
             <returns>The new delegate type</returns>

        </member>
        <member name="T:Harmony.GetterHandler">
             A getter delegate type
             <param name="source">The instance get getter uses</param>
             <returns>An delegate</returns>

        </member>
        <member name="T:Harmony.SetterHandler">
             A setter delegate type
             <param name="source">The instance the setter uses</param>
             <param name="value">The value the setter uses</param>
             <returns>An delegate</returns>

        </member>
        <member name="T:Harmony.InstantiationHandler">
             A constructor delegate type
             <returns>An delegate</returns>

        </member>
        <member name="T:Harmony.FastAccess">
            A helper class for fast access to getters and setters
        </member>
        <member name="M:Harmony.FastAccess.CreateInstantiationHandler(System.Type)">
             Creates an instantiation delegate
             <param name="type">The type</param>
             <returns>The new instantiation delegate</returns>

        </member>
        <member name="M:Harmony.FastAccess.CreateGetterHandler(System.Reflection.PropertyInfo)">
             Creates an getter delegate for a property
             <param name="propertyInfo">The property</param>
             <returns>The new getter delegate</returns>

        </member>
        <member name="M:Harmony.FastAccess.CreateGetterHandler(System.Reflection.FieldInfo)">
             Creates an getter delegate for a field
             <param name="fieldInfo">The field</param>
             <returns>The new getter delegate</returns>

        </member>
        <member name="M:Harmony.FastAccess.CreateFieldGetter(System.Type,System.String[])">
             Creates an getter delegate for a field (with a list of possible field names)
             <param name="type">The type</param>
             <param name="names">A list of possible field names</param>
             <returns>The new getter delegate</returns>

        </member>
        <member name="M:Harmony.FastAccess.CreateSetterHandler(System.Reflection.PropertyInfo)">
             Creates an setter delegate
             <param name="propertyInfo">The property</param>
             <returns>The new setter delegate</returns>

        </member>
        <member name="M:Harmony.FastAccess.CreateSetterHandler(System.Reflection.FieldInfo)">
             Creates an setter delegate for a field
             <param name="fieldInfo">The field</param>
             <returns>The new getter delegate</returns>

        </member>
        <member name="T:Harmony.FastInvokeHandler">
             A delegate to invoke a method
             <param name="target">The instance</param>
             <param name="parameters">The method parameters</param>
             <returns>The method result</returns>

        </member>
        <member name="T:Harmony.MethodInvoker">
            A helper class to invoke method with delegates
        </member>
        <member name="M:Harmony.MethodInvoker.GetHandler(System.Reflection.Emit.DynamicMethod,System.Reflection.Module)">
             Creates a fast invocation handler from a method and a module
             <param name="methodInfo">The method to invoke</param>
             <param name="module">The module context</param>
             <returns>The fast invocation handler</returns>

        </member>
        <member name="M:Harmony.MethodInvoker.GetHandler(System.Reflection.MethodInfo)">
             Creates a fast invocation handler from a method and a module
             <param name="methodInfo">The method to invoke</param>
             <returns>The fast invocation handler</returns>

        </member>
        <member name="T:Harmony.HarmonyInstance">
            A Harmony instance
        </member>
        <member name="P:Harmony.HarmonyInstance.Id">
            The unique identifier
        </member>
        <member name="F:Harmony.HarmonyInstance.DEBUG">
            Set to true before instantiating Harmony to debug Harmony
        </member>
        <member name="M:Harmony.HarmonyInstance.Create(System.String)">
             Creates a new Harmony instance
             <param name="id">A unique identifier</param>
             <returns>A Harmony instance</returns>

        </member>
        <member name="M:Harmony.HarmonyInstance.PatchAll">
            Searches current assembly for Harmony annotations and uses them to create patches

        </member>
        <member name="M:Harmony.HarmonyInstance.PatchAll(System.Reflection.Assembly)">
            Searches an assembly for Harmony annotations and uses them to create patches
            <param name="assembly">The assembly</param>

        </member>
        <member name="M:Harmony.HarmonyInstance.Patch(System.Reflection.MethodBase,Harmony.HarmonyMethod,Harmony.HarmonyMethod,Harmony.HarmonyMethod)">
             Creates patches by manually specifying the methods
             <param name="original">The original method</param>
             <param name="prefix">An optional prefix method wrapped in a HarmonyMethod object</param>
             <param name="postfix">An optional postfix method wrapped in a HarmonyMethod object</param>
             <param name="transpiler">An optional transpiler method wrapped in a HarmonyMethod object</param>
             <returns>The dynamic method that was created to patch the original method</returns>

        </member>
        <member name="M:Harmony.HarmonyInstance.UnpatchAll(System.String)">
             Unpatches methods
             <param name="harmonyID">The optional Harmony ID to restrict unpatching to a specific instance</param>

        </member>
        <member name="M:Harmony.HarmonyInstance.Unpatch(System.Reflection.MethodBase,Harmony.HarmonyPatchType,System.String)">
             Unpatches a method
             <param name="original">The original method</param>
             <param name="type">The patch type</param>
             <param name="harmonyID">The optional Harmony ID to restrict unpatching to a specific instance</param>

        </member>
        <member name="M:Harmony.HarmonyInstance.Unpatch(System.Reflection.MethodBase,System.Reflection.MethodInfo)">
             Unpatches a method
             <param name="original">The original method</param>
             <param name="patch">The patch method to remove</param>

        </member>
        <member name="M:Harmony.HarmonyInstance.HasAnyPatches(System.String)">
             Test for patches from a specific Harmony ID
             <param name="harmonyID">The Harmony ID</param>
             <returns>True if patches for this ID exist</returns>

        </member>
        <member name="M:Harmony.HarmonyInstance.GetPatchInfo(System.Reflection.MethodBase)">
             Gets patch information for a given original method
             <param name="method">The original method</param>
             <returns>The patch information</returns>

        </member>
        <member name="M:Harmony.HarmonyInstance.GetPatchedMethods">
             Gets a patched methods
             <returns>An enumeration of original methods</returns>

        </member>
        <member name="M:Harmony.HarmonyInstance.VersionInfo(System.Version@)">
             Gets current version information
             <param name="currentVersion">[out] The current Harmony version</param>
             <returns>A dictionary containing assembly versions keyed by Harmony version</returns>

        </member>
        <member name="T:Harmony.HarmonyMethod">
            A harmony annotation
        </member>
        <member name="F:Harmony.HarmonyMethod.method">
            The original method
        </member>
        <member name="F:Harmony.HarmonyMethod.declaringType">
            Declaring class
        </member>
        <member name="F:Harmony.HarmonyMethod.methodName">
            Method name
        </member>
        <member name="F:Harmony.HarmonyMethod.methodType">
            Method type
        </member>
        <member name="F:Harmony.HarmonyMethod.argumentTypes">
            Argument types
        </member>
        <member name="F:Harmony.HarmonyMethod.priority">
            Priority
        </member>
        <member name="F:Harmony.HarmonyMethod.before">
            Before parameter
        </member>
        <member name="F:Harmony.HarmonyMethod.after">
            After parameter
        </member>
        <member name="M:Harmony.HarmonyMethod.#ctor">
            Default constructor
        </member>
        <member name="M:Harmony.HarmonyMethod.#ctor(System.Reflection.MethodInfo)">
             Creates an annotation from a method
             <param name="method">The original method</param>

        </member>
        <member name="M:Harmony.HarmonyMethod.#ctor(System.Type,System.String,System.Type[])">
             Creates an annotation from a method.
             <param name="type">The type</param>
             <param name="name">The method name</param>
             <param name="parameters">The optional argument types for overloaded methods</param>

        </member>
        <member name="M:Harmony.HarmonyMethod.HarmonyFields">
             Gets the names of all internal patch info fields
             <returns>A list of field names</returns>

        </member>
        <member name="M:Harmony.HarmonyMethod.Merge(System.Collections.Generic.List{Harmony.HarmonyMethod})">
             Merges annotations
             <param name="attributes">The annotations</param>
             <returns>A merged annotation</returns>

        </member>
        <member name="M:Harmony.HarmonyMethod.ToString">
             Returns a string that represents the annotation
             <returns>A string representation</returns>

        </member>
        <member name="T:Harmony.HarmonyMethodExtensions">
            Annotation extensions
        </member>
        <member name="M:Harmony.HarmonyMethodExtensions.CopyTo(Harmony.HarmonyMethod,Harmony.HarmonyMethod)">
             Copies annotation information
             <param name="from">from</param>
             <param name="to">to</param>

        </member>
        <member name="M:Harmony.HarmonyMethodExtensions.Clone(Harmony.HarmonyMethod)">
             Clones an annotation
             <param name="original">The annotation to clone</param>
             <returns>A copy of the annotation</returns>

        </member>
        <member name="M:Harmony.HarmonyMethodExtensions.Merge(Harmony.HarmonyMethod,Harmony.HarmonyMethod)">
             Merges annotations
             <param name="master">The master</param>
             <param name="detail">The detail</param>
             <returns>A new, merged copy</returns>

        </member>
        <member name="M:Harmony.HarmonyMethodExtensions.GetHarmonyMethods(System.Type)">
             Gets all annotations on a class
             <param name="type">The class</param>
             <returns>All annotations</returns>

        </member>
        <member name="M:Harmony.HarmonyMethodExtensions.GetHarmonyMethods(System.Reflection.MethodBase)">
             Gets all annotations on a method
             <param name="method">The method</param>
             <returns>All annotations</returns>

        </member>
        <member name="T:Harmony.HarmonySharedState">
            Harmony shared state
        </member>
        <member name="T:Harmony.ILCopying.ByteBuffer">
            A byte buffer
        </member>
        <member name="F:Harmony.ILCopying.ByteBuffer.buffer">
            The buffer
        </member>
        <member name="F:Harmony.ILCopying.ByteBuffer.position">
            The position
        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.#ctor(System.Byte[])">
             Creates a buffer from a byte array
             <param name="buffer">The byte array</param>

        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.ReadByte">
             Reads a byte
             <returns>The byte</returns>

        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.ReadBytes(System.Int32)">
             Reads some bytes
             <param name="length">The number of bytes to read</param>
             <returns>An array of bytes</returns>

        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.ReadInt16">
             Reads an Int16
             <returns>The Int16</returns>

        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.ReadInt32">
             Reads Int32
             <returns>The Int32</returns>

        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.ReadInt64">
             Reads Int64
             <returns>The Int64</returns>

        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.ReadSingle">
             Reads a Single
             <returns>The single</returns>

        </member>
        <member name="M:Harmony.ILCopying.ByteBuffer.ReadDouble">
             Reads a Double
             <returns>The double</returns>

        </member>
        <member name="T:Harmony.ILCopying.LeaveTry">
            A leave try
        </member>
        <member name="M:Harmony.ILCopying.LeaveTry.ToString">
             Returns a string that represents the current object
             <returns>A string that represents the current object</returns>

        </member>
        <member name="T:Harmony.ILCopying.Emitter">
            An emitter
        </member>
        <member name="M:Harmony.ILCopying.Emitter.CodePos(System.Reflection.Emit.ILGenerator)">
             Code position
             <param name="il">The il</param>
             <returns>A string</returns>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.LogIL(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Object)">
             Logs an il
             <param name="il">		The il</param>
             <param name="opCode">  The operation code</param>
             <param name="argument">The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.LogLocalVariable(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.LocalBuilder)">
             Logs local variable
             <param name="il">		The il</param>
             <param name="variable">The variable</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.FormatArgument(System.Object)">
             Format argument
             <param name="argument">The argument</param>
             <returns>The formatted argument</returns>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.MarkLabel(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.Label)">
             Mark label
             <param name="il">	The il</param>
             <param name="label">The label</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.MarkBlockBefore(System.Reflection.Emit.ILGenerator,Harmony.ILCopying.ExceptionBlock,System.Nullable{System.Reflection.Emit.Label}@)">
             Mark block before
             <param name="il">	The il</param>
             <param name="block">The block</param>
             <param name="label">[out] The label</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.MarkBlockAfter(System.Reflection.Emit.ILGenerator,Harmony.ILCopying.ExceptionBlock)">
             Mark block after
             <param name="il">	The il</param>
             <param name="block">The block</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode)">
             MethodCopier calls when Operand type is InlineNone
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.Emit.LocalBuilder)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="local"> The local</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.FieldInfo)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="field"> The field</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.Emit.Label[])">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="labels">The labels</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.Emit.Label)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="label"> The label</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.String)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="str">	 The string</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Single)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="arg">	 The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Byte)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="arg">	 The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.SByte)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="arg">	 The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Double)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="arg">	 The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Int32)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="arg">	 The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.MethodInfo)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="meth">  The meth</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Int16)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="arg">	 The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.Emit.SignatureHelper)">
             MethodCopier calls by 3rd argument type
             <param name="il">		 The il</param>
             <param name="opcode">	 The opcode</param>
             <param name="signature">The signature</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.ConstructorInfo)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="con">	 The con</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Type)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="cls">	 The cls</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.Emit(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Int64)">
             MethodCopier calls by 3rd argument type
             <param name="il">	 The il</param>
             <param name="opcode">The opcode</param>
             <param name="arg">	 The argument</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.EmitCall(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.MethodInfo,System.Type[])">
             called from MethodInvoker (calls from MethodCopier use the corresponding Emit() call above)
             <param name="il">						  The il</param>
             <param name="opcode">					  The opcode</param>
             <param name="methodInfo">				  Information describing the method</param>
             <param name="optionalParameterTypes">List of types of the optional parameters</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.EmitCalli(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Runtime.InteropServices.CallingConvention,System.Type,System.Type[])">
             not called yet
             <param name="il">					The il</param>
             <param name="opcode">				The opcode</param>
             <param name="unmanagedCallConv">The unmanaged call convert</param>
             <param name="returnType">			Type of the return</param>
             <param name="parameterTypes">	List of types of the parameters</param>

        </member>
        <member name="M:Harmony.ILCopying.Emitter.EmitCalli(System.Reflection.Emit.ILGenerator,System.Reflection.Emit.OpCode,System.Reflection.CallingConventions,System.Type,System.Type[],System.Type[])">
             not called yet
             <param name="il">						  The il</param>
             <param name="opcode">					  The opcode</param>
             <param name="callingConvention">	  The calling convention</param>
             <param name="returnType">				  Type of the return</param>
             <param name="parameterTypes">		  List of types of the parameters</param>
             <param name="optionalParameterTypes">List of types of the optional parameters</param>

        </member>
        <member name="T:Harmony.ILCopying.ExceptionBlockType">
            Exception block types
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlockType.BeginExceptionBlock">
            The beginning of an exception block
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlockType.BeginCatchBlock">
            The beginning of a catch block
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlockType.BeginExceptFilterBlock">
            The beginning of an except filter block
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlockType.BeginFaultBlock">
            The beginning of a fault block
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlockType.BeginFinallyBlock">
            The beginning of a finally block
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlockType.EndExceptionBlock">
            The end of an exception block
        </member>
        <member name="T:Harmony.ILCopying.ExceptionBlock">
            An exception block
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlock.blockType">
            Block type
        </member>
        <member name="F:Harmony.ILCopying.ExceptionBlock.catchType">
            Catch type
        </member>
        <member name="M:Harmony.ILCopying.ExceptionBlock.#ctor(Harmony.ILCopying.ExceptionBlockType,System.Type)">
             Creates an exception block
             <param name="blockType">Block type</param>
             <param name="catchType">Catch type</param>

        </member>
        <member name="T:Harmony.ILCopying.ILInstruction">
            An intermediate language instruction
        </member>
        <member name="F:Harmony.ILCopying.ILInstruction.offset">
            The offset
        </member>
        <member name="F:Harmony.ILCopying.ILInstruction.opcode">
            The opcode
        </member>
        <member name="F:Harmony.ILCopying.ILInstruction.operand">
            The operand
        </member>
        <member name="F:Harmony.ILCopying.ILInstruction.argument">
            The argument
        </member>
        <member name="F:Harmony.ILCopying.ILInstruction.labels">
            The labels
        </member>
        <member name="F:Harmony.ILCopying.ILInstruction.blocks">
            The blocks
        </member>
        <member name="M:Harmony.ILCopying.ILInstruction.#ctor(System.Reflection.Emit.OpCode,System.Object)">
             Creates an intermediate language instruction
             <param name="opcode">The opcode</param>
             <param name="operand">The optional operand</param>

        </member>
        <member name="M:Harmony.ILCopying.ILInstruction.GetCodeInstruction">
             Gets the CodeInstruction
             <returns>The code instruction</returns>

        </member>
        <member name="M:Harmony.ILCopying.ILInstruction.GetSize">
             Gets the size
             <returns>The size</returns>

        </member>
        <member name="M:Harmony.ILCopying.ILInstruction.ToString">
             Returns a string that represents the current object
             <returns>A string representation</returns>

        </member>
        <member name="T:Harmony.ILCopying.Protection">
            A bit-field of flags for protections
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_NOACCESS">
            No access
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_READONLY">
            Read only
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_READWRITE">
            Read write
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_WRITECOPY">
            Write copy
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_EXECUTE">
            No access
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_EXECUTE_READ">
            Execute read
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_EXECUTE_READWRITE">
            Execute read write
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_EXECUTE_WRITECOPY">
            Execute write copy
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_GUARD">
            guard
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_NOCACHE">
            No cache
        </member>
        <member name="F:Harmony.ILCopying.Protection.PAGE_WRITECOMBINE">
            Write combine
        </member>
        <member name="T:Harmony.ILCopying.Memory">
            A low level memory helper
        </member>
        <member name="P:Harmony.ILCopying.Memory.IsWindows">
             Is current environment Windows?
             <value>True if it is Windows</value>

        </member>
        <member name="M:Harmony.ILCopying.Memory.VirtualProtect(System.IntPtr,System.UIntPtr,Harmony.ILCopying.Protection,Harmony.ILCopying.Protection@)">
             Virtual protect
             <param name="lpAddress">The address</param>
             <param name="dwSize">The size</param>
             <param name="flNewProtect">The fl new protect</param>
             <param name="lpflOldProtect">[out] The lpfl old protect</param>
             <returns>Status</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.UnprotectMemoryPage(System.Int64)">
             Unprotect a memory page
             <param name="memory">The memory address</param>

        </member>
        <member name="M:Harmony.ILCopying.Memory.DetourMethod(System.Reflection.MethodBase,System.Reflection.MethodBase)">
             Detours a method
             <param name="original">The original method</param>
             <param name="replacement">The replacement method</param>
             <returns>An error string</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.WriteJump(System.Int64,System.Int64)">
             Writes a jump to memory
             <param name="memory">The memory address</param>
             <param name="destination">Jump destination</param>
             <returns>An error string</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.GetMethodStart(System.Reflection.MethodBase,System.Exception@)">
             Gets the start of a method in memory
             <param name="method">The method</param>
             <param name="exception">[out] Details of the exception</param>
             <returns>The method start address</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.CompareBytes(System.Int64,System.Byte[])">
             Compare bytes
             <param name="memory">The memory address</param>
             <param name="values">The bytes to compare to</param>
             <returns>True if memory address contains the bytes</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.ReadByte(System.Int64)">
             Reads a byte
             <param name="memory">The memory address</param>
             <returns>The byte</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.ReadInt(System.Int64)">
             Reads an int
             <param name="memory">The memory address</param>
             <returns>The int</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.ReadLong(System.Int64)">
             Reads a long
             <param name="memory">The memory address</param>
             <returns>The long</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.WriteByte(System.Int64,System.Byte)">
             Writes a byte
             <param name="memory">The memory address</param>
             <param name="value">The byte</param>
             <returns>Advanced memory address</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.WriteBytes(System.Int64,System.Byte[])">
             Writes some bytes
             <param name="memory">The memory address</param>
             <param name="values">The bytes to write</param>
             <returns>Advanced memory address</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.WriteInt(System.Int64,System.Int32)">
             Writes an int
             <param name="memory">The memory address</param>
             <param name="value">The int</param>
             <returns>Advanced memory address</returns>

        </member>
        <member name="M:Harmony.ILCopying.Memory.WriteLong(System.Int64,System.Int64)">
             Writes a long
             <param name="memory">The memory address</param>
             <param name="value"> The long</param>
             <returns>Advanced memory address</returns>

        </member>
        <member name="T:Harmony.ILCopying.MethodCopier">
            A method copier
        </member>
        <member name="M:Harmony.ILCopying.MethodCopier.#ctor(System.Reflection.MethodBase,System.Reflection.Emit.ILGenerator,System.Reflection.Emit.LocalBuilder[])">
             Creates a method copier
             <param name="fromMethod">Source method</param>
             <param name="toILGenerator">The IL generator.</param>
             <param name="existingVariables">Optionally, existing variables</param>

        </member>
        <member name="M:Harmony.ILCopying.MethodCopier.AddTranspiler(System.Reflection.MethodInfo)">
             Adds a transpiler
             <param name="transpiler">The transpiler</param>

        </member>
        <member name="M:Harmony.ILCopying.MethodCopier.Finalize(System.Collections.Generic.List{System.Reflection.Emit.Label},System.Collections.Generic.List{Harmony.ILCopying.ExceptionBlock})">
             Finalizes all codes
             <param name="endLabels">The end labels</param>
             <param name="endBlocks">The end blocks</param>

        </member>
        <member name="T:Harmony.ILCopying.MethodBodyReader">
            A method body reader
        </member>
        <member name="M:Harmony.ILCopying.MethodBodyReader.GetInstructions(System.Reflection.Emit.ILGenerator,System.Reflection.MethodBase)">

               NOTE: you cannot simply "copy" ILInstructions from a method. They contain references to
               local variables which must be CREATED on an ILGenerator or else they are invalid when you
               want to use the ILInstruction. If you are really clever, you can supply a dummy generator
               and edit out all labels during the processing but that might be more trickier than you think

               In order to copy together a bunch of method parts within a transpiler, you have to pass in
               your current generator that builds your new method

               You will end up with the sum of all declared local variables of all methods you run
               GetInstructions on or use a dummy generator but edit out the invalid labels from the codes
               you copy.

             <param name="generator">The generator.</param>
             <param name="method">	 The method.</param>
             <returns>The instructions.</returns>

        </member>
        <member name="M:Harmony.ILCopying.MethodBodyReader.#ctor(System.Reflection.MethodBase,System.Reflection.Emit.ILGenerator)">
             Creates a method body reader
             <param name="method">The original method</param>
             <param name="generator">The IL generator</param>

        </member>
        <member name="M:Harmony.ILCopying.MethodBodyReader.ReadInstructions">
            Read and parse IL codes
        </member>
        <member name="M:Harmony.ILCopying.MethodBodyReader.DeclareVariables(System.Reflection.Emit.LocalBuilder[])">
             Declare local variables
             <param name="existingVariables">The existing variables to copy</param>

        </member>
        <member name="M:Harmony.ILCopying.MethodBodyReader.FinalizeILCodes(System.Collections.Generic.List{System.Reflection.MethodInfo},System.Collections.Generic.List{System.Reflection.Emit.Label},System.Collections.Generic.List{Harmony.ILCopying.ExceptionBlock})">
             Finalize all codes and apply all transpilers
             <param name="transpilers">The transpilers to apply</param>
             <param name="endLabels">The end labels</param>
             <param name="endBlocks">The end blocks</param>

        </member>
        <member name="M:Harmony.ILCopying.MethodBodyReader.ThisParameter.#ctor(System.Reflection.MethodBase)">
             Creates a new this parameter
             <param name="method">The method</param>

        </member>
        <member name="T:Harmony.MethodPatcher">
            A method patch helper
        </member>
        <member name="F:Harmony.MethodPatcher.INSTANCE_PARAM">
            special parameter names that can be used in prefix and postfix methods
            Instance parameter name
        </member>
        <member name="F:Harmony.MethodPatcher.ORIGINAL_METHOD_PARAM">
            Original method parameter name
        </member>
        <member name="F:Harmony.MethodPatcher.RESULT_VAR">
            Result variable name
        </member>
        <member name="F:Harmony.MethodPatcher.STATE_VAR">
            State variable name
        </member>
        <member name="F:Harmony.MethodPatcher.PARAM_INDEX_PREFIX">
            Parameter index prefix
        </member>
        <member name="F:Harmony.MethodPatcher.INSTANCE_FIELD_PREFIX">
            Instance field prefix
        </member>
        <member name="M:Harmony.MethodPatcher.CreatePatchedMethod(System.Reflection.MethodBase,System.Collections.Generic.List{System.Reflection.MethodInfo},System.Collections.Generic.List{System.Reflection.MethodInfo},System.Collections.Generic.List{System.Reflection.MethodInfo})">
             Creates patched method
             <param name="original">The original method</param>
             <param name="prefixes">The prefix methods</param>
             <param name="postfixes">The postfix methods</param>
             <param name="transpilers">The transpiler methods</param>
             <returns>A new dynamic method</returns>

        </member>
        <member name="M:Harmony.MethodPatcher.CreatePatchedMethod(System.Reflection.MethodBase,System.String,System.Collections.Generic.List{System.Reflection.MethodInfo},System.Collections.Generic.List{System.Reflection.MethodInfo},System.Collections.Generic.List{System.Reflection.MethodInfo})">
             Creates patched method.
             <exception cref="T:System.ArgumentNullException">Thrown when one or more required arguments are null.</exception>
             <exception cref="T:System.Exception">				  Thrown when an exception error condition occurs.</exception>
             <param name="original">			The original method.</param>
             <param name="harmonyInstanceID">Identifier for the harmony instance.</param>
             <param name="prefixes">			The prefix methods.</param>
             <param name="postfixes">			The postfix methods.</param>
             <param name="transpilers">		The transpiler methods.</param>
             <returns>A new dynamic method.</returns>

        </member>
        <member name="T:Harmony.PatchInfoSerialization">
            Patch serialization
        </member>
        <member name="M:Harmony.PatchInfoSerialization.Binder.BindToType(System.String,System.String)">
             Control the binding of a serialized object to a type
             <param name="assemblyName">Specifies the assembly name of the serialized object</param>
             <param name="typeName">Specifies the type name of the serialized object</param>
             <returns>The type of the object the formatter creates a new instance of</returns>

        </member>
        <member name="M:Harmony.PatchInfoSerialization.Serialize(Harmony.PatchInfo)">
             Serializes a patch info
             <param name="patchInfo">The patch info</param>
             <returns>A byte array</returns>

        </member>
        <member name="M:Harmony.PatchInfoSerialization.Deserialize(System.Byte[])">
             Deserialize a patch info
             <param name="bytes">The byte array</param>
             <returns>A patch info</returns>

        </member>
        <member name="M:Harmony.PatchInfoSerialization.PriorityComparer(System.Object,System.Int32,System.Int32,System.String[],System.String[])">
             Compare function to sort patch priorities
             <param name="obj">The patch</param>
             <param name="index">Zero-based index</param>
             <param name="priority">The priority</param>
             <param name="before">The before parameter</param>
             <param name="after">The after parameter</param>
             <returns>A standard sort integer (-1, 0, 1)</returns>

        </member>
        <member name="T:Harmony.PatchInfo">
            Serializable patch information
        </member>
        <member name="F:Harmony.PatchInfo.prefixes">
            The prefixes
        </member>
        <member name="F:Harmony.PatchInfo.postfixes">
            The postfixes
        </member>
        <member name="F:Harmony.PatchInfo.transpilers">
            The transpilers
        </member>
        <member name="M:Harmony.PatchInfo.#ctor">
            Default constructor
        </member>
        <member name="M:Harmony.PatchInfo.AddPrefix(System.Reflection.MethodInfo,System.String,System.Int32,System.String[],System.String[])">
             Adds a prefix
             <param name="patch">The patch</param>
             <param name="owner">The owner (Harmony ID)</param>
             <param name="priority">The priority</param>
             <param name="before">The before parameter</param>
             <param name="after">The after parameter</param>

        </member>
        <member name="M:Harmony.PatchInfo.RemovePrefix(System.String)">
             Removes a prefix
             <param name="owner">The owner or (*) for any</param>

        </member>
        <member name="M:Harmony.PatchInfo.AddPostfix(System.Reflection.MethodInfo,System.String,System.Int32,System.String[],System.String[])">
             Adds a postfix
             <param name="patch">The patch</param>
             <param name="owner">The owner (Harmony ID)</param>
             <param name="priority">The priority</param>
             <param name="before">The before parameter</param>
             <param name="after">The after parameter</param>

        </member>
        <member name="M:Harmony.PatchInfo.RemovePostfix(System.String)">
             Removes a postfix
             <param name="owner">The owner or (*) for any</param>

        </member>
        <member name="M:Harmony.PatchInfo.AddTranspiler(System.Reflection.MethodInfo,System.String,System.Int32,System.String[],System.String[])">
             Adds a transpiler
             <param name="patch">The patch</param>
             <param name="owner">The owner (Harmony ID)</param>
             <param name="priority">The priority</param>
             <param name="before">The before parameter</param>
             <param name="after">The after parameter</param>

        </member>
        <member name="M:Harmony.PatchInfo.RemoveTranspiler(System.String)">
             Removes a transpiler
             <param name="owner">The owner or (*) for any</param>

        </member>
        <member name="M:Harmony.PatchInfo.RemovePatch(System.Reflection.MethodInfo)">
             Removes a patch
             <param name="patch">The patch method</param>

        </member>
        <member name="T:Harmony.Patch">
            A serializable patch
        </member>
        <member name="F:Harmony.Patch.index">
            Zero-based index
        </member>
        <member name="F:Harmony.Patch.owner">
            The owner (Harmony ID)
        </member>
        <member name="F:Harmony.Patch.priority">
            The priority
        </member>
        <member name="F:Harmony.Patch.before">
            The before
        </member>
        <member name="F:Harmony.Patch.after">
            The after
        </member>
        <member name="F:Harmony.Patch.patch">
            The patch method
        </member>
        <member name="M:Harmony.Patch.#ctor(System.Reflection.MethodInfo,System.Int32,System.String,System.Int32,System.String[],System.String[])">
             Creates a patch
             <param name="patch">The patch</param>
             <param name="index">Zero-based index</param>
             <param name="owner">The owner (Harmony ID)</param>
             <param name="priority">The priority</param>
             <param name="before">The before parameter</param>
             <param name="after">The after parameter</param>

        </member>
        <member name="M:Harmony.Patch.GetMethod(System.Reflection.MethodBase)">
             Gets the patch method
             <param name="original">The original method</param>
             <returns>The patch method</returns>

        </member>
        <member name="M:Harmony.Patch.Equals(System.Object)">
             Determines whether patches are equal
             <param name="obj">The other patch</param>
             <returns>true if equal</returns>

        </member>
        <member name="M:Harmony.Patch.CompareTo(System.Object)">
             Determines how patches sort
             <param name="obj">The other patch</param>
             <returns>integer to define sort order (-1, 0, 1)</returns>

        </member>
        <member name="M:Harmony.Patch.GetHashCode">
             Hash function
             <returns>A hash code</returns>

        </member>
        <member name="T:Harmony.Patches">
            A group of patches
        </member>
        <member name="F:Harmony.Patches.Prefixes">
            The prefixes
        </member>
        <member name="F:Harmony.Patches.Postfixes">
            The postfixes
        </member>
        <member name="F:Harmony.Patches.Transpilers">
            The transpilers
        </member>
        <member name="P:Harmony.Patches.Owners">
             Gets all owners (Harmony IDs) or all known patches
             <value>The patch owners</value>

        </member>
        <member name="M:Harmony.Patches.#ctor(Harmony.Patch[],Harmony.Patch[],Harmony.Patch[])">
             Creates a group of patches
             <param name="prefixes">The prefixes</param>
             <param name="postfixes">The postfixes</param>
             <param name="transpilers">The transpilers</param>

        </member>
        <member name="T:Harmony.PatchFunctions">
            Patch function helpers
        </member>
        <member name="M:Harmony.PatchFunctions.AddPrefix(Harmony.PatchInfo,System.String,Harmony.HarmonyMethod)">
             Adds a prefix
             <param name="patchInfo">The patch info</param>
             <param name="owner">The owner (Harmony ID)</param>
             <param name="info">The annotation info</param>

        </member>
        <member name="M:Harmony.PatchFunctions.RemovePrefix(Harmony.PatchInfo,System.String)">
             Removes a prefix
             <param name="patchInfo">The patch info</param>
             <param name="owner">The owner (Harmony ID)</param>

        </member>
        <member name="M:Harmony.PatchFunctions.AddPostfix(Harmony.PatchInfo,System.String,Harmony.HarmonyMethod)">
             Adds a postfix
             <param name="patchInfo">The patch info</param>
             <param name="owner">The owner (Harmony ID)</param>
             <param name="info">The annotation info</param>

        </member>
        <member name="M:Harmony.PatchFunctions.RemovePostfix(Harmony.PatchInfo,System.String)">
             Removes a postfix
             <param name="patchInfo">The patch info</param>
             <param name="owner">The owner (Harmony ID)</param>

        </member>
        <member name="M:Harmony.PatchFunctions.AddTranspiler(Harmony.PatchInfo,System.String,Harmony.HarmonyMethod)">
             Adds a transpiler
             <param name="patchInfo">The patch info</param>
             <param name="owner">The owner (Harmony ID)</param>
             <param name="info">The annotation info</param>

        </member>
        <member name="M:Harmony.PatchFunctions.RemoveTranspiler(Harmony.PatchInfo,System.String)">
             Removes a transpiler
             <param name="patchInfo">The patch info</param>
             <param name="owner">The owner (Harmony ID)</param>

        </member>
        <member name="M:Harmony.PatchFunctions.RemovePatch(Harmony.PatchInfo,System.Reflection.MethodInfo)">
             Removes a patch method
             <param name="patchInfo">The patch info</param>
             <param name="patch">The patch method</param>

        </member>
        <member name="M:Harmony.PatchFunctions.GetInstructions(System.Reflection.Emit.ILGenerator,System.Reflection.MethodBase)">
             Gets all instructions from a method
             <param name="generator">The generator (for defining labels)</param>
             <param name="method">The original method</param>
             <returns>The instructions</returns>

        </member>
        <member name="M:Harmony.PatchFunctions.GetSortedPatchMethods(System.Reflection.MethodBase,Harmony.Patch[])">
             Gets sorted patch methods
             <param name="original">The original method</param>
             <param name="patches">Patches to sort</param>
             <returns>The sorted patch methods</returns>

        </member>
        <member name="M:Harmony.PatchFunctions.UpdateWrapper(System.Reflection.MethodBase,Harmony.PatchInfo,System.String)">
             Creates new dynamic method with the latest patches and detours the original method
             <param name="original">The original method</param>
             <param name="patchInfo">Information describing the patches</param>
             <param name="instanceID">Harmony ID</param>
             <returns>The newly created dynamic method</returns>

        </member>
        <member name="T:Harmony.PatchProcessor">
            A patch processor
        </member>
        <member name="M:Harmony.PatchProcessor.#ctor(Harmony.HarmonyInstance,System.Type,Harmony.HarmonyMethod)">
             Creates a patch processor
             <param name="instance">The Harmony instance</param>
             <param name="type">The patch class</param>
             <param name="attributes">The Harmony attributes</param>

        </member>
        <member name="M:Harmony.PatchProcessor.#ctor(Harmony.HarmonyInstance,System.Collections.Generic.List{System.Reflection.MethodBase},Harmony.HarmonyMethod,Harmony.HarmonyMethod,Harmony.HarmonyMethod)">
             Creates a patch processor
             <param name="instance">The Harmony instance.</param>
             <param name="originals">The original methods</param>
             <param name="prefix">The optional prefix.</param>
             <param name="postfix">The optional postfix.</param>
             <param name="transpiler">The optional transpiler.</param>

        </member>
        <member name="M:Harmony.PatchProcessor.GetPatchInfo(System.Reflection.MethodBase)">
             Gets patch information
             <param name="method">The original method</param>
             <returns>The patch information</returns>

        </member>
        <member name="M:Harmony.PatchProcessor.AllPatchedMethods">
             Gets all patched original methods
             <returns>All patched original methods</returns>

        </member>
        <member name="M:Harmony.PatchProcessor.Patch">
             Applies the patch
             <returns>A list of all created dynamic methods</returns>

        </member>
        <member name="M:Harmony.PatchProcessor.Unpatch(Harmony.HarmonyPatchType,System.String)">
             Unpatches patches of a given type and/or Harmony ID
             <param name="type">The patch type</param>
             <param name="harmonyID">Harmony ID or (*) for any</param>

        </member>
        <member name="M:Harmony.PatchProcessor.Unpatch(System.Reflection.MethodInfo)">
             Unpatches the given patch
             <param name="patch">The patch</param>

        </member>
        <member name="T:Harmony.Priority">
            A patch priority
        </member>
        <member name="F:Harmony.Priority.Last">
            Patch last
        </member>
        <member name="F:Harmony.Priority.VeryLow">
            Patch with very low priority
        </member>
        <member name="F:Harmony.Priority.Low">
            Patch with low priority
        </member>
        <member name="F:Harmony.Priority.LowerThanNormal">
            Patch with lower than normal priority
        </member>
        <member name="F:Harmony.Priority.Normal">
            Patch with normal priority
        </member>
        <member name="F:Harmony.Priority.HigherThanNormal">
            Patch with higher than normal priority
        </member>
        <member name="F:Harmony.Priority.High">
            Patch with high priority
        </member>
        <member name="F:Harmony.Priority.VeryHigh">
            Patch with very high priority
        </member>
        <member name="F:Harmony.Priority.First">
            Patch first
        </member>
        <member name="T:Harmony.AccessCache">
            A access cache for speeding up reflections
        </member>
        <member name="M:Harmony.AccessCache.GetFieldInfo(System.Type,System.String)">
             Gets field information
             <param name="type">The type</param>
             <param name="name">The name</param>
             <returns>The field information</returns>

        </member>
        <member name="M:Harmony.AccessCache.GetPropertyInfo(System.Type,System.String)">
             Gets property information
             <param name="type">The type</param>
             <param name="name">The name</param>
             <returns>The property information</returns>

        </member>
        <member name="M:Harmony.AccessCache.GetMethodInfo(System.Type,System.String,System.Type[])">
             Gets method information
             <param name="type">		 The type</param>
             <param name="name">		 The name</param>
             <param name="arguments">The arguments</param>
             <returns>The method information</returns>

        </member>
        <member name="T:Harmony.AccessTools">
            A helper class for reflection related functions
        </member>
        <member name="F:Harmony.AccessTools.all">
            Shortcut to simplify the use of reflections and make it work for any access level
        </member>
        <member name="M:Harmony.AccessTools.TypeByName(System.String)">
             Gets a type by name. Prefers a full name with namespace but falls back to the first type matching the name otherwise
             <param name="name">The name</param>
             <returns>A Type</returns>

        </member>
        <member name="M:Harmony.AccessTools.FindIncludingBaseTypes``1(System.Type,System.Func{System.Type,``0})">
             Applies a function going up the type hierarchy and stops at the first non null result
             <typeparam name="T">Result type of func()</typeparam>
             <param name="type">The type to start with</param>
             <param name="func">The evaluation function returning T</param>
             <returns>Returns the first non null result or default(T) when reaching the top level type object</returns>

        </member>
        <member name="M:Harmony.AccessTools.FindIncludingInnerTypes``1(System.Type,System.Func{System.Type,``0})">
             Applies a function going into inner types and stops at the first non null result
             <typeparam name="T">Generic type parameter</typeparam>
             <param name="type">The type to start with</param>
             <param name="func">The evaluation function returning T</param>
             <returns>Returns the first non null result or null with no match</returns>

        </member>
        <member name="M:Harmony.AccessTools.DeclaredField(System.Type,System.String)">
             Gets the reflection information for a directly declared field
             <param name="type">The class where the field is defined</param>
             <param name="name">The name of the field</param>
             <returns>A FieldInfo or null when type/name is null or when the field cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.Field(System.Type,System.String)">
             Gets the reflection information for a field by searching the type and all its super types
             <param name="type">The class where the field is defined</param>
             <param name="name">The name of the field (case sensitive)</param>
             <returns>A FieldInfo or null when type/name is null or when the field cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.DeclaredField(System.Type,System.Int32)">
             Gets the reflection information for a field
             <param name="type">The class where the field is declared</param>
             <param name="idx">The zero-based index of the field inside the class definition</param>
             <returns>A FieldInfo or null when type is null or when the field cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.DeclaredProperty(System.Type,System.String)">
             Gets the reflection information for a directly declared property
             <param name="type">The class where the property is declared</param>
             <param name="name">The name of the property (case sensitive)</param>
             <returns>A PropertyInfo or null when type/name is null or when the property cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.Property(System.Type,System.String)">
             Gets the reflection information for a property by searching the type and all its super types
             <param name="type">The type</param>
             <param name="name">The name</param>
             <returns>A PropertyInfo or null when type/name is null or when the property cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.DeclaredMethod(System.Type,System.String,System.Type[],System.Type[])">
             Gets the reflection information for a directly declared method
             <param name="type">The class where the method is declared</param>
             <param name="name">The name of the method (case sensitive)</param>
             <param name="parameters">Optional parameters to target a specific overload of the method</param>
             <param name="generics">Optional list of types that define the generic version of the method</param>
             <returns>A MethodInfo or null when type/name is null or when the method cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.Method(System.Type,System.String,System.Type[],System.Type[])">
             Gets the reflection information for a method by searching the type and all its super types
             <param name="type">The class where the method is declared</param>
             <param name="name">The name of the method (case sensitive)</param>
             <param name="parameters">Optional parameters to target a specific overload of the method</param>
             <param name="generics">Optional list of types that define the generic version of the method</param>
             <returns>A MethodInfo or null when type/name is null or when the method cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.Method(System.String,System.Type[],System.Type[])">
             Gets the reflection information for a method by searching the type and all its super types
             <param name="typeColonMethodname">The full name (Namespace.Type1.Type2:MethodName) of the type where the method is declared</param>
             <param name="parameters">Optional parameters to target a specific overload of the method</param>
             <param name="generics">Optional list of types that define the generic version of the method</param>
             <returns>A MethodInfo or null when type/name is null or when the method cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetMethodNames(System.Type)">
             Gets the names of all method that are declared in a type
             <param name="type">The declaring type</param>
             <returns>A list of method names</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetMethodNames(System.Object)">
             Gets the names of all method that are declared in the type of the instance
             <param name="instance">An instance of the type to search in</param>
             <returns>A list of method names</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetFieldNames(System.Type)">
             Gets the names of all fields that are declared in a type
             <param name="type">The declaring type</param>
             <returns>A list of field names</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetFieldNames(System.Object)">
             Gets the names of all fields that are declared in the type of the instance
             <param name="instance">An instance of the type to search in</param>
             <returns>A list of field names</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetPropertyNames(System.Type)">
             Gets the names of all properties that are declared in a type
             <param name="type">The declaring type</param>
             <returns>A list of property names</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetPropertyNames(System.Object)">
             Gets the names of all properties that are declared in the type of the instance
             <param name="instance">An instance of the type to search in</param>
             <returns>A list of property names</returns>

        </member>
        <member name="M:Harmony.AccessTools.DeclaredConstructor(System.Type,System.Type[])">
             Gets the reflection information for a directly declared constructor
             <param name="type">The class where the constructor is declared</param>
             <param name="parameters">Optional parameters to target a specific overload of the constructor</param>
             <returns>A ConstructorInfo or null when type is null or when the constructor cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.Constructor(System.Type,System.Type[])">
             Gets the reflection information for a constructor by searching the type and all its super types
             <param name="type">The class where the constructor is declared</param>
             <param name="parameters">Optional parameters to target a specific overload of the method</param>
             <returns>A ConstructorInfo or null when type is null or when the method cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetDeclaredConstructors(System.Type)">
             Gets reflection information for all declared constructors
             <param name="type">The class where the constructors are declared</param>
             <returns>A list of ConstructorInfo</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetDeclaredMethods(System.Type)">
             Gets reflection information for all declared methods
             <param name="type">The class where the methods are declared</param>
             <returns>A list of MethodInfo</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetDeclaredProperties(System.Type)">
             Gets reflection information for all declared properties
             <param name="type">The class where the properties are declared</param>
             <returns>A list of PropertyInfo</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetDeclaredFields(System.Type)">
             Gets reflection information for all declared fields
             <param name="type">The class where the fields are declared</param>
             <returns>A list of FieldInfo</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetReturnedType(System.Reflection.MethodBase)">
             Gets the return type of a method or constructor
             <param name="methodOrConstructor">The method or constructor</param>
             <returns>The return type of the method</returns>

        </member>
        <member name="M:Harmony.AccessTools.Inner(System.Type,System.String)">
             Given a type, returns the first inner type matching a recursive search by name
             <param name="type">The type to start searching at</param>
             <param name="name">The name of the inner type (case sensitive)</param>
             <returns>The inner type or null if type/name is null or if a type with that name cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.FirstInner(System.Type,System.Func{System.Type,System.Boolean})">
             Given a type, returns the first inner type matching a recursive search with a predicate
             <param name="type">The type to start searching at</param>
             <param name="predicate">The predicate to search with</param>
             <returns>The inner type or null if type/predicate is null or if a type with that name cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.FirstMethod(System.Type,System.Func{System.Reflection.MethodInfo,System.Boolean})">
             Given a type, returns the first method matching a predicate
             <param name="type">The type to start searching at</param>
             <param name="predicate">The predicate to search with</param>
             <returns>The MethodInfo or null if type/predicate is null or if a type with that name cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.FirstConstructor(System.Type,System.Func{System.Reflection.ConstructorInfo,System.Boolean})">
             Given a type, returns the first constructor matching a predicate
             <param name="type">The type to start searching at</param>
             <param name="predicate">The predicate to search with</param>
             <returns>The ConstructorInfo or null if type/predicate is null or if a type with that name cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.FirstProperty(System.Type,System.Func{System.Reflection.PropertyInfo,System.Boolean})">
             Given a type, returns the first property matching a predicate
             <param name="type">The type to start searching at</param>
             <param name="predicate">The predicate to search with</param>
             <returns>The PropertyInfo or null if type/predicate is null or if a type with that name cannot be found</returns>

        </member>
        <member name="M:Harmony.AccessTools.GetTypes(System.Object[])">
             Returns an array containing the type of each object in the given array
             <param name="parameters">An array of objects</param>
             <returns>An array of types or an empty array if parameters is null (if an object is null, the type for it will be object)</returns>

        </member>
        <member name="T:Harmony.AccessTools.FieldRef`2">
             A read/writable reference to a field
             <typeparam name="T">The class the field is defined in</typeparam>
             <typeparam name="U">The type of the field</typeparam>
             <param name="obj">The runtime instance to access the field</param>
             <returns>The value of the field (or an assignable object)</returns>

        </member>
        <member name="M:Harmony.AccessTools.FieldRefAccess``2(System.String)">
             Creates a field reference
             <typeparam name="T">The class the field is defined in</typeparam>
             <typeparam name="U">The type of the field</typeparam>
             <param name="fieldName">The name of the field</param>
             <returns>A read and writable field reference</returns>

        </member>
        <member name="M:Harmony.AccessTools.FieldRefAccess``2(``0,System.String)">
             Creates a field reference for a specific instance
             <typeparam name="T">The class the field is defined in</typeparam>
             <typeparam name="U">The type of the field</typeparam>
             <param name="instance">The instance</param>
             <param name="fieldName">The name of the field</param>
             <returns>A read and writable field reference</returns>

        </member>
        <member name="M:Harmony.AccessTools.ThrowMissingMemberException(System.Type,System.String[])">
             Throws a missing member runtime exception
             <param name="type">The class that is involved</param>
             <param name="names">A list of names</param>

        </member>
        <member name="M:Harmony.AccessTools.GetDefaultValue(System.Type)">
             Gets default value for a specific type
             <param name="type">The type</param>
             <returns>The default value</returns>

        </member>
        <member name="M:Harmony.AccessTools.CreateInstance(System.Type)">
             Creates an (possibly uninitialized) instance of a given type
             <param name="type">The type</param>
             <returns>The new instance</returns>

        </member>
        <member name="M:Harmony.AccessTools.MakeDeepCopy``1(System.Object)">
             Makes a deep copy of any object
             <typeparam name="T">The type of the instance that should be created</typeparam>
             <param name="source">The original object</param>
             <returns>A copy of the original object but of type T</returns>

        </member>
        <member name="M:Harmony.AccessTools.MakeDeepCopy``1(System.Object,``0@,System.Func{System.String,Harmony.Traverse,Harmony.Traverse,System.Object},System.String)">
             Makes a deep copy of any object
             <typeparam name="T">The type of the instance that should be created</typeparam>
             <param name="source">The original object</param>
             <param name="result">[out] The copy of the original object</param>
             <param name="processor">Optional value transformation function (taking a field name and src/dst traverse objects)</param>
             <param name="pathRoot">The optional path root to start with</param>

        </member>
        <member name="M:Harmony.AccessTools.MakeDeepCopy(System.Object,System.Type,System.Func{System.String,Harmony.Traverse,Harmony.Traverse,System.Object},System.String)">
             Makes a deep copy of any object
             <param name="source">The original object</param>
             <param name="resultType">The type of the instance that should be created</param>
             <param name="processor">Optional value transformation function (taking a field name and src/dst traverse objects)</param>
             <param name="pathRoot">The optional path root to start with</param>
             <returns>The copy of the original object</returns>

        </member>
        <member name="M:Harmony.AccessTools.IsStruct(System.Type)">
             Tests if a type is a struct
             <param name="type">The type</param>
             <returns>True if the type is a struct</returns>

        </member>
        <member name="M:Harmony.AccessTools.IsClass(System.Type)">
             Tests if a type is a class
             <param name="type">The type</param>
             <returns>True if the type is a class</returns>

        </member>
        <member name="M:Harmony.AccessTools.IsValue(System.Type)">
             Tests if a type is a value type
             <param name="type">The type</param>
             <returns>True if the type is a value type</returns>

        </member>
        <member name="M:Harmony.AccessTools.IsVoid(System.Type)">
             Tests if a type is void
             <param name="type">The type</param>
             <returns>True if the type is void</returns>

        </member>
        <member name="T:Harmony.DynamicTools">
            Creating dynamic methods
        </member>
        <member name="M:Harmony.DynamicTools.CreateDynamicMethod(System.Reflection.MethodBase,System.String)">
             Creates a new dynamic method based on the signature of an existing method
             <param name="original">The original method</param>
             <param name="suffix">A suffix for the new method name</param>
             <returns>The new and so far empty dynamic method, ready to be implemented</returns>

        </member>
        <member name="M:Harmony.DynamicTools.DeclareLocalVariables(System.Reflection.MethodBase,System.Reflection.Emit.ILGenerator,System.Boolean)">
             Creates local variables by copying them from an original method
             <param name="original">The original method</param>
             <param name="generator">A IL generator to generate the variables with</param>
             <param name="logOutput">Set to true to log the actions to the debug log</param>
             <returns>An array of newly defined variables, each represented by a LocalBuilder</returns>

        </member>
        <member name="M:Harmony.DynamicTools.DeclareLocalVariable(System.Reflection.Emit.ILGenerator,System.Type)">
             Creates a local variable
             <param name="generator">A IL generator to generate the variable with</param>
             <param name="type">The variable type</param>
             <returns>A LocalBuilder representing the new variable</returns>

        </member>
        <member name="M:Harmony.DynamicTools.PrepareDynamicMethod(System.Reflection.Emit.DynamicMethod)">
             Prepares a dynamic method so it is jitted
             <param name="method">The dynamic method</param>

        </member>
        <member name="T:Harmony.GeneralExtensions">
            General extensions for common cases
        </member>
        <member name="M:Harmony.GeneralExtensions.Join``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String},System.String)">
             Joins an enumeration with a value converter and a delimiter to a string
             <typeparam name="T">The inner type of the enumeration</typeparam>
             <param name="enumeration">The enumeration</param>
             <param name="converter">An optional value converter (from T to string)</param>
             <param name="delimiter">An optional delimiter</param>
             <returns>The values joined into a string</returns>

        </member>
        <member name="M:Harmony.GeneralExtensions.Description(System.Type[])">
             Converts an array of types (for example methods arguments) into a human readable form
             <param name="parameters">The array of types</param>
             <returns>A human readable description including brackets</returns>

        </member>
        <member name="M:Harmony.GeneralExtensions.FullDescription(System.Reflection.MethodBase)">
             A a full description of a method or a constructor
             <param name="method">The method or constructor</param>
             <returns>A human readable description</returns>

        </member>
        <member name="M:Harmony.GeneralExtensions.Types(System.Reflection.ParameterInfo[])">
             A helper converting parameter infos to types
             <param name="pinfo">The array of ParameterInfo</param>
             <returns>The parameter types</returns>

        </member>
        <member name="M:Harmony.GeneralExtensions.GetValueSafe``2(System.Collections.Generic.Dictionary{``0,``1},``0)">
             A helper to access a value via key from a dictionary
             <typeparam name="S">The key type</typeparam>
             <typeparam name="T">The value type</typeparam>
             <param name="dictionary">The dictionary</param>
             <param name="key">The key</param>
             <returns>The value for the key or the default value (of T) if that key does not exist</returns>

        </member>
        <member name="M:Harmony.GeneralExtensions.GetTypedValue``1(System.Collections.Generic.Dictionary{System.String,System.Object},System.String)">
             A helper to access a value via key from a dictionary with extra casting
             <typeparam name="T">The value type</typeparam>
             <param name="dictionary">The dictionary</param>
             <param name="key">The key</param>
             <returns>The value for the key or the default value (of T) if that key does not exist or cannot be cast to T</returns>

        </member>
        <member name="T:Harmony.CollectionExtensions">
            General extensions for collections
        </member>
        <member name="M:Harmony.CollectionExtensions.Do``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
             A simple way to execute code for every element in a collection
             <typeparam name="T">The inner type of the collection</typeparam>
             <param name="sequence">The collection</param>
             <param name="action">The action to execute</param>

        </member>
        <member name="M:Harmony.CollectionExtensions.DoIf``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Action{``0})">
             A simple way to execute code for elements in a collection matching a condition
             <typeparam name="T">The inner type of the collection</typeparam>
             <param name="sequence">The collection</param>
             <param name="condition">The predicate</param>
             <param name="action">The action to execute</param>

        </member>
        <member name="M:Harmony.CollectionExtensions.Add``1(System.Collections.Generic.IEnumerable{``0},``0)">
             A helper to add an item to a collection
             <typeparam name="T">The inner type of the collection</typeparam>
             <param name="sequence">The collection</param>
             <param name="item">The item to add</param>
             <returns>The collection containing the item</returns>

        </member>
        <member name="M:Harmony.CollectionExtensions.AddToArray``1(``0[],``0)">
             A helper to add an item to an array
             <typeparam name="T">The inner type of the collection</typeparam>
             <param name="sequence">The array</param>
             <param name="item">The item to add</param>
             <returns>The array containing the item</returns>

        </member>
        <member name="M:Harmony.CollectionExtensions.AddRangeToArray``1(``0[],``0[])">
             A helper to add items to an array
             <typeparam name="T">The inner type of the collection</typeparam>
             <param name="sequence">The array</param>
             <param name="items">The items to add</param>
             <returns>The array containing the items</returns>

        </member>
        <member name="T:Harmony.FileLog">
            A file log for debugging
        </member>
        <member name="F:Harmony.FileLog.logPath">
            Full pathname of the log file
        </member>
        <member name="F:Harmony.FileLog.indentChar">
            The indent character
        </member>
        <member name="F:Harmony.FileLog.indentLevel">
            The indent level
        </member>
        <member name="F:Harmony.FileLog.buffer">
            A buffer
        </member>
        <member name="M:Harmony.FileLog.ChangeIndent(System.Int32)">
             Changes indent depth
             <param name="delta">The value to add to the indent level</param>

        </member>
        <member name="M:Harmony.FileLog.LogBuffered(System.String)">
             Log a string in a buffered way. Use this method only if you are sure that FlushBuffer will be called
             or else logging information is incomplete in case of a crash
             <param name="str">The string to log</param>

        </member>
        <member name="M:Harmony.FileLog.FlushBuffer">
            Flushes the log buffer to disk (use in combination with LogBuffered)
        </member>
        <member name="M:Harmony.FileLog.Log(System.String)">
             Log a string directly to disk. Slower method that prevents missing information in case of a crash
             <param name="str">The string to log.</param>

        </member>
        <member name="M:Harmony.FileLog.Reset">
            Resets and deletes the log
        </member>
        <member name="M:Harmony.FileLog.LogBytes(System.Int64,System.Int32)">
             Logs some bytes as hex values
             <param name="ptr">The pointer to some memory</param>
             <param name="len">The length of bytes to log</param>

        </member>
        <member name="T:Harmony.PatchTools">
            Patch tools
        </member>
        <member name="F:Harmony.PatchTools.objectReferences">
            This holds all the objects we want to keep alive so they don't get garbage-collected
        </member>
        <member name="M:Harmony.PatchTools.RememberObject(System.Object,System.Object)">
             Remember an object so it does not get garbage collected
             <param name="key">A key to pin the value to</param>
             <param name="value">The value</param>

        </member>
        <member name="M:Harmony.PatchTools.GetPatchMethod``1(System.Type,System.String,System.Type[])">
             Helper that returns a specific patch method
             <typeparam name="T">The type (prefix, postfix or transpiler) of the patch</typeparam>
             <param name="patchType">The class where the patch method is declared</param>
             <param name="name">The name of the method</param>
             <param name="parameters">Optional argument types for overloads</param>
             <returns>The patch method</returns>

        </member>
        <member name="M:Harmony.PatchTools.GetPatches(System.Type,System.Reflection.MethodInfo@,System.Reflection.MethodInfo@,System.Reflection.MethodInfo@)">
             Gets all patch methods declared in a patch class
             <param name="patchType">The class that declares the patch methods</param>
             <param name="prefix">[out] The prefix patch</param>
             <param name="postfix">[out] The postfix patch</param>
             <param name="transpiler">[out] The transpiler patch</param>

        </member>
        <member name="T:Harmony.SymbolExtensions">
            A helper class to retrieve reflection info for non-private methods
        </member>
        <member name="M:Harmony.SymbolExtensions.GetMethodInfo(System.Linq.Expressions.Expression{System.Action})">
             Given a lambda expression that calls a method, returns the method info
             <param name="expression">The lambda expression using the method</param>
             <returns>The MethodInfo for the method in the lambda expression</returns>

        </member>
        <member name="M:Harmony.SymbolExtensions.GetMethodInfo``1(System.Linq.Expressions.Expression{System.Action{``0}})">
             Given a lambda expression that calls a method, returns the method info
             <typeparam name="T"></typeparam>
             <param name="expression">The lambda expression using the method</param>
             <returns>The MethodInfo for the method in the lambda expression</returns>

        </member>
        <member name="M:Harmony.SymbolExtensions.GetMethodInfo``2(System.Linq.Expressions.Expression{System.Func{``0,``1}})">
             Given a lambda expression that calls a method, returns the method info
             <typeparam name="T"></typeparam>
             <typeparam name="TResult"></typeparam>
             <param name="expression">The lambda expression using the method</param>
             <returns>The MethodInfo for the method in the lambda expression</returns>

        </member>
        <member name="M:Harmony.SymbolExtensions.GetMethodInfo(System.Linq.Expressions.LambdaExpression)">
             Given a lambda expression that calls a method, returns the method info
             <param name="expression">The lambda expression using the method</param>
             <returns>The MethodInfo for the method in the lambda expression</returns>

        </member>
        <member name="T:Harmony.Traverse`1">
             A reflection helper to read and write private elements
             <typeparam name="T">The result type defined by GetValue()</typeparam>

        </member>
        <member name="M:Harmony.Traverse`1.#ctor(Harmony.Traverse)">
             Creates a traverse instance from an existing instance
             <param name="traverse">The original</param>

        </member>
        <member name="P:Harmony.Traverse`1.Value">
             Gets/Sets the current value
             <value>The value to read or write</value>

        </member>
        <member name="T:Harmony.Traverse">
            A reflection helper to read and write private elements
        </member>
        <member name="M:Harmony.Traverse.Create(System.Type)">
             Creates a new traverse instance from a class
             <param name="type">The class</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Create``1">
             Creates a new traverse instance from a class T
             <typeparam name="T">The class</typeparam>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Create(System.Object)">
             Creates a new traverse instance from an instance
             <param name="root">The object</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.CreateWithType(System.String)">
             Creates a new traverse instance from a named type
             <param name="name">The type name</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.#ctor">
             Creates a new and empty traverse instance
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.#ctor(System.Type)">
             Creates a new traverse instance from a class
             <param name="type">The class</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.#ctor(System.Object)">
             Creates a new traverse instance from an instance
             <param name="root">The object</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.GetValue">
             Gets the current value
             <value>The value</value>

        </member>
        <member name="M:Harmony.Traverse.GetValue``1">
             Gets the current value
             <typeparam name="T">The type of the value</typeparam>
             <value>The value</value>

        </member>
        <member name="M:Harmony.Traverse.GetValue(System.Object[])">
             Invokes the current method with arguments and returns the result
             <param name="arguments">The method arguments</param>
             <value>The value returned by the method</value>

        </member>
        <member name="M:Harmony.Traverse.GetValue``1(System.Object[])">
             Invokes the current method with arguments and returns the result
             <typeparam name="T">The type of the value</typeparam>
             <param name="arguments">The method arguments</param>
             <value>The value returned by the method</value>

        </member>
        <member name="M:Harmony.Traverse.SetValue(System.Object)">
             Sets a value of the current field or property
             <param name="value">The value</param>
             <returns>The same traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.GetValueType">
             Gets the type of the current field or property
             <returns>The type</returns>

        </member>
        <member name="M:Harmony.Traverse.Type(System.String)">
             Moves the current traverse instance to a inner type
             <param name="name">The type name</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Field(System.String)">
             Moves the current traverse instance to a field
             <param name="name">The type name</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Field``1(System.String)">
             Moves the current traverse instance to a field
             <typeparam name="T">The type of the field</typeparam>
             <param name="name">The type name</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Fields">
             Gets all fields of the current type
             <returns>A list of field names</returns>

        </member>
        <member name="M:Harmony.Traverse.Property(System.String,System.Object[])">
             Moves the current traverse instance to a property
             <param name="name">The type name</param>
             <param name="index">Optional property index</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Property``1(System.String,System.Object[])">
             Moves the current traverse instance to a field
             <typeparam name="T">The type of the property</typeparam>
             <param name="name">The type name</param>
             <param name="index">Optional property index</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Properties">
             Gets all properties of the current type
             <returns>A list of property names</returns>

        </member>
        <member name="M:Harmony.Traverse.Method(System.String,System.Object[])">
             Moves the current traverse instance to a method
             <param name="name">The name of the method</param>
             <param name="arguments">The arguments defining the argument types of the method overload</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Method(System.String,System.Type[],System.Object[])">
             Moves the current traverse instance to a method
             <param name="name">The name of the method</param>
             <param name="paramTypes">The argument types of the method</param>
             <param name="arguments">The arguments for the method</param>
             <returns>A traverse instance</returns>

        </member>
        <member name="M:Harmony.Traverse.Methods">
             Gets all methods of the current type
             <returns>A list of method names</returns>

        </member>
        <member name="M:Harmony.Traverse.FieldExists">
             Checks if the current traverse instance is for a field
             <returns>True if its a field</returns>

        </member>
        <member name="M:Harmony.Traverse.MethodExists">
             Checks if the current traverse instance is for a method
             <returns>True if its a method</returns>

        </member>
        <member name="M:Harmony.Traverse.TypeExists">
             Checks if the current traverse instance is for a type
             <returns>True if its a type</returns>

        </member>
        <member name="M:Harmony.Traverse.IterateFields(System.Object,System.Action{Harmony.Traverse})">
             Iterates over all fields of the current type and executes a traverse action
             <param name="source">Original object</param>
             <param name="action">The action receiving a traverse for each field</param>

        </member>
        <member name="M:Harmony.Traverse.IterateFields(System.Object,System.Object,System.Action{Harmony.Traverse,Harmony.Traverse})">
             Iterates over all fields of the current type and executes a traverse action
             <param name="source">Original object</param>
             <param name="target">Target object</param>
             <param name="action">The action receiving a traverse for each field traverse pair</param>

        </member>
        <member name="M:Harmony.Traverse.IterateFields(System.Object,System.Object,System.Action{System.String,Harmony.Traverse,Harmony.Traverse})">
             Iterates over all fields of the current type and executes a traverse action
             <param name="source">Original object</param>
             <param name="target">Target object</param>
             <param name="action">The action receiving a field dot path and a field pair</param>

        </member>
        <member name="M:Harmony.Traverse.IterateProperties(System.Object,System.Action{Harmony.Traverse})">
             Iterates over all properties of the current type and executes a traverse action
             <param name="source">Original object</param>
             <param name="action">The action receiving a traverse for each property</param>

        </member>
        <member name="M:Harmony.Traverse.IterateProperties(System.Object,System.Object,System.Action{Harmony.Traverse,Harmony.Traverse})">
             Iterates over all properties of the current type and executes a traverse action
             <param name="source">Original object</param>
             <param name="target">Target object</param>
             <param name="action">The action receiving a traverse for each property traverse pair</param>

        </member>
        <member name="M:Harmony.Traverse.IterateProperties(System.Object,System.Object,System.Action{System.String,Harmony.Traverse,Harmony.Traverse})">
             Iterates over all properties of the current type and executes a traverse action
             <param name="source">Original object</param>
             <param name="target">Target object</param>
             <param name="action">The action receiving a property dot path and a property pair</param>

        </member>
        <member name="F:Harmony.Traverse.CopyFields">
            A default field action that copies fields to fields
        </member>
        <member name="M:Harmony.Traverse.ToString">
             Returns a string that represents the current traverse
             <returns>A string representation</returns>

        </member>
        <member name="T:Harmony.Transpilers">
            A collection of commonly used transpilers
        </member>
        <member name="M:Harmony.Transpilers.MethodReplacer(System.Collections.Generic.IEnumerable{Harmony.CodeInstruction},System.Reflection.MethodBase,System.Reflection.MethodBase)">
             A transpiler that replaces all occurrences of a given method with another one
             <param name="instructions">The instructions to act on</param>
             <param name="from">Method or constructor to search for</param>
             <param name="to">Method or constructor to replace with</param>
             <returns>Modified instructions</returns>

        </member>
        <member name="M:Harmony.Transpilers.DebugLogger(System.Collections.Generic.IEnumerable{Harmony.CodeInstruction},System.String)">
             A transpiler that logs a text at the beginning of the method
             <param name="instructions">The instructions to act on</param>
             <param name="text">The log text</param>
             <returns>Modified instructions</returns>

        </member>
    </members>
</doc>