multi-demangle

Demangling support for various languages and compilers, usable as a Rust crate or a Python extension module. Fork of symbolic-demangle.

Currently supported languages are:

Language	Mangling schemes / notes	Cargo feature
C++	Itanium ABI (GCC, Clang), GNU v2, CodeWarrior, and MSVC	`cpp`, `gnuv2`, `codewarrior`, `msvc`
Rust	Both `legacy` and `v0` schemes	`rust`
Scala Native	Via the unknown-language fallback (symbols prefixed `_SM`)	`scala-native`
Swift	Up to Swift 6.3.3, using a vendored Swift demangler	`swift`
D	D ABI mangling (`_D…`), incl. function types and templates	`dlang`
Fortran	gfortran `mod_MOD_proc`, Intel `mod_mp_proc_`, and the plain g77 `name_` form — explicit request only (see below)	`fortran`
Kotlin/Native	`_kfun:` symbols with parameter types	`kotlin-native`
Ada (GNAT)	`pkg__sub` encoding with escapes, operators, and markers — explicit request only (see below)	`ada`
ObjC	Selectors plus runtime metadata symbols (`_OBJC_CLASS_$_…`, `_OBJC_IVAR_$_…`, selector references)	always on

All of the above features are enabled by default. Disabling them trims the corresponding demangler (and, for swift, the vendored C++ sources) from the build.

As the demangling schemes for the languages are different, the supported demangling features are inconsistent. For example, argument types were not encoded in legacy Rust mangling and thus not available in demangled names.

Rust usage

The crate exposes a Demangle trait on symbolic_common::Name, along with DemangleOptions to control how verbose the output is:

use symbolic_common::{Language, Name};
use multi_demangle::{Demangle, DemangleOptions};

let name = Name::from("__ZN3std2io4Read11read_to_end17hb85a0f6802e14499E");

// Detect the language of a mangled symbol.
assert_eq!(name.detect_language(), Language::Rust);

// Demangle with a full, verbose signature.
assert_eq!(
    name.try_demangle(DemangleOptions::complete()),
    "std::io::Read::read_to_end"
);

// The shortcut free function demangles with complete options and
// falls back to the input if demangling fails.
assert_eq!(multi_demangle::demangle("_ZN3foo3barEv"), "foo::bar()");

The cli cargo feature (on by default) pulls in the argument parser for the binary. Library-only consumers can drop it by re-enabling the backends explicitly:

multi-demangle = { version = "...", default-features = false, features = [
  "cpp", "gnuv2", "codewarrior", "msvc", "rust", "scala-native", "swift",
] }

Batch demangling

Symbol tables repeat the same symbol many times (dynsym, symtab, version tables, and GOT/PLT maps), so the batch API demangles each distinct symbol at most once and preserves input order:

use multi_demangle::{demangle_iter, DemangleOptions};

let symbols = ["_ZN3foo3barEv", "libc.so.6", "_ZN3foo3barEv"];
let demangled = demangle_iter(symbols, DemangleOptions::complete());
assert_eq!(&demangled[0], "foo::bar()");
assert_eq!(&demangled[1], "libc.so.6");
assert_eq!(&demangled[2], "foo::bar()");

demangle_iter computes the whole batch eagerly and returns a Vec (in input order). demangle_one is the single-symbol pipeline the batch is built on (it is what multi_demangle::demangle delegates to), exposed so consumers can share it with their own batching. Enabling the parallel cargo feature (off by default) demangles the distinct symbols on the rayon thread pool.

multi-demangle = { version = "...", features = ["parallel"] }

Structured demangling

demangle_structured extracts typed fields from the demangled rendering — namespace path, leaf name, entity kind, generics, parameters, return type, and compiler disambiguation hashes — so consumers do not have to re-parse text:

use symbolic_common::Name;
use multi_demangle::{Demangle, DemangleOptions};

let info = Name::from("_ZN3std2io4Read11read_to_end17hb85a0f6802e14499E")
    .demangle_structured(DemangleOptions::complete())
    .unwrap();
assert_eq!(info.namespace, ["std", "io", "Read"]);
assert_eq!(info.name, "read_to_end");
assert_eq!(info.kind, multi_demangle::DemangledKind::Method);
assert_eq!(info.hash.as_deref(), Some("hb85a0f6802e14499"));
assert_eq!(info.parameters, None); // legacy Rust encodes no parameter types

DemangledKind classifies the entity (best-effort, modeled on the primary consumer's tables): Function, Method, Closure, Glue (CRT/linker glue and drop glue), Intrinsic, MethodThunk, VirtualTable, TypeInfo, ObjCMethod { class_method }, StaticVariable, or Other.

<Type as Trait>:: and <impl Trait for Type>:: prefixes are reduced to the implementing type in the namespace, and trailing Rust hashes plus .llvm.N clone counters are captured into hash instead of being silently stripped.

Where a backend exposes its parse tree, the fields come from the AST rather than text: MSVC symbols are walked through msvc_demangler's parse tree (which is how a data symbol like ?value@ns@@3HA is correctly a StaticVariable and ??_7Bar@@6B@ a VirtualTable), Swift symbols through the vendored demangler's node tree (accessors, initializers, and closures keep their kinds; accessor names resolve to the wrapped property), and Itanium kinds come from the mangling grammar's own prefixes (_ZGV guard variables, _ZTV/_ZTC vtables, _ZTh/_ZTv thunks). Text-derived extraction remains the fallback for every language.

One stated Itanium limitation: thunk symbols (_ZTh/_ZTv) classify with the right kind, but their target identity is not extracted — the leaf name stays the full brace rendering ({virtual override thunk(...)}) since the demangled form is descriptive and no Itanium AST is available to walk.

New-language backends (D, Fortran, Kotlin/Native, Ada)

The D backend is a port of LLVM's D demangler extended with the full type grammar from the D ABI specification — function types, member functions, compound types, type modifiers, template instances, and back references. It is the only D demangler implemented in Rust. Function symbols render as module.func(params) without the return type (matching the reference demanglers), variables as type module.var, and template instances as name!(args):

use symbolic_common::{Language, Name};
use multi_demangle::{Demangle, DemangleOptions};

assert_eq!(Name::from("_Dmain").detect_language(), Language::D);
assert_eq!(
    Name::from("_D6module4funcFZv").try_demangle(DemangleOptions::complete()),
    "module.func()"
);
assert_eq!(
    Name::from("_D6module4Test6methodMFiZi").try_demangle(DemangleOptions::complete()),
    "module.Test.method(int)"
);

Fortran module symbols demangle to module::proc for both gfortran (__mod_MOD_proc, with or without platform underscores) and Intel (mod_mp_proc_) conventions, and the plain g77 form (init_, my_sub__) renders as the bare subprogram name.

Fortran is explicit-request-only — see Ada and Fortran are opt-in below.

use multi_demangle::{demangle_as, DemangleOptions};

// Auto-detection leaves Fortran symbols alone...
assert_eq!(multi_demangle::demangle("__my_module_MOD_my_proc"), "__my_module_MOD_my_proc");
// ...naming the language is what demangles them.
assert_eq!(
    demangle_as("fortran", "__my_module_MOD_my_proc", DemangleOptions::complete()),
    Some("my_module::my_proc".to_string())
);
assert_eq!(
    demangle_as("fortran", "init_", DemangleOptions::complete()),
    Some("init".to_string())
);

Kotlin/Native symbols still carry the readable kfun: prefix (verified against the 2.0.20x compilers; see contrib/fixtures/kotlin/), in the modern spelling kfun:<pkg>#<member>(<params>){<bounds>}<ret>. They render with their parameter and return types and kotlin. prefix elision: kfun:com.example.Counter#increment(kotlin.Int){}kotlin.Int becomes com.example.Counter.increment(Int): Int. Compiler markers (#static, #internal) render as trailing name segments, and -trampoline thunks keep a [trampoline] marker so they do not alias the function they dispatch to.

Ada (GNAT) symbols decode the pkg__sub encoding — _ada_ prefixes, __N body suffixes, elaboration procedures (corpus___elabb → corpus'Elab_Body), compiler-generated task companions (TB task body, IP initialization procedure, E/Z variables), U/W character escapes, anonymous blocks, and operator names (module__Oadd → module."+").

Ada is explicit-request-only — see the next section.

use multi_demangle::{demangle_as, DemangleOptions};

assert_eq!(
    demangle_as("ada", "ada__exceptions__last_chance_handlerXn", DemangleOptions::complete()),
    Some("ada.exceptions.last_chance_handler".to_string())
);

Ada and Fortran are opt-in

Every other supported scheme has a reserved prefix — _Z, _R, $s, _D, kfun:, ? — that no ordinary C symbol produces, so detecting them by shape is safe. Ada and Fortran have none. GNAT emits pkg__sub and Intel emits mod_mp_proc: flat identifiers with a separator, which is also how a great many C projects spell an internal function.

The collisions are not hypothetical. In a survey of ~443,000 symbols from 133 real binaries, shape-based detection claimed 680 C symbols and zero Ada ones:

C symbol	Origin	Was demangled to
`_uv__io_close`	libuv	`_uv.io_close`
`llhttp__debug`	llhttp (Node.js)	`llhttp.debug`
`_thread_db___pthread_keys`	glibc nptl	`_thread_db._pthread_keys`
`_ada_copy`	ada-url (C, in Node)	`copy`
`ossl_rsa_mp_coeff_names`	OpenSSL multi-prime	`ossl_rsa::coeff_names`

Mach-O makes the Ada case worse: every symbol there picks up a leading underscore, so the C function ada_copy is spelled exactly like GNAT's library-level subprogram Copy. Since C symbols outnumber Ada and Fortran ones by orders of magnitude in any real symbol table, guessing by shape rewrites far more correct names than it fixes — and it fails destructively, turning a correct name into a plausible-looking wrong one rather than leaving it alone.

So both are reached only by naming the language:

use multi_demangle::{demangle_as, DemangleOptions};

// Detection never claims them.
assert_eq!(multi_demangle::detect_language("ada__exceptions__raiseXn"), None);
assert!(!multi_demangle::looks_mangled("__my_module_MOD_my_proc"));

// Naming the language is the way in.
assert_eq!(
    demangle_as("ada", "_ada_main", DemangleOptions::complete()),
    Some("main".to_string())
);

From Python, pass language=:

import multi_demangle

multi_demangle.demangle_symbol("ada__exceptions__raiseXn")                    # unchanged
multi_demangle.demangle_symbol("ada__exceptions__raiseXn", language="ada")    # "ada.exceptions.raise"
multi_demangle.demangle_symbols(symbols, language="fortran")                  # whole batch

From the CLI, pass --language:

$ multi-demangle --language ada ada__exceptions__last_chance_handlerXn
ada.exceptions.last_chance_handler

Use it when you already know the binary's source language; a symbol the named language rejects is returned unchanged. demangle_symbol_structured has no language parameter and so has no Ada or Fortran view — those manglings carry nothing but a scope and a name, which demangle_as already returns in full.

ObjC support now also recognizes runtime metadata symbols — _OBJC_CLASS_$_Foo, _OBJC_METACLASS_$_Foo, _OBJC_IVAR_$_Foo.bar, and emitted selector references (l_OBJC_SELECTOR_REFERENCES_…) — passing the symbols through unchanged but classifying them with typed kinds (objc_class, objc_metaclass, objc_ivar, glue) in the structured API. These dominate non-Swift Mach-O symbol tables.

Symbol hygiene

On top of demangling, the crate provides cheap, prefix-based helpers for the questions consumers face around demangling: is this symbol mangled, in which language, and which linker decorations wrap it?

use multi_demangle::{
    classify_symbol, detect_language, looks_mangled, normalize_symbol, Decoration,
    SymbolStatus,
};

// Cheap mangling check; never attempts a demangling pass.
assert!(looks_mangled("_$s8mangling12GenericUnionO3FooyACyxGSicAEmlF"));
assert!(!looks_mangled("libc.so.6"));

// Language detection (includes Scala Native, which has no Language variant).
assert_eq!(detect_language("_ZN3foo3barEv"), Some("cpp"));
assert_eq!(detect_language("libc.so.6"), None);

// Classification without demangling.
let status = classify_symbol("__imp_?foo@bar@@YAXXZ");
assert_eq!(
    status,
    SymbolStatus::Decorated {
        decoration: Decoration::ImportPointer,
        inner: Box::new(SymbolStatus::Mangled(symbolic_common::Language::Cpp)),
    }
);

// Display-oriented normalization: legacy Rust `$`-escapes, Rust hash
// suffixes, import pointer rewriting, and pseudo-symbol mapping.
assert_eq!(
    normalize_symbol("std::io::Read::read_to_end::hb85a0f6802e14499"),
    "std::io::Read::read_to_end"
);
assert_eq!(
    normalize_symbol("__imp__Z1fv"),
    "__declspec(dllimport) _Z1fv"
);

Two Normalizer pass sets are available: Normalizer::display() (the default of normalize_symbol) cleans names for humans, while Normalizer::matching() additionally strips .llvm. clone suffixes, PLT/GOT call stubs, and ELF version suffixes — and strips import pointers instead of rewriting them — so results match the other binary's export table:

use multi_demangle::Normalizer;

assert_eq!(
    Normalizer::matching().normalize("memcpy@plt"),
    "memcpy"
);
assert_eq!(
    Normalizer::matching().normalize("__imp_CreateFileW"),
    "CreateFileW"
);

Demangle::try_demangle_normalized combines demangling with a normalizer fallback: a symbol that cannot be demangled goes through the given passes instead of being returned unchanged (successful demangled output is never normalized).

use symbolic_common::Name;
use multi_demangle::{Demangle, DemangleOptions, Normalizer};

assert_eq!(
    Name::from("__imp__ZN3foo3barEv")
        .try_demangle_normalized(DemangleOptions::complete(), &Normalizer::display()),
    "__declspec(dllimport) _ZN3foo3barEv"
);

Python usage

Install the pypi package multi-demangle:

pip install multi-demangle

The module exposes demangle_symbol together with a DemangleOptions class:

>>> import multi_demangle
>>> print(multi_demangle.demangle_symbol("_ZN3foo3barEv"))
foo::bar()

>>> # name-only output, without parameters or return types
>>> opts = multi_demangle.DemangleOptions.name_only()
>>> print(multi_demangle.demangle_symbol("_ZN3foo3barEv", options=opts))
foo::bar

>>> # pick individual options via keyword arguments
>>> opts = multi_demangle.DemangleOptions(return_type=False, parameters=True)
>>> print(multi_demangle.demangle_symbol("__pl__FRC9CRelAngleRC9CRelAngle", options=opts))
operator+(CRelAngle const &, CRelAngle const &)

demangle_symbol returns the original string unchanged when the language cannot be detected or demangling fails.

Batch demangling

demangle_symbols demangles a whole batch in one call, releasing the GIL for the duration. It accepts any iterable of strings — lists, tuples, generators, map objects — so hot loops can feed it without materializing first. Duplicate symbols are demangled once by default and share a single string object across their occurrences; results keep the input order and unmangled symbols pass through unchanged:

>>> multi_demangle.demangle_symbols(["_ZN3foo3barEv", "libc.so.6", "_ZN3foo3barEv"])
['foo::bar()', 'libc.so.6', 'foo::bar()']

>>> # pass unique=False to demangle every position independently
>>> multi_demangle.demangle_symbols(["_Z1hic", "libc.so.6"], unique=False)
['h(int, char)', 'libc.so.6']

>>> # options behave like demangle_symbol
>>> multi_demangle.demangle_symbols(["_ZN3foo3barEv"], options=multi_demangle.DemangleOptions.name_only())
['foo::bar']

This replaces the per-symbol calls in hot loops (full symbol tables, PE import tables, Mach-O binding/stub maps) with a handful of batch calls. Type stubs ship with the wheel (multi_demangle.pyi), so type checkers see the full API including the keyword-only unique parameter.

Language detection and symbol hygiene

>>> multi_demangle.detect_language("_ZN3foo3barEv")
'cpp'
>>> multi_demangle.detect_language("libc.so.6") is None
True

>>> # cheap prefix-based check; never attempts a demangling pass
>>> multi_demangle.looks_mangled("_$s8mangling12GenericUnionO3FooyACyxGSicAEmlF")
True

>>> multi_demangle.normalize_symbol("std::io::Read::read_to_end::hb85a0f6802e14499")
'std::io::Read::read_to_end'

>>> multi_demangle.classify_symbol("_Z1hic@GLIBC_2.2.5")
{'status': 'mangled', 'language': 'cpp', 'decorations': [{'kind': 'version', 'value': 'GLIBC_2.2.5'}]}

>>> info = multi_demangle.demangle_symbol_ex("__imp_?h@@YAXH@Z")
>>> info["status"], info["language"], info["decorations"]
('mangled', 'cpp', [{'kind': 'import-pointer'}])

demangle_symbol_ex returns a dict with mangled, demangled, status ("mangled", "unmangled", or "unsupported"), language, and an outermost-first decorations list; classify_symbol returns the same classification without demangling. Passing multi_demangle.DemangleOptions(normalize=True) applies the display hygiene passes to the fallback when demangling does not succeed, and Normalizer.matching() provides the pass set for cross-symbol matching (memcpy@plt → memcpy, __imp_CreateFileW → CreateFileW).

Structured demangling

>>> info = multi_demangle.demangle_symbol_structured("_ZN3std2io4Read11read_to_end17hb85a0f6802e14499E")
>>> info.language
'rust'
>>> info.name
'read_to_end'
>>> info.namespace
['std', 'io', 'Read']
>>> info.kind
'method'
>>> info.hash
'hb85a0f6802e14499'
>>> info.parameters is None  # legacy Rust encodes no parameter types
True

demangle_symbol_structured returns a DemangledInfo with read-only getters (display, simple, namespace, name, kind, parameters, return_type, hash, template_args, is_generic, mangled, and class_method for ObjC) plus to_dict() for JSON serialization. It returns None for symbols that are not mangled in any known scheme.

CLI

A c++filt-style command line tool ships with the crate. Install it with a Rust toolchain (or use cargo run -- from a checkout):

cargo install multi-demangle

With arguments, each argument is demangled to one output line. Without arguments, the tool runs in filter mode: lines are read from stdin, every whitespace-separated token that looks mangled is demangled, and everything else passes through unchanged — so it composes with nm / objdump pipelines:

$ multi-demangle _ZN3foo3barEv
foo::bar()

$ nm libfoo.so | multi-demangle
$ nm libfoo.so | sort | uniq -c | multi-demangle -n --normalize

Hyphen-prefixed symbols such as ObjC selectors are accepted as values, so the obvious invocation just works (and -- works too):

$ multi-demangle '-[Foo bar:blub:]'
-[Foo bar:blub:]

Options:

Flag	Effect
`-n, --name-only`	names only, no parameters or return types
`--no-parameters` / `--no-return-type`	individual output toggles
`-l, --language <LANG>`	force a backend instead of auto-detecting (`cpp`, `rust`, `swift`, `objc`, `objcpp`, `d`, `fortran`, `kotlin-native`, `ada`, `scala-native`); required for `ada` and `fortran`, which are never auto-detected
`--normalize`	apply the symbol hygiene passes (`__imp_`, `@plt`, ELF versions, Rust hash suffixes and `$`-escapes, `.llvm.` clone suffixes, pseudo-symbols) to symbols that cannot be demangled, then demangle the cleaned symbol when it succeeds
`-s, --structured`	print one JSON record per symbol with its status, language, linker decorations, and the structured fields (name, namespace, kind, parameters, return type, generics, hash)
`--list-languages`	print the supported languages and the backends enabled in this build
`--color=auto/always/never`	colorize successfully demangled output (auto is the default)

multi-demangle --version prints the crate version together with the enabled backends. Exit code is 0 on success — including when nothing looked mangled — and 1 on I/O errors.

$ multi-demangle -s "_Z1hic@GLIBC_2.2.5"
{"mangled":"_Z1hic@GLIBC_2.2.5","demangled":"_Z1hic@GLIBC_2.2.5","status":"mangled","language":"cpp","decorations":[{"kind":"version","value":"GLIBC_2.2.5"}]}

In filter mode with --structured, records are emitted only for tokens that look like symbols or that the pipeline changed — under --normalize, a cleaned token such as bar.llvm.12345 is reported — while plain addresses, type letters, and words are skipped.

--normalize never touches directly successful demangled output; the passes run on the symbols the demanglers rejected, and the cleaned symbol is then demangled once more — a version-suffixed _Z1hic@GLIBC_2.2.5 comes out as h(int, char). Because .llvm. clone suffixes and legacy Rust $-escapes appear on names that do not classify as mangled, filter mode processes every token while --normalize is active:

$ multi-demangle --normalize bar.llvm.12345
bar
$ multi-demangle "_Z1hic@GLIBC_2.2.5"
_Z1hic@GLIBC_2.2.5
$ multi-demangle --normalize "_Z1hic@GLIBC_2.2.5"
h(int, char)

Development

Use uv package manager.

uv tool install maturin
maturin develop --all-features

Run the Rust test suite (includes the vendored Swift demangler build):

cargo test --all-features

Run the Python tests against the locally built module:

maturin develop --all-features
pytest python/tests

Run the criterion benchmarks for the batch pipeline (uses the real-symbol dumps in tests/corpus/; regenerate them with scripts/collect-corpus.sh when the producing toolchains change):

cargo bench

The Swift demangler is a minimal subset of the Swift standard library sources vendored under vendor/swift; see vendor/swift/README.md for how it is maintained.

Updating the vendored Swift demangler

A single command syncs vendor/swift from upstream (shallow, blobless, sparse clones), auto-adds headers new to the demangler's dependency graph, records provenance in vendor/swift/SYNC.md, and runs the validation gauntlet (cargo test --all-features, the Python tests, and an ASan/UBSan pass over the real-symbol corpus):

scripts/sync-swift.sh                # newest swift-*-RELEASE tag
scripts/sync-swift.sh swift-6.4.0    # or an explicit tag

A monthly CI workflow (swift-sync-reminder) opens an issue listing upstream commits that touch lib/Demangling or include/swift/Demangling since the last sync, so the vendored subset never rots silently.

The supported-version claim above is backed by per-toolchain corpus snapshots: scripts/collect-swift-corpus.sh compiles a fixture with a concrete Swift toolchain (pass its swiftc to represent another one) into tests/corpus/swift/<version>/, and the swift_corpus test pins the exact rendering. After a sync that changes output, regenerate snapshots deliberately and review the diff — downstream consumers (blint) match on these strings:

MULTI_DEMANGLE_UPDATE_SNAPSHOTS=1 cargo test --all-features --test test_swift_corpus

License

MIT

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

multi_demangle-2.0.1.tar.gz (399.6 kB view details)

Uploaded Aug 30, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

multi_demangle-2.0.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 PyPymusllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 PyPymusllinux: musl 1.2+ i686

multi_demangle-2.0.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 PyPymusllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (949.5 kB view details)

Uploaded Aug 30, 2026 PyPymanylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 PyPymanylinux: glibc 2.17+ i686

multi_demangle-2.0.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (946.0 kB view details)

Uploaded Aug 30, 2026 PyPymanylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (945.9 kB view details)

Uploaded Aug 30, 2026 CPython 3.15tmanylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp315-cp315t-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.15tmanylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (939.2 kB view details)

Uploaded Aug 30, 2026 CPython 3.15tmanylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (947.3 kB view details)

Uploaded Aug 30, 2026 CPython 3.15manylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.15manylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (942.8 kB view details)

Uploaded Aug 30, 2026 CPython 3.15manylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.14tmusllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp314-cp314t-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.14tmusllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.14tmusllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (945.6 kB view details)

Uploaded Aug 30, 2026 CPython 3.14tmanylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.14tmanylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (939.6 kB view details)

Uploaded Aug 30, 2026 CPython 3.14tmanylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp314-cp314-win_amd64.whl (764.2 kB view details)

Uploaded Aug 30, 2026 CPython 3.14Windows x86-64

multi_demangle-2.0.1-cp314-cp314-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.14musllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp314-cp314-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.14musllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp314-cp314-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.14musllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (946.6 kB view details)

Uploaded Aug 30, 2026 CPython 3.14manylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.14manylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (942.9 kB view details)

Uploaded Aug 30, 2026 CPython 3.14manylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp314-cp314-macosx_11_0_arm64.whl (847.3 kB view details)

Uploaded Aug 30, 2026 CPython 3.14macOS 11.0+ ARM64

multi_demangle-2.0.1-cp314-cp314-macosx_10_12_x86_64.whl (867.6 kB view details)

Uploaded Aug 30, 2026 CPython 3.14macOS 10.12+ x86-64

multi_demangle-2.0.1-cp313-cp313-win_amd64.whl (764.2 kB view details)

Uploaded Aug 30, 2026 CPython 3.13Windows x86-64

multi_demangle-2.0.1-cp313-cp313-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.13musllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp313-cp313-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.13musllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp313-cp313-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.13musllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (946.3 kB view details)

Uploaded Aug 30, 2026 CPython 3.13manylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.13manylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (941.8 kB view details)

Uploaded Aug 30, 2026 CPython 3.13manylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp313-cp313-macosx_11_0_arm64.whl (843.7 kB view details)

Uploaded Aug 30, 2026 CPython 3.13macOS 11.0+ ARM64

multi_demangle-2.0.1-cp313-cp313-macosx_10_12_x86_64.whl (868.0 kB view details)

Uploaded Aug 30, 2026 CPython 3.13macOS 10.12+ x86-64

multi_demangle-2.0.1-cp312-cp312-win_amd64.whl (764.7 kB view details)

Uploaded Aug 30, 2026 CPython 3.12Windows x86-64

multi_demangle-2.0.1-cp312-cp312-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.12musllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp312-cp312-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.12musllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp312-cp312-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.12musllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (946.6 kB view details)

Uploaded Aug 30, 2026 CPython 3.12manylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.12manylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (939.4 kB view details)

Uploaded Aug 30, 2026 CPython 3.12manylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp312-cp312-macosx_11_0_arm64.whl (844.2 kB view details)

Uploaded Aug 30, 2026 CPython 3.12macOS 11.0+ ARM64

multi_demangle-2.0.1-cp312-cp312-macosx_10_12_x86_64.whl (866.9 kB view details)

Uploaded Aug 30, 2026 CPython 3.12macOS 10.12+ x86-64

multi_demangle-2.0.1-cp311-cp311-win_amd64.whl (765.5 kB view details)

Uploaded Aug 30, 2026 CPython 3.11Windows x86-64

multi_demangle-2.0.1-cp311-cp311-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.11musllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp311-cp311-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.11musllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp311-cp311-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.11musllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (948.3 kB view details)

Uploaded Aug 30, 2026 CPython 3.11manylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.11manylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (944.7 kB view details)

Uploaded Aug 30, 2026 CPython 3.11manylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp311-cp311-macosx_11_0_arm64.whl (850.1 kB view details)

Uploaded Aug 30, 2026 CPython 3.11macOS 11.0+ ARM64

multi_demangle-2.0.1-cp311-cp311-macosx_10_12_x86_64.whl (869.4 kB view details)

Uploaded Aug 30, 2026 CPython 3.11macOS 10.12+ x86-64

multi_demangle-2.0.1-cp310-cp310-win_amd64.whl (766.1 kB view details)

Uploaded Aug 30, 2026 CPython 3.10Windows x86-64

multi_demangle-2.0.1-cp310-cp310-win32.whl (706.3 kB view details)

Uploaded Aug 30, 2026 CPython 3.10Windows x86

multi_demangle-2.0.1-cp310-cp310-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.10musllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp310-cp310-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.10musllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp310-cp310-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.10musllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (949.5 kB view details)

Uploaded Aug 30, 2026 CPython 3.10manylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.10manylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (943.7 kB view details)

Uploaded Aug 30, 2026 CPython 3.10manylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp310-cp310-macosx_11_0_arm64.whl (850.9 kB view details)

Uploaded Aug 30, 2026 CPython 3.10macOS 11.0+ ARM64

multi_demangle-2.0.1-cp310-cp310-macosx_10_12_x86_64.whl (867.7 kB view details)

Uploaded Aug 30, 2026 CPython 3.10macOS 10.12+ x86-64

multi_demangle-2.0.1-cp39-cp39-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.9musllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp39-cp39-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.9musllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp39-cp39-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.9musllinux: musl 1.2+ ARM64

multi_demangle-2.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (952.4 kB view details)

Uploaded Aug 30, 2026 CPython 3.9manylinux: glibc 2.17+ x86-64

multi_demangle-2.0.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl (1.0 MB view details)

Uploaded Aug 30, 2026 CPython 3.9manylinux: glibc 2.17+ i686

multi_demangle-2.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (946.9 kB view details)

Uploaded Aug 30, 2026 CPython 3.9manylinux: glibc 2.17+ ARM64

multi_demangle-2.0.1-cp38-cp38-musllinux_1_2_x86_64.whl (7.6 MB view details)

Uploaded Aug 30, 2026 CPython 3.8musllinux: musl 1.2+ x86-64

multi_demangle-2.0.1-cp38-cp38-musllinux_1_2_i686.whl (7.5 MB view details)

Uploaded Aug 30, 2026 CPython 3.8musllinux: musl 1.2+ i686

multi_demangle-2.0.1-cp38-cp38-musllinux_1_2_aarch64.whl (7.4 MB view details)

Uploaded Aug 30, 2026 CPython 3.8musllinux: musl 1.2+ ARM64

File details

Details for the file multi_demangle-2.0.1.tar.gz.

File metadata

Download URL: multi_demangle-2.0.1.tar.gz
Upload date: Aug 30, 2026
Size: 399.6 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for multi_demangle-2.0.1.tar.gz
Algorithm	Hash digest
SHA256	`a77e2360543f83fd4b6869b20685bca367eb5063bb1a53e6f3bfa9d9515ce312`
MD5	`6ce114149ac8c936cb6ff60b1faf93ee`
BLAKE2b-256	`a96f9b13b701c0832cf82fe21071aac626f999bdb1a2a4c28414108c47df64a4`

Algorithm	Hash digest
SHA256	`847c985d46aa597017a485b6b9e56030f38b7683a5e27b5763da6f0118a6ebf2`
MD5	`c840ea184149a629fcf3ac27ff1b9d20`
BLAKE2b-256	`14d40502e843424244029f3cea11173547eee03d0462ad4404981b7a995ff2e0`

Algorithm	Hash digest
SHA256	`dc6fd2e5ce617dd9608cb15179302e8776ad87ba13665f85c848a311856debd2`
MD5	`531ca4b17d98b5436ee4b893c0212d1e`
BLAKE2b-256	`0eb8e3b43a57b1863ea4b945c90dc8d78d6893d9072d8998b57feaa7a15e51b1`

Algorithm	Hash digest
SHA256	`be7766666b300ca7d8b993915bcd172ebf9d60ef47a3acb374a77fe09452cd6a`
MD5	`c5d4975e7ea92b82e0864fd3407973a2`
BLAKE2b-256	`3cb2bee64c4551542cabd4c128cf3d28895351deddf6b2f152eae0822571092c`

Algorithm	Hash digest
SHA256	`55ef86d4fb0678451b98080a9fa64eb197ac5685e9fc7333e1ff30550860ddd9`
MD5	`9ea030829c736003a20817b23942bea5`
BLAKE2b-256	`753ca5d34e0abceb251e5bd430f3e79bc41080665130c5ec361ee39ddac32a6e`

Algorithm	Hash digest
SHA256	`a838da6f74809537a95a950e989877d599ed3c601529ba333095a4bea6672775`
MD5	`97e8a6ed71d76d8868aacc05ca74c147`
BLAKE2b-256	`cdc2ca750cfdf7784cf96ab10ed857b93e157c5c6d8cd4550ca4c265b1c9ea20`

Algorithm	Hash digest
SHA256	`76d7fa48628b606ccf5016860036d666704dad9d51c0d8671209cf2a7ed510b7`
MD5	`4081cf9538f85fdc25a3bdcc1cf94602`
BLAKE2b-256	`dcbab9c4a7752c5bd52a2204b12e908516b0dcec4590cd1d1cf84bf1b375ffdf`

Algorithm	Hash digest
SHA256	`c7773f46e57e6334e117af0e170e118b25b7c0d61a44bbd84d279f1df8ca1ce9`
MD5	`73a36186d2c2abacc3facae1860003ec`
BLAKE2b-256	`9a3e0ff71ffef767a0452dca055db6a8c9af64b6a20ed8ea0ef2f219dca04dd1`

Algorithm	Hash digest
SHA256	`c249f8af6a661dcd08ab7fe06eaab497f1cb6dcb60143bf7f0f8e0eb6d229937`
MD5	`b29836e11916fe99bbe01e499139bd48`
BLAKE2b-256	`a185b759790df9785811283b4a99020428162a8f938cc03d2685f1ba195e3ef6`

Algorithm	Hash digest
SHA256	`f282a707658a0ba59b57ca865095c018b56fc831313cac4bc2f1e3c61974ea4e`
MD5	`bf3971822100d611b774e2fd0503f5c4`
BLAKE2b-256	`4dd02095bcc8d383bb140135822d8cf46a0200623e49733afa60e93cea808a3f`

Algorithm	Hash digest
SHA256	`c12c567c0b12d17ba749f11a2b1bd93dbb53fa0a8c36aa9d59d1adb74dfd0f19`
MD5	`8e83ecc3fa2235917168558cf2ddbb7e`
BLAKE2b-256	`7f220be9f2575ef209ad0bb9038f6699194225f8b4cb9303e25debf78aea0db3`

Algorithm	Hash digest
SHA256	`37c7c8f119c89d498a1b858ffcc7f03e694eb15c36c839a769a4919b5bcba1c2`
MD5	`7042879f211073dd88abb9b5c06c6f9c`
BLAKE2b-256	`0da1a0a18466a3f0dcbcf25dfca7b1978380cfd1cc0566ae00a3a4cc52e7eec5`

Algorithm	Hash digest
SHA256	`f6ba3125ca40ff5196dd54f8a6a81299d273e95e161744d90bd7516bfef8249f`
MD5	`6a9db825cc4d1e99e35adb1582065965`
BLAKE2b-256	`d8e137b850dff275c2efec2ae89dfbe4c003f60d3f0f259bf60c2388b7e6b973`

Algorithm	Hash digest
SHA256	`a849a051881a821cb0f79f01994457e836aff004cb5118eb848a4f3ec52ef7c5`
MD5	`c70bffd8047a51e7260e9fe7f2b7b0e5`
BLAKE2b-256	`f76940750c3a8340b3a540329847825f97d2a490cc6ee0e5953a39830373615a`

Algorithm	Hash digest
SHA256	`65a20acef498ed0f57fe6340b5b62d61e064eafb4eca0d96710cf87be846da2f`
MD5	`f0054d1799e6e535441e38a4a4acdb8f`
BLAKE2b-256	`7cb8b54bb05ae65c998405abc2a0fe5f5e43185620facbf8a0af2e28e6d00d00`

Algorithm	Hash digest
SHA256	`bc56f442bbb0382cc41424f13f8365197a8c398ef5eeb675af887b0d08261abb`
MD5	`60e908aad78cabdd4db46a6ef95e7987`
BLAKE2b-256	`be00e61e0b8ad1d76e558b0143219b35d2f92e64bf22fd4fbc5bd9b6a5803c32`

Algorithm	Hash digest
SHA256	`e4f3e4330dbd356ad8491e3c338b4ab5e9c0b34ef0bc868ac0ab37f079a8256d`
MD5	`d3903380af820d859548389de127b09d`
BLAKE2b-256	`791ca11c0fc49ea9ab3a3a42645bb26b16b7d59bee63de0a3f2782f787db68a8`

Algorithm	Hash digest
SHA256	`a8abc5aabe153fded5f0dd94f3f0cdcb7ca003e05af142b42cdb62564e729e4f`
MD5	`373fc058d2040a24768d2faf9f5f4e20`
BLAKE2b-256	`b7a98102d124e32a23433b5ef1e7d084d0e1e880259fa4069acddd87a9c656e0`

Algorithm	Hash digest
SHA256	`12b917aa9d80965141810f63000ddb131fc3065bfbd18b6f7da67ba67cefddf4`
MD5	`a9e00c68bc13b4c2c759e84aea883822`
BLAKE2b-256	`c8c00b46136af57074385ce6f2252383cbfb30335a1f5d2dd201ffc533cac387`

Algorithm	Hash digest
SHA256	`c7d5aa2466ce510e99d07874a4490c9dd6299e2d8d10af47f92ee1cd9abf7b09`
MD5	`a0d99cce98607b259dd501596bc77faf`
BLAKE2b-256	`f8f07b78a090ea94b78494683474db4cb92606d700442b13303a1d426ba01b64`

Algorithm	Hash digest
SHA256	`1cc8ca82c1952a197f17967944a529837a41c21f72e26bf800e09979a078ba15`
MD5	`c80d179d7715001dd5da1cdfafb9f352`
BLAKE2b-256	`05bc6923ac1978af36648e7198505f12639c3a7d87436c555c98801286046e8b`

multi-demangle 2.0.1

multi-demangle

Rust usage

Batch demangling

Structured demangling

New-language backends (D, Fortran, Kotlin/Native, Ada)

Ada and Fortran are opt-in

Symbol hygiene

Python usage

Batch demangling

Language detection and symbol hygiene

Structured demangling

CLI

Development

Updating the vendored Swift demangler

License

Project links

Key dates

Owner

GitHub Statistics

License expression

Tags

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Algorithm	Hash digest
SHA256	`9362707691bc3811e17280eddd2d2c6317326da7e51ea0175d4ad3b8638f3a3f`
MD5	`364f90f6753a1f7ac7f9cea963607eab`
BLAKE2b-256	`f173c3c6e6b80d44c0ebc4683d87f28e0341a00c7ef383ec60024dd433a975ec`

Algorithm	Hash digest
SHA256	`9347dba6036c9df7193f902c0bcfe1236b5424144f1176976c1ffc56d87a330d`
MD5	`47019845d28bfe1ae8499f8857ce02d5`
BLAKE2b-256	`4de3a68abb2ed1eebede1924228a71a8fb4ddb9a3359ee8af3c6baf8efa8996b`

Algorithm	Hash digest
SHA256	`8f744fd7be5431f6a1c62301014be1312c0d81775a5c6babcdcc08c4bfd98e86`
MD5	`9e78bbdeae287c6cfb5aba987dbd1812`
BLAKE2b-256	`f1d2df901ee38b19f8728cf7b151fcf08789dbb139a6b688fc22479669e5fd66`

Algorithm	Hash digest
SHA256	`31e38dee93fb9ccd3b8d9361e14830daf5fba26879c29bae7191ddd3afb506c4`
MD5	`d37263d81715898f2e5eda58c754d4f7`
BLAKE2b-256	`bb6784c5142f88828fd91a02f23d23946da2d6c6f0c05d4e29c14278d841e90d`

Algorithm	Hash digest
SHA256	`08a28e5388b797fd748f6459bf1a7f533e5c5309fcbc5f7e3a5d8e66d8c15c4d`
MD5	`d641cb70b29c39f9a518c618928eb01a`
BLAKE2b-256	`3b896633daa02d51dcf8aab7d2ad78bcf1a15d7ef6c711bea9d67800cde20ede`

Algorithm	Hash digest
SHA256	`4147ee142785ffe9e54a46ff3f4002f459a3d0e548c9585fbeb53d41598e5622`
MD5	`be04c9f08e96eb7daba8ed2095a7ab1f`
BLAKE2b-256	`95e6d371c0437d49e5e1506b2bab4985e8509698196fb3de21737138c4c790e4`

Algorithm	Hash digest
SHA256	`9bf8eba8f9e9b3d42aed1d0f373f48291fabe61e27d1f3a9b3959fcb888cbb51`
MD5	`8c1d6315f80bf05df68b42ff37701795`
BLAKE2b-256	`1e07725da0bae6df797e4b69ef91a05d06d74603d45c8cb50ae0161438e8ecf4`

Algorithm	Hash digest
SHA256	`fd9ce91fdcbd11b24c0a8356edc13a22737d0a7c92056b8df3361de1254031d9`
MD5	`5f8a1870c2380e8f47795da0336af915`
BLAKE2b-256	`bd93ea04dbbf181b6ed898a9aaf45817a2840633998cb37d7d803a3063f9da71`

Algorithm	Hash digest
SHA256	`47a28836387dddb4d39afe6ba956e9f1d8352e8c78d2ff0b821b29f759806a9f`
MD5	`8f9f57bfa8ce244a29049dcd78c239f1`
BLAKE2b-256	`654aecf62c4f75f4596c8bb0039fdf927084ac85a4390c1eab4e978a3d499f9b`

Algorithm	Hash digest
SHA256	`1abe1989dc8fcd00fabcbc8d1974e7cda71017d59a006748558729253bae3dec`
MD5	`86d817cdd452ead4c46a5d0316de99f4`
BLAKE2b-256	`23fae702385e7302d2cdd6181ea99fe2a53b605297a5e8daf5f7b2427fb77ebc`