<?xml version="1.0"?>
<doc>
    <assembly>
        <name>BitMono.IL2CPP</name>
    </assembly>
    <members>
        <member name="T:BitMono.IL2CPP.GlobalMetadataEncryptor">
            <summary>
            Offline half of the #276 metadata-encryption protection: turns a plain <c>global-metadata.dat</c> into an
            encrypted blob that a native decryptor (compiled into <c>GameAssembly.dll</c>) restores in memory at
            startup, so static dumpers can't parse it. The format is a small plaintext front header followed by the
            XXTEA-encrypted metadata. <see cref="M:BitMono.IL2CPP.GlobalMetadataEncryptor.Decrypt(System.Byte[],System.Byte[])"/> is the reference the native decryptor mirrors. The key
            ships in the binary, so this is obfuscation strength, not secrecy.
            </summary>
        </member>
        <member name="T:BitMono.IL2CPP.GlobalMetadataFile">
            <summary>
            Read-only parser for Unity IL2CPP <c>global-metadata.dat</c>. Reads the header magic + version and
            the two string regions Il2CppDumper reconstructs your code from: the identifier names (type/method/
            field names) and the string literals from your code. This header prefix is identical across every
            il2cpp metadata version, so no per-version branching is needed for it. The later per-version tables
            (types, methods, fields, ...) are intentionally not parsed yet.
            </summary>
        </member>
        <member name="F:BitMono.IL2CPP.GlobalMetadataFile.Magic">
            <summary>The "sanity" magic every <c>global-metadata.dat</c> starts with.</summary>
        </member>
        <member name="P:BitMono.IL2CPP.GlobalMetadataFile.Version">
            <summary>The il2cpp metadata version (e.g. 24, 27, 29, 31).</summary>
        </member>
        <member name="P:BitMono.IL2CPP.GlobalMetadataFile.Strings">
            <summary>Identifier names (namespaces, type/method/field names) IL2CPP keeps for reflection etc.</summary>
        </member>
        <member name="P:BitMono.IL2CPP.GlobalMetadataFile.StringLiterals">
            <summary>String literals from your code (the <c>ldstr</c> values) - what string encryption targets.</summary>
        </member>
        <member name="T:BitMono.IL2CPP.GlobalMetadataWriter">
            <summary>
            Writes modified <c>global-metadata.dat</c> bytes. For now it only does same-length, in-place edits of the
            identifier <c>string</c> region - the one rewrite that needs no offset fix-up, since every <c>nameIndex</c>
            keeps pointing at the same place (Tulach's approach). Arbitrary-length renames need a full rebuild that
            re-points every referent, which waits on the per-version table parser.
            </summary>
            <remarks>
            This is only the offline half: a renamed metadata file loads correctly at runtime <i>only</i> if a matching
            forwarder is present in <c>GameAssembly.dll</c> to map name lookups back. That forwarder isn't built (the
            shipped protection encrypts the metadata instead of renaming), so this primitive alone will break a build.
            </remarks>
        </member>
        <member name="M:BitMono.IL2CPP.GlobalMetadataWriter.ReplaceNames(System.Byte[],System.Collections.Generic.IReadOnlyDictionary{System.Int32,System.String})">
            <summary>
            Returns a copy of <paramref name="metadata"/> with identifier names overwritten in place. Keys are
            <c>nameIndex</c> values (byte offsets relative to the start of the string region, as IL2CPP uses them);
            each replacement must encode to exactly the same number of UTF-8 bytes as the name currently at that
            index, so nothing moves and the file stays valid.
            </summary>
        </member>
        <member name="T:BitMono.IL2CPP.Il2CppExportName">
            <summary>
            Deterministic per-build rename of an IL2CPP API export (#276 follow-up: export renaming). The post-build
            renamer rewrites each <c>il2cpp_*</c> export in GameAssembly.dll / libil2cpp.so to <see cref="M:BitMono.IL2CPP.Il2CppExportName.Mangle(System.Byte[],System.String)"/>,
            and the native <c>GetProcAddress</c>/<c>dlsym</c> hook computes the identical value so UnityPlayer still
            resolves the function - while a dumper walking the export table only sees the mangled names.
            FNV-1a over (key ++ name) keeps it keyed to the per-build key, so it differs per game.
            </summary>
        </member>
        <member name="F:BitMono.IL2CPP.Il2CppExportName.Prefix">
            <summary>The IL2CPP API exports all start with this prefix; only these get renamed.</summary>
        </member>
        <member name="T:BitMono.IL2CPP.ReservedNames">
            <summary>
            Names that must never be renamed in <c>global-metadata.dat</c> because IL2CPP/Unity resolves them by
            name at runtime - renaming them breaks the build. This is the part of the rename policy you can decide
            from the string alone. Names that are unsafe for *contextual* reasons - classes referenced by scenes/
            assets, reflection targets, <c>[SerializeField]</c> members - can't be told apart from a bare string and
            are NOT covered here; they need separate analysis.
            </summary>
        </member>
        <member name="M:BitMono.IL2CPP.ReservedNames.IsReserved(System.String)">
            <summary>True when <paramref name="name"/> must be left alone (never renamed).</summary>
        </member>
    </members>
</doc>
