{
    "src" :
    [
        "mars.c", "enum.c", "struct.c", "dsymbol.c", "import.c", "utf.h",
        "utf.c", "identifier.c", "mtype.c", "expression.c", "optimize.c", "template.h",
        "template.c", "lexer.c", "declaration.c", "cast.c", "cond.h", "cond.c", "link.c",
        "aggregate.h", "staticassert.h", "parse.c", "statement.c", "constfold.c", "version.h",
        "version.c", "inifile.c", "staticassert.c", "module.c", "scope.c",
        "init.h", "init.c", "attrib.h", "attrib.c", "opover.c", "class.c",
        "mangle.c", "func.c", "inline.c", "access.c",
        "cppmangle.c", "identifier.h", "parse.h", "scope.h", "enum.h", "import.h",
        "mars.h", "module.h", "mtype.h", "dsymbol.h",
        "declaration.h", "lexer.h", "expression.h", "statement.h", "doc.h", "doc.c", "macro.h",
        "macro.c", "hdrgen.h", "hdrgen.c", "arraytypes.h", "delegatize.c",
        "interpret.c", "ctfeexpr.c", "traits.c", "builtin.c", "clone.c",
        "arrayop.c", "aliasthis.h", "aliasthis.c", "json.h", "json.c",
        "unittests.c", "imphint.c", "argtypes.c", "apply.c", "sapply.c", "sideeffect.c",
        "ctfe.h", "canthrow.c", "target.c", "target.h", "id.c", "id.h",
        "impcnvtab.c", "visitor.h", "lib.h", "nogc.c", "nspace.h", "nspace.c",
        "errors.c", "errors.h",
        "tokens.c", "tokens.h",
        "globals.c", "globals.h",
        "escape.c",
        "root/aav.h", "root/aav.c",
        "root/filename.h", "root/filename.c",
        "root/file.h", "root/file.c",
        "root/speller.h", "root/speller.c",
        "root/outbuffer.h", "root/outbuffer.c",
        "root/stringtable.h", "root/stringtable.c",
        "root/man.c", "root/response.c"
    ],
    "mapping" :
    [
        {
            "module" : "dinterpret",
            "package" : "",
            "imports" :
            [
                "apply",
                "attrib",
                "arraytypes",
                "builtin",
                "constfold",
                "core.stdc.stdio",
                "core.stdc.string",
                "ctfeexpr",
                "dclass",
                "declaration",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "id",
                "identifier",
                "init",
                "tokens",
                "globals",
                "mtype",
                "root.array",
                "root.rootobject",
                "statement",
                "utf",
                "visitor"
            ],
            "extra" :
            [
                "private enum LOG = false;"
            ],
            "members" :
            [
                "variable LOGASSIGN",
                "variable LOGCOMPILE",
                "variable SHOWPERFORMANCE",
                "variable CTFE_RECURSION_LIMIT",
                "struct CtfeStack",
                "struct InterState",
                "variable ctfeStack",
                "function printCtfePerformanceStats",
                "struct CompiledCtfeFunction",
                "struct CtfeCompiler",
                "function ctfeCompile",
                "function ctfeInterpret",
                "function ctfeInterpretForPragmaMsg",
                "function interpretFuncDeclaration*InterState*Expressions*Expression*",
                "struct Interpreter",
                "function interpretExpression*InterState*CtfeGoal",
                "function interpretStatement*InterState*",
                "function scrubReturnValue",
                "function isEntirelyVoid",
                "function scrubArray",
                "function scrubCacheValue",
                "function scrubArrayCache",
                "function interpret_length",
                "function interpret_keys",
                "function interpret_values",
                "function interpret_dup",
                "function interpret_aaApply",
                "function returnedArrayType",
                "function foreachApplyUtf",
                "function evaluateIfBuiltin",
                "function evaluatePostblit",
                "function evaluateDtor",
                "function hasValue",
                "function getValueVarDeclaration*",
                "function setValueNull",
                "function setValueWithoutChecking",
                "function setValue"
            ]
        },
        {
            "module" : "dclass",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "backend",
                "clone",
                "core.stdc.string",
                "declaration",
                "dmodule",
                "doc",
                "dscope",
                "dsymbol",
                "dtemplate",
                "errors",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "globals",
                "mtype",
                "root.outbuffer",
                "root.rmem",
                "root.rootobject",
                "statement",
                "target",
                "visitor"
            ],
            "members" :
            [
                "function isf",
                "struct BaseClass",
                "struct ClassFlags",
                "struct ClassDeclaration",
                "struct InterfaceDeclaration"
            ]
        },
        {
            "module" : "ctfeexpr",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "complex",
                "constfold",
                "core.stdc.stdio",
                "core.stdc.string",
                "dclass",
                "declaration",
                "dstruct",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "dinterpret",
                "tokens",
                "root.longdouble",
                "globals",
                "mtype",
                "root.outbuffer",
                "root.port",
                "root.rmem",
                "target",
                "utf",
                "visitor"
            ],
            "members" :
            [
                "struct CtfeStatus",
                "struct ClassReferenceExp",
                "struct VoidInitExp",
                "function findFieldIndexByName",
                "struct ThrownExceptionExp",
                "struct CTFEExp",
                "function exceptionOrCantInterpret",
                "function needToCopyLiteral",
                "function copyLiteralArray",
                "function copyLiteral",
                "function paintTypeOntoLiteral",
                "function paintTypeOntoLiteralCopy",
                "function resolveSlice",
                "function resolveArrayLength",
                "function createBlockDuplicatedArrayLiteral",
                "function createBlockDuplicatedStringLiteral",
                "function isAssocArray",
                "function toBuiltinAAType",
                "function isTypeInfo_Class",
                "function isPointer",
                "function isTrueBool",
                "function isSafePointerCast",
                "function getAggregateFromPointer",
                "function pointToSameMemoryBlock",
                "function pointerDifference",
                "function pointerArithmetic",
                "function comparePointers",
                "function isFloatIntPaint",
                "function paintFloatInt",
                "function intUnary",
                "function intBinary",
                "function isCtfeComparable",
                "function intUnsignedCmp",
                "function intSignedCmp",
                "function realCmp",
                "function ctfeCmpArrays",
                "function funcptrOf",
                "function isArray",
                "function ctfeRawCmp",
                "function ctfeEqual",
                "function ctfeIdentity",
                "function ctfeCmp",
                "function ctfeCat",
                "function findKeyInAA",
                "function ctfeIndex",
                "function ctfeCast",
                "function assignInPlace",
                "function recursiveBlockAssign",
                "function changeOneElement",
                "function modifyStructField",
                "function assignAssocArrayElement",
                "function changeArrayLiteralLength",
                "function isCtfeValueValid",
                "function isCtfeReferenceValid",
                "function showCtfeExpr",
                "function voidInitLiteral"
            ]
        },
        {
            "module" : "dstruct",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "argtypes",
                "arraytypes",
                "backend",
                "clone",
                "declaration",
                "dmodule",
                "doc",
                "dscope",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "tokens",
                "globals",
                "mtype",
                "opover",
                "root.outbuffer",
                "statement",
                "visitor"
            ],
            "members" :
            [
                "function search_toString",
                "function semanticTypeInfo",
                "struct StructFlags",
                "enum StructPOD",
                "struct StructDeclaration",
                "struct UnionDeclaration"
            ]
        },
        {
            "module" : "inline",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "apply",
                "arraytypes",
                "attrib",
                "core.stdc.stdio",
                "core.stdc.string",
                "declaration",
                "dscope",
                "dstruct",
                "dsymbol",
                "expression",
                "func",
                "id",
                "identifier",
                "init",
                "globals",
                "dmodule",
                "mtype",
                "statement",
                "dtemplate",
                "tokens",
                "visitor",
                "opover"
            ],
            "extra" :
            [
                "private enum LOG = false;",
                "enum CANINLINE_LOG = false;"
            ],
            "members" :
            [
                "variable COST_MAX",
                "variable STATEMENT_COST",
                "variable STATEMENT_COST_MAX",
                "function tooCostly",
                "struct InlineCostVisitor",
                "struct InlineDoState",
                "function inlineAsStatement",
                "function doInlineStatement*InlineDoState*",
                "function doInlineExpression*InlineDoState*",
                "struct InlineScanVisitor",
                "function canInline",
                "function inlineScan",
                "function expandInline",
                "function inlineCopy"
            ]
        },
        {
            "module" : "denum",
            "package" : "",
            "imports" :
            [
                "access",
                "backend",
                "declaration",
                "dmodule",
                "doc",
                "dscope",
                "dsymbol",
                "errors",
                "expression",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "tokens",
                "globals",
                "mtype",
                "root.outbuffer",
                "visitor"
            ],
            "members" :
            [
                "struct EnumDeclaration",
                "struct EnumMember"
            ]
        },
        {
            "module" : "target",
            "package" : "",
            "imports" :
            [
                "core.stdc.string",
                "expression",
                "identifier",
                "root.longdouble",
                "globals",
                "mtype",
                "dmodule"
            ],
            "members" :
            [
                "struct Target",
                "function encodeInteger",
                "function decodeInteger",
                "function encodeReal",
                "function decodeReal"
            ]
        },
        {
            "module" : "apply",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "expression",
                "visitor"
            ],
            "members" :
            [
                "struct PostorderExpressionVisitor",
                "function walkPostorderExpression*StoppableVisitor*"
            ]
        },
        {
            "module" : "init",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "declaration",
                "dcast",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "tokens",
                "globals",
                "mtype",
                "root.outbuffer",
                "root.rootobject",
                "statement",
                "visitor"
            ],
            "members" :
            [
                "enum NeedInterpret",
                "struct Initializer",
                "struct VoidInitializer",
                "struct ErrorInitializer",
                "struct StructInitializer",
                "struct ArrayInitializer",
                "struct ExpInitializer",
                "version function hasNonConstPointers"
            ]
        },
        {
            "module" : "clone",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "declaration",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "id",
                "identifier",
                "init",
                "globals",
                "mtype",
                "opover",
                "statement",
                "tokens"
            ],
            "members" :
            [
                "function mergeFuncAttrs",
                "function hasIdentityOpAssign",
                "function needOpAssign",
                "function buildOpAssign",
                "function needOpEquals",
                "function hasIdentityOpEquals",
                "function buildOpEquals",
                "function buildXopEquals",
                "function buildXopCmp",
                "function needToHash",
                "function buildXtoHash",
                "function buildPostBlit",
                "function buildDtor",
                "function buildInv"
            ]
        },
        {
            "module" : "cond",
            "package" : "",
            "imports" :
            [
                "mars",
                "arraytypes",
                "core.stdc.string",
                "dmodule",
                "dmodule",
                "dscope",
                "dsymbol",
                "errors",
                "expression",
                "hdrgen",
                "identifier",
                "globals",
                "mtype",
                "root.outbuffer",
                "tokens",
                "visitor"
            ],
            "members" :
            [
                "struct Condition",
                "struct DVCondition",
                "struct DebugCondition",
                "struct VersionCondition",
                "struct StaticIfCondition",
                "function findCondition",
                "function printDepsConditional"
            ]
        },
        {
            "module" : "access",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "dclass",
                "declaration",
                "dmodule",
                "dscope",
                "dstruct",
                "dsymbol",
                "errors",
                "expression",
                "func",
                "tokens",
                "globals",
                "mtype"
            ],
            "extra" :
            [
                "private enum LOG = false;"
            ],
            "members" :
            [
                "function getAccess",
                "function isAccessible",
                "function checkAccessAggregateDeclaration*LocScope*Dsymbol*",
                "function isFriendOf",
                "function hasPackageAccess",
                "function hasPrivateAccess",
                "function checkAccessLocScope*Expression*Declaration*"
            ]
        },
        {
            "module" : "argtypes",
            "package" : "",
            "imports" :
            [
                "core.stdc.stdio",
                "declaration",
                "globals",
                "mtype",
                "visitor"
            ],
            "members" :
            [
                "function toArgTypes"
            ]
        },
        {
            "module" : "dscope",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "attrib",
                "arraytypes",
                "core.stdc.stdio",
                "core.stdc.string",
                "dclass",
                "declaration",
                "dmodule",
                "doc",
                "dsymbol",
                "dtemplate",
                "errors",
                "func",
                "id",
                "identifier",
                "globals",
                "globals",
                "mtype",
                "root.outbuffer",
                "root.rmem",
                "root.speller",
                "root.stringtable",
                "root.aav",
                "statement"
            ],
            "members" :
            [
                "function mergeFieldInit",
                "function scope_search_fp",
                "variable CSXthis_ctor",
                "variable CSXsuper_ctor",
                "variable CSXthis",
                "variable CSXsuper",
                "variable CSXlabel",
                "variable CSXreturn",
                "variable CSXany_ctor",
                "variable CSXhalt",
                "variable SCOPEctor",
                "variable SCOPEnoaccesscheck",
                "variable SCOPEcondition",
                "variable SCOPEdebug",
                "variable SCOPEconstraint",
                "variable SCOPEinvariant",
                "variable SCOPErequire",
                "variable SCOPEensure",
                "variable SCOPEcontract",
                "variable SCOPEctfe",
                "variable SCOPEcompile",
                "variable SCOPEfree",
                "struct Scope"
            ]
        },
        {
            "module" : "hdrgen",
            "package" : "",
            "imports" :
            [
                "mars",
                "aggregate",
                "aliasthis",
                "arraytypes",
                "attrib",
                "complex",
                "cond",
                "core.stdc.ctype",
                "core.stdc.stdio",
                "core.stdc.string",
                "ctfeexpr",
                "dclass",
                "declaration",
                "dimport",
                "dmodule",
                "doc",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "denum",
                "dversion",
                "expression",
                "func",
                "identifier",
                "id",
                "init",
                "tokens",
                "root.longdouble",
                "globals",
                "mtype",
                "nspace",
                "parse",
                "root.outbuffer",
                "root.port",
                "root.rootobject",
                "statement",
                "staticassert",
                "target",
                "visitor"
            ],
            "members" :
            [
                "struct HdrGenState",
                "variable TEST_EMIT_ALL",
                "function genhdrfile",
                "struct PrettyPrintVisitor",
                "function toCBufferStatement*OutBuffer*HdrGenState*",
                "function toCBufferType*OutBuffer*Identifier*HdrGenState*",
                "function toCBufferDsymbol*OutBuffer*HdrGenState*",
                "function toCBufferInstance",
                "function toCBufferInitializer*OutBuffer*HdrGenState*",
                "function trustToBuffer",
                "function trustToChars",
                "function linkageToBuffer",
                "function linkageToChars",
                "function protectionToBuffer",
                "function protectionToChars",
                "function functionToBufferFull",
                "function functionToBufferWithIdent",
                "function toCBufferExpression*OutBuffer*HdrGenState*",
                "function argExpTypesToCBuffer",
                "function toCBufferTemplateParameter*OutBuffer*HdrGenState*",
                "function arrayObjectsToBuffer",
                "function parametersTypeToChars"
            ]
        },
        {
            "module" : "aav",
            "package" : "root",
            "imports" :
            [
                "core.stdc.stdlib",
                "core.stdc.string",
                "root.rmem"
            ],
            "extra" :
            [
            ],
            "members" :
            [
                "function hash",
                "typedef Key",
                "typedef Value",
                "struct aaA",
                "struct AA",
                "function dmd_aaLen",
                "function dmd_aaGet",
                "function dmd_aaGetRvalue",
                "function dmd_aaRehash",
                "version function unittest_aa"
            ]
        },
        {
            "module" : "file",
            "package" : "root",
            "imports" :
            [
                "core.stdc.errno",
                "core.stdc.stdlib",
                "core.stdc.stdio",
                "core.stdc.string",
                "root.array",
                "root.filename",
                "root.rmem",
                "core.sys.windows.windows",
                "core.sys.posix.sys.types",
                "core.sys.posix.utime",
                "core.sys.posix.unistd",
                "core.sys.posix.fcntl"
            ],
            "extra" :
            [
                "version (Windows) alias WIN32_FIND_DATAA = WIN32_FIND_DATA;"
            ],
            "members" :
            [
                "struct File"
            ]
        },
        {
            "module" : "outbuffer",
            "package" : "root",
            "imports" :
            [
                "core.stdc.stdarg",
                "core.stdc.stdio",
                "core.stdc.string",
                "root.rootobject",
                "root.rmem"
            ],
            "extra" :
            [
            ],
            "members" :
            [
                "struct OutBuffer"
            ]
        },
        {
            "module" : "stringtable",
            "package" : "root",
            "imports" :
            [
                "core.stdc.stdint",
                "core.stdc.string",
                "root.rmem"
            ],
            "extra" :
            [
            ],
            "members" :
            [
                "variable POOL_BITS",
                "variable POOL_SIZE",
                "function calcHash",
                "function nextpow2",
                "variable loadFactor",
                "struct StringEntry",
                "struct StringValue",
                "struct StringTable"
            ]
        },
        {
            "module" : "arrayop",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "declaration",
                "dscope",
                "dsymbol",
                "expression",
                "func",
                "id",
                "identifier",
                "globals",
                "mtype",
                "root.aav",
                "statement",
                "root.outbuffer",
                "tokens",
                "visitor"
            ],
            "members" :
            [
                "variable arrayfuncs",
                "function buildArrayOp",
                "function isArrayOpValid",
                "function isNonAssignmentArrayOp",
                "function checkNonAssignmentArrayOp",
                "function arrayOpBinExp*Scope*",
                "function arrayOpBinAssignExp*Scope*",
                "function buildArrayIdent",
                "function buildArrayLoop",
                "function isUnaArrayOp",
                "function isBinArrayOp",
                "function isBinAssignArrayOp",
                "function isArrayOpOperand"
            ]
        },
        {
            "module" : "aggregate",
            "package" : "",
            "imports" :
            [
                "access",
                "arraytypes",
                "backend",
                "clone",
                "declaration",
                "doc",
                "dclass",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "tokens",
                "globals",
                "mtype",
                "opover",
                "root.outbuffer",
                "statement",
                "visitor"
            ],
            "members" :
            [
                "enum Sizeok",
                "enum Baseok",
                "struct AggregateDeclaration"
            ]
        },
        {
            "module" : "visitor",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "aliasthis",
                "attrib",
                "cond",
                "ctfeexpr",
                "dclass",
                "declaration",
                "denum",
                "dimport",
                "dmodule",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "dversion",
                "expression",
                "func",
                "init",
                "mtype",
                "nspace",
                "statement",
                "staticassert"
            ],
            "members" :
            [
                "struct Visitor",
                "struct StoppableVisitor"
            ]
        },
        {
            "module" : "utf",
            "package" : "",
            "imports" :
            [
            ],
            "members" :
            [
                "typedef utf8_t",
                "typedef utf16_t",
                "typedef utf32_t",
                "typedef dchar_t",
                "variable ALPHA_TABLE_LENGTH",
                "variable ALPHA_TABLE",
                "variable UTF8_DECODE_OK",
                "variable UTF16_DECODE_OK",
                "variable UTF8_STRIDE",
                "variable UTF8_DECODE_OUTSIDE_CODE_SPACE",
                "variable UTF8_DECODE_TRUNCATED_SEQUENCE",
                "variable UTF8_DECODE_OVERLONG",
                "variable UTF8_DECODE_INVALID_TRAILER",
                "variable UTF8_DECODE_INVALID_CODE_POINT",
                "variable UTF16_DECODE_TRUNCATED_SEQUENCE",
                "variable UTF16_DECODE_INVALID_SURROGATE",
                "variable UTF16_DECODE_UNPAIRED_SURROGATE",
                "variable UTF16_DECODE_INVALID_CODE_POINT",
                "function utf_isValidDchar",
                "function isUniAlpha",
                "function utf_codeLengthChar",
                "function utf_codeLengthWchar",
                "function utf_codeLength",
                "function utf_encodeChar",
                "function utf_encodeWchar",
                "function utf_encode",
                "function utf_decodeChar",
                "function utf_decodeWchar"
            ]
        },
        {
            "module" : "arraytypes",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "backend",
                "dclass",
                "declaration",
                "dmodule",
                "dsymbol",
                "dtemplate",
                "expression",
                "func",
                "identifier",
                "init",
                "globals",
                "mtype",
                "root.array",
                "root.file",
                "root.rootobject",
                "statement"
            ],
            "members" :
            [
                "typedef Strings",
                "typedef Identifiers",
                "typedef TemplateParameters",
                "typedef Expressions",
                "typedef Statements",
                "typedef BaseClasses",
                "typedef ClassDeclarations",
                "typedef Dsymbols",
                "typedef Objects",
                "typedef FuncDeclarations",
                "typedef Parameters",
                "typedef Initializers",
                "typedef VarDeclarations",
                "typedef Types",
                "typedef Catches",
                "typedef StaticDtorDeclarations",
                "typedef SharedStaticDtorDeclarations",
                "typedef AliasDeclarations",
                "typedef Modules",
                "typedef CaseStatements",
                "typedef ScopeStatements",
                "typedef GotoCaseStatements",
                "typedef ReturnStatements",
                "typedef GotoStatements",
                "typedef TemplateInstances",
                "typedef Blocks",
                "typedef Symbols"
            ]
        },
        {
            "module" : "mtype",
            "package" : "",
            "imports" :
            [
                "access",
                "aggregate",
                "aliasthis",
                "argtypes",
                "arraytypes",
                "attrib",
                "backend",
                "complex",
                "core.checkedint",
                "core.stdc.float_",
                "core.stdc.stdarg",
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "ctfeexpr",
                "dcast",
                "dclass",
                "declaration",
                "denum",
                "dimport",
                "dmangle",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "imphint",
                "init",
                "root.longdouble",
                "globals",
                "dmodule",
                "opover",
                "root.outbuffer",
                "root.port",
                "root.rmem",
                "root.rootobject",
                "root.stringtable",
                "sideeffect",
                "target",
                "tokens",
                "visitor"
            ],
            "members" :
            [
                "variable LOGDOTEXP",
                "variable LOGDEFAULTINIT",
                "variable IMPLICIT_ARRAY_TO_PTR",
                "variable Tsize_t",
                "variable Tptrdiff_t",
                "function MODimplicitConv",
                "function MODmethodConv",
                "function MODmerge",
                "function MODtoBuffer",
                "function MODtoChars",
                "function ModToStc",
                "function stripDefaultArgs",
                "variable TFLAGSintegral",
                "variable TFLAGSfloating",
                "variable TFLAGSunsigned",
                "variable TFLAGSreal",
                "variable TFLAGSimaginary",
                "variable TFLAGScomplex",
                "function semanticLengthScope*TupleDeclaration*Expression*",
                "function semanticLengthScope*Type*Expression*",
                "function isTPLDg",
                "function dimDgvoid*size_tParameter*",
                "struct GetNthParamCtx",
                "function getNthParamDg",
                "enum ENUMTY",
                "typedef TY",
                "enum MODFlags",
                "typedef MOD",
                "struct Type",
                "struct TypeError",
                "struct TypeNext",
                "struct TypeBasic",
                "struct TypeVector",
                "struct TypeArray",
                "struct TypeSArray",
                "struct TypeDArray",
                "struct TypeAArray",
                "struct TypePointer",
                "struct TypeReference",
                "enum RET",
                "enum TRUST",
                "enum TRUSTformat",
                "enum PURE",
                "struct TypeFunction",
                "struct TypeDelegate",
                "struct TypeQualified",
                "struct TypeIdentifier",
                "struct TypeInstance",
                "struct TypeTypeof",
                "struct TypeReturn",
                "enum AliasThisRec",
                "struct TypeStruct",
                "struct TypeEnum",
                "struct TypeClass",
                "struct TypeTuple",
                "struct TypeSlice",
                "struct TypeNull",
                "struct Parameter"
            ]
        },
        {
            "module" : "dtemplate",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "aliasthis",
                "arraytypes",
                "attrib",
                "backend",
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "dcast",
                "dclass",
                "declaration",
                "dmangle",
                "dmodule",
                "doc",
                "dscope",
                "dsymbol",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "globals",
                "mtype",
                "opover",
                "root.aav",
                "root.array",
                "root.outbuffer",
                "root.rootobject",
                "tokens",
                "visitor"
            ],
            "extra" :
            [
                "private enum LOG = false;"
            ],
            "members" :
            [
                "variable IDX_NOTFOUND",
                "function isExpression",
                "function isDsymbol",
                "function isType",
                "function isTuple",
                "function isParameter",
                "function isError",
                "function arrayObjectIsError",
                "function getType",
                "function getDsymbol",
                "function getValueDsymbol*&",
                "function getValueExpression*",
                "function match",
                "function arrayObjectMatch",
                "function arrayObjectHash",
                "function objectSyntaxCopy",
                "struct Tuple",
                "struct TemplatePrevious",
                "struct TemplateDeclaration",
                "struct TypeDeduced",
                "function isVariadic",
                "function functionResolve",
                "function templateIdentifierLookup",
                "function templateParameterLookup",
                "function deduceWildHelper",
                "function deduceTypeHelper",
                "variable emptyArrayElement",
                "function deduceType",
                "function reliesOnTident",
                "struct TemplateParameter",
                "struct TemplateTypeParameter",
                "struct TemplateThisParameter",
                "struct TemplateValueParameter",
                "function aliasParameterSemantic",
                "struct TemplateAliasParameter",
                "struct TemplateTupleParameter",
                "struct TemplateInstance",
                "function unSpeculative",
                "function definitelyValueParameter",
                "struct TemplateMixin"
            ]
        },
        {
            "module" : "builtin",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "core.stdc.math",
                "core.stdc.string",
                "dmangle",
                "errors",
                "expression",
                "func",
                "tokens",
                "globals",
                "mtype",
                "root.port",
                "root.stringtable"
            ],
            "members" :
            [
                "typedef builtin_fp",
                "variable builtins",
                "function add_builtin",
                "function builtin_lookup",
                "function eval_unimp",
                "function eval_sin",
                "function eval_cos",
                "function eval_tan",
                "function eval_sqrt",
                "function eval_fabs",
                "function eval_bsf",
                "function eval_bsr",
                "function eval_bswap",
                "function eval_popcnt",
                "function eval_yl2x",
                "function eval_yl2xp1",
                "function builtin_init",
                "function isBuiltin",
                "function eval_builtin"
            ]
        },
        {
            "module" : "json",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "attrib",
                "core.stdc.stdio",
                "core.stdc.string",
                "dclass",
                "declaration",
                "denum",
                "dimport",
                "dmodule",
                "dsymbol",
                "dtemplate",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "globals",
                "mtype",
                "root.outbuffer",
                "visitor"
            ],
            "members" :
            [
                "struct ToJsonVisitor",
                "function json_generate"
            ]
        },
        {
            "module" : "dcast",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "aliasthis",
                "arrayop",
                "arraytypes",
                "core.stdc.stdio",
                "core.stdc.string",
                "dclass",
                "declaration",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "id",
                "init",
                "intrange",
                "tokens",
                "root.longdouble",
                "globals",
                "mtype",
                "opover",
                "root.rmem",
                "root.rootobject",
                "root.outbuffer",
                "utf",
                "visitor"
            ],
            "extra" :
            [
                "enum LOG = false;"
            ],
            "members" :
            [
                "function implicitCastTo",
                "function implicitConvTo",
                "function toStaticArrayType",
                "function castTo",
                "function inferType",
                "function scaleFactor",
                "function isVoidArrayLiteral",
                "function typeMerge",
                "function typeCombine",
                "function integralPromotions",
                "function arrayTypeCompatible",
                "function arrayTypeCompatibleWithoutCasting",
                "function getIntRange"
            ]
        },
        {
            "module" : "imphint",
            "package" : "",
            "imports" :
            [
                "core.stdc.string"
            ],
            "members" :
            [
                "function importHint",
                "version function unittest_importHint"
            ]
        },
        {
            "module" : "optimize",
            "package" : "",
            "imports" :
            [
                "constfold",
                "ctfeexpr",
                "dclass",
                "declaration",
                "expression",
                "init",
                "tokens",
                "root.longdouble",
                "globals",
                "mtype",
                "sideeffect",
                "visitor"
            ],
            "members" :
            [
                "function expandVar",
                "function fromConstInitializer",
                "function Expression_optimize"
            ]
        },
        {
            "module" : "filename",
            "package" : "root",
            "imports" :
            [
                "core.stdc.ctype",
                "core.stdc.errno",
                "core.stdc.stdlib",
                "core.stdc.string",
                "root.array",
                "root.file",
                "root.outbuffer",
                "root.rmem",
                "root.rootobject",
                "core.sys.windows.windows",
                "core.sys.posix.sys.stat",
                "core.sys.posix.stdlib"
            ],
            "extra" :
            [
                "version (Windows) extern (C) int mkdir(const char*);",
                "version (Windows) alias _mkdir = mkdir;",
                "version (Posix) extern (C) char* canonicalize_file_name(const char*);",
                "version (Windows) extern (C) int stricmp(const char*, const char*);",
                "version (Windows) extern (Windows) DWORD GetFullPathNameA(LPCTSTR lpFileName, DWORD nBufferLength, LPTSTR lpBuffer, LPTSTR* lpFilePart);"
            ],
            "members" :
            [
                "typedef Strings",
                "typedef Files",
                "struct FileName"
            ]
        },
        {
            "module" : "speller",
            "package" : "root",
            "imports" :
            [
                "core.stdc.limits",
                "core.stdc.stdlib",
                "core.stdc.string"
            ],
            "members" :
            [
                "typedef fp_speller_t",
                "variable idchars",
                "function combineSpellerResult",
                "function spellerY",
                "function spellerX",
                "function speller",
                "version function speller_test"
            ]
        },
        {
            "module" : "func",
            "package" : "",
            "imports" :
            [
                "escape",
                "mars",
                "aggregate",
                "arraytypes",
                "attrib",
                "backend",
                "builtin",
                "core.stdc.stdio",
                "core.stdc.string",
                "ctfeexpr",
                "dclass",
                "declaration",
                "dmodule",
                "doc",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "inline",
                "dinterpret",
                "globals",
                "mtype",
                "nogc",
                "opover",
                "root.filename",
                "root.outbuffer",
                "root.rmem",
                "root.rootobject",
                "statement",
                "target",
                "tokens",
                "visitor"
            ],
            "extra" :
            [
                "extern extern (C++) RET retStyle(TypeFunction tf);"
            ],
            "members" :
            [
                "enum ILS",
                "enum BUILTIN",
                "struct StatementRewriteWalker",
                "struct NrvoWalker",
                "variable FUNCFLAGpurityInprocess",
                "variable FUNCFLAGsafetyInprocess",
                "variable FUNCFLAGnothrowInprocess",
                "variable FUNCFLAGnogcInprocess",
                "variable FUNCFLAGreturnInprocess",
                "struct FuncDeclaration",
                "function addInvariant",
                "function overloadApply",
                "function MODMatchToBuffer",
                "function resolveFuncCall",
                "struct TemplateCandidateWalker",
                "struct FuncCandidateWalker",
                "function getIndirection",
                "function traverseIndirections",
                "function markAsNeedingClosure",
                "function checkEscapingSiblings",
                "struct FuncAliasDeclaration",
                "struct FuncLiteralDeclaration",
                "struct CtorDeclaration",
                "struct PostBlitDeclaration",
                "struct DtorDeclaration",
                "struct StaticCtorDeclaration",
                "struct SharedStaticCtorDeclaration",
                "struct StaticDtorDeclaration",
                "struct SharedStaticDtorDeclaration",
                "struct InvariantDeclaration",
                "function unitTestId",
                "struct UnitTestDeclaration",
                "struct NewDeclaration",
                "struct DeleteDeclaration"
            ]
        },
        {
            "module" : "dunittest",
            "package" : "",
            "imports" :
            [
            ],
            "members" :
            [
                "function unittests"
            ]
        },
        {
            "module" : "declaration",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "attrib",
                "core.stdc.stdio",
                "cppmangle",
                "ctfeexpr",
                "dclass",
                "declaration",
                "delegatize",
                "dmangle",
                "doc",
                "dcast",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "inline",
                "intrange",
                "dinterpret",
                "globals",
                "mtype",
                "opover",
                "root.outbuffer",
                "root.rootobject",
                "statement",
                "target",
                "tokens",
                "visitor"
            ],
            "members" :
            [
                "function checkFrameAccess",
                "function ObjectNotFound",
                "variable STCundefined",
                "variable STCstatic",
                "variable STCextern",
                "variable STCconst",
                "variable STCfinal",
                "variable STCabstract",
                "variable STCparameter",
                "variable STCfield",
                "variable STCoverride",
                "variable STCauto",
                "variable STCsynchronized",
                "variable STCdeprecated",
                "variable STCin",
                "variable STCout",
                "variable STClazy",
                "variable STCforeach",
                "variable STCvariadic",
                "variable STCctorinit",
                "variable STCtemplateparameter",
                "variable STCscope",
                "variable STCimmutable",
                "variable STCref",
                "variable STCinit",
                "variable STCmanifest",
                "variable STCnodtor",
                "variable STCnothrow",
                "variable STCpure",
                "variable STCtls",
                "variable STCalias",
                "variable STCshared",
                "variable STCgshared",
                "variable STCwild",
                "variable STC_TYPECTOR",
                "variable STC_FUNCATTR",
                "variable STCproperty",
                "variable STCsafe",
                "variable STCtrusted",
                "variable STCsystem",
                "variable STCctfe",
                "variable STCdisable",
                "variable STCresult",
                "variable STCnodefaultctor",
                "variable STCtemp",
                "variable STCrvalue",
                "variable STCnogc",
                "variable STCvolatile",
                "variable STCreturn",
                "variable STCStorageClass",
                "struct Match",
                "enum Semantic",
                "struct Declaration",
                "struct TupleDeclaration",
                "struct AliasDeclaration",
                "struct OverDeclaration",
                "struct VarDeclaration",
                "struct SymbolDeclaration",
                "struct TypeInfoDeclaration",
                "struct TypeInfoStructDeclaration",
                "struct TypeInfoClassDeclaration",
                "struct TypeInfoInterfaceDeclaration",
                "struct TypeInfoPointerDeclaration",
                "struct TypeInfoArrayDeclaration",
                "struct TypeInfoStaticArrayDeclaration",
                "struct TypeInfoAssociativeArrayDeclaration",
                "struct TypeInfoEnumDeclaration",
                "struct TypeInfoFunctionDeclaration",
                "struct TypeInfoDelegateDeclaration",
                "struct TypeInfoTupleDeclaration",
                "struct TypeInfoConstDeclaration",
                "struct TypeInfoInvariantDeclaration",
                "struct TypeInfoSharedDeclaration",
                "struct TypeInfoWildDeclaration",
                "struct TypeInfoVectorDeclaration",
                "struct ThisDeclaration"
            ]
        },
        {
            "module" : "dmodule",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "backend",
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "dimport",
                "dmacro",
                "doc",
                "dscope",
                "dsymbol",
                "errors",
                "expression",
                "hdrgen",
                "id",
                "identifier",
                "lexer",
                "globals",
                "parse",
                "root.file",
                "root.filename",
                "root.outbuffer",
                "root.port",
                "root.rmem",
                "target",
                "visitor"
            ],
            "members" :
            [
                "function lookForSourceFile",
                "enum PKG",
                "struct Package",
                "struct Module",
                "struct ModuleDeclaration"
            ]
        },
        {
            "module" : "sideeffect",
            "package" : "",
            "imports" :
            [
                "apply",
                "declaration",
                "expression",
                "func",
                "tokens",
                "globals",
                "mtype",
                "visitor"
            ],
            "members" :
            [
                "function isTrivialExp",
                "function hasSideEffect",
                "function callSideEffectLevelFuncDeclaration*",
                "function callSideEffectLevelType*",
                "function lambdaHasSideEffect",
                "function discardValue"
            ]
        },
        {
            "module" : "dinifile",
            "package" : "",
            "imports" :
            [
                "core.stdc.ctype",
                "core.stdc.stdlib",
                "core.stdc.string",
                "globals",
                "root.file",
                "root.filename",
                "root.outbuffer",
                "root.port",
                "root.stringtable",
                "core.sys.windows.windows",
                "core.sys.posix.stdlib"
            ],
            "extra" :
            [
                "version (Windows) extern (C) int putenv(const char*);",
                "private enum LOG = false;"
            ],
            "members" :
            [
                "function findConfFile",
                "function readFromEnv",
                "function writeToEnv",
                "function envput",
                "function updateRealEnvironment",
                "function parseConfFile",
                "function skipspace"
            ]
        },
        {
            "module" : "id",
            "package" : "",
            "imports" :
            [
                "identifier",
                "tokens"
            ],
            "members" :
            [
                "struct Id"
            ]
        },
        {
            "module" : "identifier",
            "package" : "",
            "imports" :
            [
                "core.stdc.stdio",
                "core.stdc.string",
                "id",
                "globals",
                "root.outbuffer",
                "root.rootobject",
                "root.stringtable",
                "tokens"
            ],
            "members" :
            [
                "struct Identifier"
            ]
        },
        {
            "module" : "statement",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "arrayop",
                "attrib",
                "backend",
                "canthrow",
                "core.stdc.stdarg",
                "core.stdc.stdio",
                "dcast",
                "clone",
                "cond",
                "ctfeexpr",
                "dclass",
                "declaration",
                "denum",
                "dimport",
                "dscope",
                "dsymbol",
                "dtemplate",
                "errors",
                "escape",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "inline",
                "dinterpret",
                "intrange",
                "nogc",
                "globals",
                "mtype",
                "mtype",
                "opover",
                "parse",
                "root.outbuffer",
                "root.rootobject",
                "sapply",
                "sideeffect",
                "staticassert",
                "target",
                "tokens",
                "visitor"
            ],
            "extra" :
            [
                "extern extern (C++) Statement asmSemantic(AsmStatement s, Scope* sc);"
            ],
            "members" :
            [
                "function fixupLabelName",
                "function checkLabeledLoop",
                "enum BE",
                "struct Statement",
                "struct ErrorStatement",
                "struct PeelStatement",
                "function toStatement",
                "struct ExpStatement",
                "struct DtorExpStatement",
                "struct CompileStatement",
                "struct CompoundStatement",
                "struct CompoundDeclarationStatement",
                "struct UnrolledLoopStatement",
                "struct ScopeStatement",
                "struct WhileStatement",
                "struct DoStatement",
                "struct ForStatement",
                "struct ForeachStatement",
                "struct ForeachRangeStatement",
                "struct IfStatement",
                "struct ConditionalStatement",
                "struct PragmaStatement",
                "struct StaticAssertStatement",
                "struct SwitchStatement",
                "struct CaseStatement",
                "struct CaseRangeStatement",
                "struct DefaultStatement",
                "struct GotoDefaultStatement",
                "struct GotoCaseStatement",
                "struct SwitchErrorStatement",
                "struct ReturnStatement",
                "struct BreakStatement",
                "struct ContinueStatement",
                "struct SynchronizedStatement",
                "struct WithStatement",
                "struct TryCatchStatement",
                "struct Catch",
                "struct TryFinallyStatement",
                "struct OnScopeStatement",
                "struct ThrowStatement",
                "struct DebugStatement",
                "struct GotoStatement",
                "struct LabelStatement",
                "struct LabelDsymbol",
                "struct AsmStatement",
                "struct CompoundAsmStatement",
                "struct ImportStatement"
            ]
        },
        {
            "module" : "sapply",
            "package" : "",
            "imports" :
            [
                "statement",
                "visitor"
            ],
            "members" :
            [
                "struct PostorderStatementVisitor",
                "function walkPostorderStatement*StoppableVisitor*"
            ]
        },
        {
            "module" : "dsymbol",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "aliasthis",
                "arraytypes",
                "attrib",
                "backend",
                "core.stdc.stdarg",
                "core.stdc.stdio",
                "core.stdc.string",
                "dclass",
                "declaration",
                "denum",
                "dimport",
                "dmodule",
                "doc",
                "dscope",
                "dstruct",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "lexer",
                "globals",
                "mtype",
                "nspace",
                "opover",
                "root.aav",
                "root.outbuffer",
                "root.rmem",
                "root.rootobject",
                "root.speller",
                "root.stringtable",
                "statement",
                "tokens",
                "visitor"
            ],
            "members" :
            [
                "struct Ungag",
                "enum PROTKIND",
                "struct Prot",
                "enum PASS",
                "enum IgnoreNone",
                "typedef Dsymbol_apply_ft_t",
                "struct Dsymbol",
                "function symbol_search_fp",
                "function dimDgvoid*size_tDsymbol*",
                "struct GetNthSymbolCtx",
                "function getNthSymbolDg",
                "struct ScopeDsymbol",
                "struct WithScopeSymbol",
                "struct ArrayScopeSymbol",
                "struct OverloadSet",
                "struct DsymbolTable"
            ]
        },
        {
            "module" : "dmacro",
            "package" : "",
            "imports" :
            [
                "core.stdc.ctype",
                "core.stdc.string",
                "doc",
                "root.outbuffer",
                "root.rmem",
                "utf"
            ],
            "members" :
            [
                "struct Macro",
                "function memdup",
                "function extractArgN"
            ]
        },
        {
            "module" : "link",
            "package" : "",
            "imports" :
            [
                "core.stdc.ctype",
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "mars",
                "errors",
                "globals",
                "root.file",
                "root.filename",
                "root.outbuffer",
                "root.rmem",
                "core.sys.posix.sys.wait",
                "core.sys.posix.stdlib",
                "core.sys.posix.stdio",
                "core.sys.posix.unistd"
            ],
            "extra" :
            [
                "version (Posix) extern (C) int pipe(int*);",
                "version (Windows) extern (C) int putenv(const char*);",
                "version (Windows) extern (C) int spawnlp(int, const char*, const char*, const char*, const char*);",
                "version (Windows) extern (C) int spawnl(int, const char*, const char*, const char*, const char*);",
                "version (Windows) extern (C) int spawnv(int, const char*, const char**);"
            ],
            "members" :
            [
                "version variable HAS_POSIX_SPAWN",
                "function writeFilenameOutBuffer*char*size_t",
                "function writeFilenameOutBuffer*char*",
                "version function findNoMainError",
                "function runLINK",
                "function deleteExeFile",
                "version function executecmd",
                "version function executearg0",
                "function runProgram"
            ]
        },
        {
            "module" : "traits",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "attrib",
                "canthrow",
                "core.stdc.string",
                "declaration",
                "dclass",
                "denum",
                "dimport",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "globals",
                "mtype",
                "nogc",
                "root.aav",
                "root.array",
                "root.rootobject",
                "root.stringtable",
                "root.speller",
                "tokens",
                "visitor"
            ],
            "extra" :
            [
                "enum LOGSEMANTIC = false;"
            ],
            "members" :
            [
                "struct Ptrait",
                "function fptraits",
                "function collectUnitTests",
                "function isTypeArithmetic",
                "function isTypeFloating",
                "function isTypeIntegral",
                "function isTypeScalar",
                "function isTypeUnsigned",
                "function isTypeAssociativeArray",
                "function isTypeStaticArray",
                "function isTypeAbstractClass",
                "function isTypeFinalClass",
                "function isTypeX",
                "function isFuncAbstractFunction",
                "function isFuncVirtualFunction",
                "function isFuncVirtualMethod",
                "function isFuncFinalFunction",
                "function isFuncStaticFunction",
                "function isFuncOverrideFunction",
                "function isFuncX",
                "function isDeclRef",
                "function isDeclOut",
                "function isDeclLazy",
                "function isDeclX",
                "struct PushAttributes",
                "variable traits",
                "variable traitsStringTable",
                "function initTraitsStringTable",
                "function trait_search_fp",
                "function fpisTemplate",
                "function isTemplate",
                "function isSymbolX",
                "function pointerBitmap",
                "function semanticTraits"
            ]
        },
        {
            "module" : "attrib",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "cond",
                "core.stdc.stdio",
                "core.stdc.string",
                "dclass",
                "declaration",
                "dmodule",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "dinterpret",
                "mtype",
                "tokens",
                "globals",
                "mars",
                "parse",
                "root.outbuffer",
                "root.rmem",
                "utf",
                "visitor"
            ],
            "members" :
            [
                "struct AttribDeclaration",
                "struct StorageClassDeclaration",
                "struct DeprecatedDeclaration",
                "struct LinkDeclaration",
                "struct ProtDeclaration",
                "struct AlignDeclaration",
                "struct AnonDeclaration",
                "struct PragmaDeclaration",
                "struct ConditionalDeclaration",
                "struct StaticIfDeclaration",
                "struct CompileDeclaration",
                "struct UserAttributeDeclaration",
                "function setMangleOverride"
            ]
        },
        {
            "module" : "canthrow",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "attrib",
                "apply",
                "declaration",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "expression",
                "func",
                "init",
                "tokens",
                "globals",
                "mtype",
                "root.rootobject",
                "visitor"
            ],
            "members" :
            [
                "function canThrow",
                "function Dsymbol_canThrow"
            ]
        },
        {
            "module" : "dmangle",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "arraytypes",
                "core.stdc.ctype",
                "core.stdc.stdio",
                "core.stdc.string",
                "declaration",
                "cppmangle",
                "dclass",
                "dmodule",
                "dsymbol",
                "dstruct",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "id",
                "root.longdouble",
                "globals",
                "mtype",
                "root.outbuffer",
                "root.port",
                "utf",
                "visitor"
            ],
            "members" :
            [
                "variable mangleChar",
                "function initTypeMangle",
                "function MODtoDecoBuffer",
                "struct Mangler",
                "function mangle",
                "function mangleExact",
                "function mangleToBufferType*OutBuffer*",
                "function mangleToBufferType*OutBuffer*bool",
                "function mangleToBufferExpression*OutBuffer*"
            ]
        },
        {
            "module" : "lexer",
            "package" : "",
            "imports" :
            [
                "core.stdc.ctype",
                "core.stdc.errno",
                "core.stdc.stdarg",
                "core.stdc.stdio",
                "core.stdc.string",
                "core.stdc.time",
                "entity",
                "errors",
                "id",
                "identifier",
                "root.longdouble",
                "globals",
                "tokens",
                "root.outbuffer",
                "root.port",
                "root.rmem",
                "root.stringtable",
                "utf"
            ],
            "members" :
            [
                "variable LS",
                "variable PS",
                "variable cmtable",
                "variable CMoctal",
                "variable CMhex",
                "variable CMidchar",
                "function isoctal",
                "function ishex",
                "function isidchar",
                "function cmtable_init",
                "version function unittest_lexer",
                "struct Lexer"
            ]
        },
        {
            "module" : "tokens",
            "package" : "",
            "imports" :
            [
                "core.stdc.ctype",
                "core.stdc.stdio",
                "core.stdc.string",
                "globals",
                "id",
                "identifier",
                "root.longdouble",
                "root.outbuffer",
                "root.rmem",
                "utf"
            ],
            "members" :
            [
                "enum TOK",
                "variable TOKwild",
                "struct Token",
                "struct Keyword",
                "variable nkeywords",
                "variable keywords"
            ]
        },
        {
            "module" : "parse",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "aliasthis",
                "arraytypes",
                "attrib",
                "cond",
                "core.stdc.stdio",
                "core.stdc.string",
                "dclass",
                "declaration",
                "denum",
                "dimport",
                "dmodule",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "dtemplate",
                "dversion",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "init",
                "lexer",
                "globals",
                "mtype",
                "nspace",
                "root.outbuffer",
                "root.rmem",
                "root.rootobject",
                "statement",
                "staticassert",
                "tokens"
            ],
            "members" :
            [
                "variable CDECLSYNTAX",
                "variable CCASTSYNTAX",
                "variable CARRAYDECL",
                "variable precedence",
                "function initPrecedence",
                "enum ParseStatementFlags",
                "struct PrefixAttributes",
                "struct Parser",
                "enum PREC"
            ]
        },
        {
            "module" : "staticassert",
            "package" : "",
            "imports" :
            [
                "dscope",
                "dsymbol",
                "errors",
                "expression",
                "globals",
                "hdrgen",
                "id",
                "identifier",
                "globals",
                "mtype",
                "root.outbuffer",
                "visitor"
            ],
            "members" :
            [
                "struct StaticAssert"
            ]
        },
        {
            "module" : "constfold",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "builtin",
                "complex",
                "core.stdc.string",
                "ctfeexpr",
                "declaration",
                "dstruct",
                "errors",
                "expression",
                "func",
                "tokens",
                "root.longdouble",
                "globals",
                "mtype",
                "root.port",
                "root.rmem",
                "sideeffect",
                "utf"
            ],
            "extra" :
            [
                "private enum LOG = false;"
            ],
            "members" :
            [
                "function expType",
                "function isConst",
                "function Neg",
                "function Com",
                "function Not",
                "function Bool",
                "function Add",
                "function Min",
                "function Mul",
                "function Div",
                "function Mod",
                "function Pow",
                "function Shl",
                "function Shr",
                "function Ushr",
                "function And",
                "function Or",
                "function Xor",
                "function Equal",
                "function Identity",
                "function Cmp",
                "function Cast",
                "function ArrayLength",
                "function Index",
                "function Slice",
                "function sliceAssignArrayLiteralFromString",
                "function sliceAssignStringFromArrayLiteral",
                "function sliceAssignStringFromString",
                "function sliceCmpStringWithString",
                "function sliceCmpStringWithArray",
                "function Cat",
                "function Ptr"
            ]
        },
        {
            "module" : "dversion",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "cond",
                "dmodule",
                "dmodule",
                "dscope",
                "dsymbol",
                "hdrgen",
                "identifier",
                "globals",
                "root.outbuffer",
                "visitor"
            ],
            "members" :
            [
                "struct DebugSymbol",
                "struct VersionSymbol"
            ]
        },
        {
            "module" : "dimport",
            "package" : "",
            "imports" :
            [
                "mars",
                "arraytypes",
                "attrib",
                "core.stdc.string",
                "declaration",
                "dmodule",
                "dscope",
                "dsymbol",
                "errors",
                "expression",
                "hdrgen",
                "id",
                "identifier",
                "globals",
                "mtype",
                "root.outbuffer",
                "visitor"
            ],
            "members" :
            [
                "struct Import"
            ]
        },
        {
            "module" : "aliasthis",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "declaration",
                "dscope",
                "dsymbol",
                "errors",
                "expression",
                "func",
                "hdrgen",
                "identifier",
                "tokens",
                "globals",
                "mtype",
                "opover",
                "root.outbuffer",
                "visitor"
            ],
            "members" :
            [
                "struct AliasThis",
                "function resolveAliasThis"
            ]
        },
        {
            "module" : "mars",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "backend",
                "builtin",
                "errors",
                "cond",
                "core.stdc.ctype",
                "core.stdc.errno",
                "core.stdc.limits",
                "core.stdc.stdint",
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "doc",
                "dinifile",
                "dmodule",
                "dscope",
                "dsymbol",
                "dunittest",
                "expression",
                "globals",
                "hdrgen",
                "id",
                "identifier",
                "inline",
                "dinterpret",
                "json",
                "lexer",
                "lib",
                "link",
                "mtype",
                "parse",
                "root.file",
                "root.filename",
                "root.man",
                "root.outbuffer",
                "root.rmem",
                "root.response",
                "root.stringtable",
                "target",
                "tokens",
                "traits"
            ],
            "extra" :
            [
                "enum ASYNCREAD = false;"
            ],
            "members" :
            [
                "function toWinPath",
                "function readFile",
                "function writeFile",
                "function ensurePathToNameExists",
                "function logo",
                "function usage",
                "variable entrypoint",
                "variable rootHasMain",
                "function genCmain",
                "function tryMain",
                "function main",
                "function getenv_setargv",
                "function escapePath",
                "function parse_arch_arg",
                "function parse_conf_arg",
                "function Dsymbols_create",
                "function Symbols_create",
                "function VarDeclarations_create",
                "function Blocks_create",
                "function Expressions_create"
            ]
        },
        {
            "module" : "globals",
            "package" : "",
            "imports" :
            [
                "core.stdc.stdio",
                "core.stdc.stdint",
                "core.stdc.string",
                "root.array",
                "root.filename",
                "root.outbuffer"
            ],
            "extra" :
            [
                "template xversion(string s)",
                "{",
                "    enum xversion = mixin(`{ version (` ~ s ~ `) return true; else return false; }`)();",
                "}",
                "",
                "enum __linux__ = xversion!`linux`;",
                "enum __APPLE__ = xversion!`OSX`;",
                "enum __FreeBSD__ = xversion!`FreeBSD`;",
                "enum __OpenBSD__ = xversion!`OpenBSD`;",
                "enum __sun = xversion!`Solaris`;",
                "",
                "enum IN_GCC = xversion!`IN_GCC`;",
                "",
                "enum TARGET_LINUX = xversion!`linux`;",
                "enum TARGET_OSX = xversion!`OSX`;",
                "enum TARGET_FREEBSD = xversion!`FreeBSD`;",
                "enum TARGET_OPENBSD = xversion!`OpenBSD`;",
                "enum TARGET_SOLARIS = xversion!`Solaris`;",
                "enum TARGET_WINDOS = xversion!`Windows`;"
            ],
            "members" :
            [
                "enum BOUNDSCHECK",
                "struct Param",
                "struct Compiler",
                "typedef structalign_t",
                "variable STRUCTALIGN_DEFAULT",
                "struct Global",
                "version typedef dinteger_t",
                "typedef d_int8",
                "typedef d_uns8",
                "typedef d_int16",
                "typedef d_uns16",
                "typedef d_int32",
                "typedef d_uns32",
                "typedef d_int64",
                "typedef d_uns64",
                "typedef d_float32",
                "typedef d_float64",
                "typedef d_float80",
                "typedef d_char",
                "typedef d_wchar",
                "typedef d_dchar",
                "typedef real_t",
                "struct Loc",
                "enum LINK",
                "enum DYNCAST",
                "enum MATCH",
                "enum PINLINE",
                "typedef StorageClass",
                "variable global"
            ]
        },
        {
            "module" : "expression",
            "package" : "",
            "imports" :
            [
                "mars",
                "access",
                "aggregate",
                "aliasthis",
                "apply",
                "argtypes",
                "arrayop",
                "arraytypes",
                "attrib",
                "backend",
                "canthrow",
                "complex",
                "constfold",
                "core.stdc.stdarg",
                "core.stdc.stdio",
                "core.stdc.string",
                "clone",
                "ctfeexpr",
                "dcast",
                "dclass",
                "declaration",
                "delegatize",
                "denum",
                "dimport",
                "dmangle",
                "dmodule",
                "doc",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "imphint",
                "init",
                "inline",
                "dinterpret",
                "intrange",
                "root.longdouble",
                "globals",
                "mtype",
                "nspace",
                "opover",
                "optimize",
                "parse",
                "root.aav",
                "root.file",
                "root.filename",
                "root.outbuffer",
                "root.port",
                "root.rmem",
                "root.rootobject",
                "sideeffect",
                "statement",
                "target",
                "tokens",
                "traits",
                "utf",
                "visitor"
            ],
            "extra" :
            [
                "enum LOGSEMANTIC = false;",
                "void emplaceExp(T : Expression, Args...)(void* p, Args args)",
                "{",
                "    scope tmp = new T(args);",
                "    memcpy(p, cast(void*)tmp, __traits(classInstanceSize, T));",
                "}",
                "",
                "void emplaceExp(T : UnionExp)(T* p, Expression e)",
                "{",
                "    memcpy(p, cast(void*)e, e.size);",
                "}"
            ],
            "members" :
            [
                "function getRightThis",
                "function hasThis",
                "function isNeedThisScope",
                "function resolvePropertiesX",
                "function resolveProperties",
                "function checkPropertyCall",
                "function resolvePropertiesOnly",
                "function searchUFCS",
                "function isDotOpDispatch",
                "function resolveUFCS",
                "function resolveUFCSProperties",
                "function arrayExpressionSemantic",
                "function expandTuples",
                "function isAliasThisTuple",
                "function expandAliasThisTuples",
                "function arrayExpressionToCommonType",
                "function getFuncTemplateDecl",
                "function preFunctionParameters",
                "function valueNoDtor",
                "function checkDefCtor",
                "function callCpCtor",
                "function functionParameters",
                "struct UnionExp",
                "function RealEquals",
                "function typeDotIdExp",
                "function modifyFieldVar",
                "function opAssignToOp",
                "function needDirectEq",
                "function extractOpDollarSideEffect",
                "function resolveOpDollarScope*ArrayExp*Expression**",
                "function resolveOpDollarScope*ArrayExp*IntervalExp*Expression**",
                "enum CtfeGoal",
                "enum OwnedBy",
                "variable WANTvalue",
                "variable WANTexpand",
                "struct Expression",
                "struct IntegerExp",
                "struct ErrorExp",
                "struct RealExp",
                "struct ComplexExp",
                "struct IdentifierExp",
                "struct DollarExp",
                "struct DsymbolExp",
                "struct ThisExp",
                "struct SuperExp",
                "struct NullExp",
                "struct StringExp",
                "struct TupleExp",
                "struct ArrayLiteralExp",
                "struct AssocArrayLiteralExp",
                "variable stageScrub",
                "variable stageSearchPointers",
                "variable stageOptimize",
                "variable stageApply",
                "variable stageInlineScan",
                "variable stageToCBuffer",
                "struct StructLiteralExp",
                "struct TypeExp",
                "struct ScopeExp",
                "struct TemplateExp",
                "struct NewExp",
                "struct NewAnonClassExp",
                "struct SymbolExp",
                "struct SymOffExp",
                "struct VarExp",
                "struct OverExp",
                "struct FuncExp",
                "struct DeclarationExp",
                "struct TypeidExp",
                "struct TraitsExp",
                "struct HaltExp",
                "struct IsExp",
                "struct UnaExp",
                "typedef fp_t",
                "typedef fp2_t",
                "struct BinExp",
                "struct BinAssignExp",
                "struct CompileExp",
                "struct FileExp",
                "struct AssertExp",
                "struct DotIdExp",
                "struct DotTemplateExp",
                "struct DotVarExp",
                "struct DotTemplateInstanceExp",
                "struct DelegateExp",
                "struct DotTypeExp",
                "struct CallExp",
                "struct AddrExp",
                "struct PtrExp",
                "struct NegExp",
                "struct UAddExp",
                "struct ComExp",
                "struct NotExp",
                "struct BoolExp",
                "struct DeleteExp",
                "struct CastExp",
                "struct VectorExp",
                "struct SliceExp",
                "struct ArrayLengthExp",
                "struct ArrayExp",
                "struct DotExp",
                "struct CommaExp",
                "struct IntervalExp",
                "struct DelegatePtrExp",
                "struct DelegateFuncptrExp",
                "struct IndexExp",
                "struct PostExp",
                "struct PreExp",
                "struct AssignExp",
                "struct ConstructExp",
                "struct BlitExp",
                "struct AddAssignExp",
                "struct MinAssignExp",
                "struct MulAssignExp",
                "struct DivAssignExp",
                "struct ModAssignExp",
                "struct AndAssignExp",
                "struct OrAssignExp",
                "struct XorAssignExp",
                "struct PowAssignExp",
                "struct ShlAssignExp",
                "struct ShrAssignExp",
                "struct UshrAssignExp",
                "struct CatAssignExp",
                "struct AddExp",
                "struct MinExp",
                "struct CatExp",
                "struct MulExp",
                "struct DivExp",
                "struct ModExp",
                "struct PowExp",
                "function loadStdMath",
                "struct ShlExp",
                "struct ShrExp",
                "struct UshrExp",
                "struct AndExp",
                "struct OrExp",
                "struct XorExp",
                "struct OrOrExp",
                "struct AndAndExp",
                "struct CmpExp",
                "struct InExp",
                "struct RemoveExp",
                "struct EqualExp",
                "struct IdentityExp",
                "struct CondExp",
                "struct DefaultInitExp",
                "struct FileInitExp",
                "struct LineInitExp",
                "struct ModuleInitExp",
                "struct FuncInitExp",
                "struct PrettyFuncInitExp"
            ]
        },
        {
            "module" : "delegatize",
            "package" : "",
            "imports" :
            [
                "apply",
                "declaration",
                "dscope",
                "expression",
                "func",
                "tokens",
                "globals",
                "mtype",
                "statement",
                "visitor"
            ],
            "members" :
            [
                "function toDelegate",
                "function lambdaSetParent",
                "function lambdaCheckForNestedRef"
            ]
        },
        {
            "module" : "opover",
            "package" : "",
            "imports" :
            [
                "aggregate",
                "aliasthis",
                "arraytypes",
                "core.stdc.stdio",
                "core.stdc.string",
                "declaration",
                "dclass",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "expression",
                "func",
                "id",
                "identifier",
                "tokens",
                "globals",
                "mtype",
                "statement",
                "visitor"
            ],
            "members" :
            [
                "function isCommutative",
                "function opId",
                "function opId_r",
                "function isAggregate",
                "function opToArg",
                "function op_overload",
                "function compare_overload",
                "function build_overload",
                "function search_function",
                "function inferAggregate",
                "function inferApplyArgTypes",
                "function inferApplyArgTypesX",
                "function inferApplyArgTypesY"
            ]
        },
        {
            "module" : "doc",
            "package" : "",
            "imports" :
            [
                "mars",
                "aggregate",
                "arraytypes",
                "attrib",
                "core.stdc.ctype",
                "core.stdc.stdlib",
                "core.stdc.string",
                "core.stdc.time",
                "dclass",
                "declaration",
                "denum",
                "dmacro",
                "dmodule",
                "dscope",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "errors",
                "func",
                "hdrgen",
                "id",
                "identifier",
                "lexer",
                "globals",
                "mtype",
                "root.aav",
                "root.array",
                "root.file",
                "root.filename",
                "root.outbuffer",
                "root.port",
                "root.rmem",
                "tokens",
                "utf",
                "visitor"
            ],
            "members" :
            [
                "struct Escape",
                "struct Section",
                "struct ParamSection",
                "struct MacroSection",
                "typedef Sections",
                "function isCVariadicParameter",
                "function getEponymousMember",
                "function getEponymousParent",
                "variable ddoc_default",
                "variable ddoc_decl_s",
                "variable ddoc_decl_e",
                "variable ddoc_decl_dd_s",
                "variable ddoc_decl_dd_e",
                "function gendocfile",
                "function escapeDdocString",
                "function escapeStrayParenthesis",
                "function skipNonQualScopes",
                "function emitAnchorName",
                "function emitAnchor",
                "function getCodeIndent",
                "function expandTemplateMixinComments",
                "function emitMemberComments",
                "function emitProtection",
                "function emitComment",
                "function toDocBuffer",
                "struct DocComment",
                "function cmp",
                "function icmp",
                "function isDitto",
                "function skipwhitespace",
                "function skiptoident",
                "function skippastident",
                "function skippastURL",
                "function isIdentifier",
                "function isKeyword",
                "function isTypeFunction",
                "function isFunctionParameter",
                "function isTemplateParameter",
                "function isReservedName",
                "function highlightText",
                "function highlightCodeScope*Dsymbol*OutBuffer*size_t",
                "function highlightCodeScope*Dsymbols*OutBuffer*size_t",
                "function highlightCode3",
                "function highlightCode2",
                "function isCVariadicArg",
                "function isIdStart",
                "function isIdTail",
                "function isIndentWS",
                "function utfStride"
            ]
        },
        {
            "module" : "cppmangle",
            "package" : "",
            "imports" :
            [
                "arraytypes",
                "core.stdc.string",
                "declaration",
                "dstruct",
                "dsymbol",
                "dtemplate",
                "expression",
                "func",
                "id",
                "identifier",
                "tokens",
                "globals",
                "mtype",
                "target",
                "root.outbuffer",
                "root.rootobject",
                "visitor"
            ],
            "members" :
            [
                "version struct CppMangleVisitor"
            ]
        },
        {
            "module" : "lib",
            "package" : "",
            "imports" :
            [
                "globals"
            ],
            "extra" : [
                "extern (C++) Library LibOMF_factory();",
                "extern (C++) Library LibElf_factory();",
                "extern (C++) Library LibMSCoff_factory();",
                "extern (C++) Library LibMach_factory();"
            ],
            "members" : [
                "struct Library"
            ]
        },
        {
            "module" : "nogc",
            "package" : "",
            "imports" :
            [
                "apply",
                "declaration",
                "dscope",
                "expression",
                "func",
                "id",
                "identifier",
                "init",
                "tokens",
                "globals",
                "mtype",
                "sapply",
                "statement",
                "visitor"
            ],
            "members" :
            [
                "struct NOGCVisitor",
                "function checkGC"
            ]
        },
        {
            "module" : "nspace",
            "package" : "",
            "imports" : [
                "arraytypes",
                "aggregate",
                "dscope",
                "dsymbol",
                "hdrgen",
                "identifier",
                "globals",
                "root.outbuffer",
                "visitor"
            ],
            "extra" :
            [
                "private enum LOG = false;"
            ],
            "members" :
            [
                "struct Nspace"
            ]
        },
        {
            "module" : "errors",
            "package" : "",
            "imports" : [
                "core.stdc.stdarg",
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "core.sys.posix.unistd",
                "core.sys.windows.windows",
                "globals",
                "root.outbuffer",
                "root.rmem"
            ],
            "extra" :
            [
                "version (Windows) extern (C) int isatty(int);",
                "version (Windows) alias _isatty = isatty;",
                "version (Windows) int _fileno(FILE* f)",
                "{",
                "    return f._file;",
                "}"
            ],
            "members" :
            [
                "enum COLOR",
                "version function consoleAttributes",
                "function isConsoleColorSupported",
                "function setConsoleColorBright",
                "function setConsoleColor",
                "function resetConsoleColor",
                "function errorLocchar*??",
                "function errorchar*unsignedunsignedchar*??",
                "function errorSupplemental",
                "function warning",
                "function warningSupplemental",
                "function deprecation",
                "function deprecationSupplemental",
                "function verrorPrint",
                "function verror",
                "function verrorSupplemental",
                "function vwarning",
                "function vwarningSupplemental",
                "function vdeprecation",
                "function vdeprecationSupplemental",
                "function fatal",
                "function halt"
            ]
        },
        {
            "module" : "escape",
            "package" : "",
            "imports" : [
                "dscope",
                "dsymbol",
                "expression",
                "visitor",
                "globals",
                "declaration",
                "func",
                "mtype",
                "root.rootobject",
                "tokens",
                "errors",
                "init"
            ],
            "members" :
            [
                "function checkEscape",
                "function checkEscapeRef"
            ]
        },
        {
            "module" : "man",
            "package" : "root",
            "imports" : [
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "core.sys.windows.windows",
                "core.sys.posix.sys.types",
                "core.sys.posix.sys.wait",
                "core.sys.posix.unistd"
            ],
            "members" :
            [
                "version function browse"
            ]
        },
        {
            "module" : "response",
            "package" : "root",
            "imports" : [
                "core.stdc.stdio",
                "core.stdc.stdlib",
                "core.stdc.string",
                "root.filename",
                "root.file"
            ],
            "members" :
            [
                "function response_expand"
            ]
        }
    ],
    "basicTypes" :
    [
        "void",
        "bool",
        "char",
        "short",
        "int",
        "long",
        "float",
        "double",

        "volatile",
        "unsigned",
        "signed",

        "size_t",
        "time_t",
        "longdouble",
        "volatile_longdouble",
        "uinteger_t",
        "sinteger_t",
        "dinteger_t",
        "dchar_t",
        "real_t",
        "complex_t",
        "d_float80",
        "d_int8",
        "d_uns8",
        "d_int16",
        "d_uns16",
        "d_int32",
        "d_uns32",
        "d_int64",
        "d_uns64",
        "d_wchar",
        "d_dchar",
        "longlong",
        "ulonglong",
        "hash_t",
        "DWORD",
        "WORD",
        "HANDLE",
        "Key",
        "Value",

        "int8_t",
        "uint8_t",
        "int16_t",
        "uint16_t",
        "int32_t",
        "uint32_t",
        "int64_t",
        "uint64_t",
        "ssize_t",

        "fp_t",
        "fp2_t",
        "Dsymbol_apply_ft_t",
        "pid_t",
        "utf32_t",
        "utf16_t",
        "utf8_t",
        "ForeachDg",
        "fp_speller_t",
        "builtin_fp",

        "TY",
        "StorageClass",
        "MATCH",
        "PROTKIND",
        "NeedInterpret",
        "FLAGS",
        "AliasThisRec",
        "StructPOD",
        "COLOR",
        "OwnedBy",

        "LINK",
        "PINLINE",
        "PREC",
        "BUILTIN",
        "PASS",
        "Sizeok",
        "Semantic",
        "PURE",
        "TRUST",
        "RET",
        "PKG",
        "TRUSTformat",
        "Baseok",
        "BOUNDSCHECK"
    ],
    "structTypes" :
    [
        "IntRange",
        "SignExtendedNumber",
        "va_list",
        "type",
        "code",
        "block",
        "InlineDoState",
        "CtfeStatus",
        "CtfeGoal",
        "TOK",
        "stat",
        "SV",
        "ILS",
        "TYPE",
        "FILE",
        "structalign_t",
        "Ctxt",
        "WIN32_FIND_DATAA",
        "utimbuf",
        "Symbol",
        "StructFlags",
        "ClassFlags",
        "CONSOLE_SCREEN_BUFFER_INFO",
        "MOD",
        "AsyncRead",

        "Strings",
        "Sections"
    ],
    "classTypes" :
    [
    ],
    "rootclasses" :
    [
        "Section",
        "Condition",
        "TemplateParameter",
        "Lexer",
        "RootObject",
        "Library",
        "Visitor"
    ],
    "overriddenfuncs" :
    [
        ["AggregateDeclaration", "mangle"],
        ["AggregateDeclaration", "toDocBuffer"],
        ["AssignExp", "clone"],
        ["AttribDeclaration", "addComment"],
        ["AttribDeclaration", "addMember"],
        ["AttribDeclaration", "emitComment"],
        ["AttribDeclaration", "kind"],
        ["AttribDeclaration", "oneMember"],
        ["AttribDeclaration", "semantic"],
        ["AttribDeclaration", "semantic2"],
        ["AttribDeclaration", "semantic3"],
        ["AttribDeclaration", "setFieldOffset"],
        ["AttribDeclaration", "toCBuffer"],
        ["AttribDeclaration", "toJson"],
        ["AttribDeclaration", "toObjFile"],
        ["BinAssignExp", "semantic"],
        ["BinExp", "apply"],
        ["BinExp", "buildArrayIdent"],
        ["BinExp", "buildArrayLoop"],
        ["BinExp", "doInline"],
        ["BinExp", "inlineScan"],
        ["BinExp", "interpret"],
        ["BinExp", "op_overload"],
        ["BinExp", "optimize"],
        ["BinExp", "semantic"],
        ["BinExp", "syntaxCopy"],
        ["BinExp", "toCBuffer"],
        ["ClassDeclaration", "finalizeSize"],
        ["ClassDeclaration", "kind"],
        ["ClassDeclaration", "semantic"],
        ["ClassDeclaration", "syntaxCopy"],
        ["ClassDeclaration", "toObjFile"],
        ["ClassDeclaration", "toSymbol"],
        ["CompoundStatement", "syntaxCopy"],
        ["CompoundStatement", "toCBuffer"],
        ["ConditionalDeclaration", "importAll"],
        ["ConditionalDeclaration", "include"],
        ["ConditionalDeclaration", "setScope"],
        ["ConditionalDeclaration", "syntaxCopy"],
        ["Declaration", "emitComment"],
        ["Declaration", "kind"],
        ["Declaration", "mangle"],
        ["Declaration", "semantic"],
        ["Declaration", "toDocBuffer"],
        ["Declaration", "toJson"],
        ["Dsymbol", "defineRef"],
        ["Dsymbol", "emitComment"],
        ["Dsymbol", "equals"],
        ["Dsymbol", "hasStaticCtorOrDtor"],
        ["Dsymbol", "inlineScan"],
        ["Dsymbol", "isforwardRef"],
        ["Dsymbol", "isOverloadable"],
        ["Dsymbol", "isScopeDsymbol"],
        ["Dsymbol", "isTemplateDeclaration"],
        ["Dsymbol", "jsonProperties"],
        ["Dsymbol", "kind"],
        ["Dsymbol", "overloadInsert"],
        ["Dsymbol", "prot"],
        ["Dsymbol", "search"],
        ["Dsymbol", "semantic"],
        ["Dsymbol", "semantic2"],
        ["Dsymbol", "semantic3"],
        ["Dsymbol", "syntaxCopy"],
        ["Dsymbol", "toCBuffer"],
        ["Dsymbol", "toChars"],
        ["Dsymbol", "toJson"],
        ["Expression", "toChars"],
        ["ExpStatement", "syntaxCopy"],
        ["ExpStatement", "toIR"],
        ["FuncDeclaration", "inlineScan"],
        ["FuncDeclaration", "isThis"],
        ["FuncDeclaration", "kind"],
        ["FuncDeclaration", "mangle"],
        ["FuncDeclaration", "overloadInsert"],
        ["FuncDeclaration", "semantic"],
        ["FuncDeclaration", "syntaxCopy"],
        ["FuncDeclaration", "toCBuffer"],
        ["FuncDeclaration", "toJson"],
        ["FuncDeclaration", "toPrettyChars"],
        ["FuncDeclaration", "toSymbol"],
        ["IdentifierExp", "clone"],
        ["Package", "kind"],
        ["Package", "search"],
        ["ScopeDsymbol", "hasStaticCtorOrDtor"],
        ["ScopeDsymbol", "kind"],
        ["ScopeDsymbol", "search"],
        ["ScopeDsymbol", "syntaxCopy"],
        ["StaticCtorDeclaration", "syntaxCopy"],
        ["StaticCtorDeclaration", "toCBuffer"],
        ["StaticDtorDeclaration", "syntaxCopy"],
        ["StaticDtorDeclaration", "toCBuffer"],
        ["StorageClassDeclaration", "setScope"],
        ["StorageClassDeclaration", "syntaxCopy"],
        ["StorageClassDeclaration", "toCBuffer"],
        ["StructDeclaration", "kind"],
        ["StructDeclaration", "syntaxCopy"],
        ["SymbolExp", "clone"],
        ["TemplateInstance", "findTemplateDeclaration"],
        ["TemplateInstance", "inlineScan"],
        ["TemplateInstance", "kind"],
        ["TemplateInstance", "oneMember"],
        ["TemplateInstance", "semantic"],
        ["TemplateInstance", "semantic2"],
        ["TemplateInstance", "semantic3"],
        ["TemplateInstance", "syntaxCopy"],
        ["TemplateInstance", "toCBuffer"],
        ["TemplateInstance", "toChars"],
        ["TemplateInstance", "toObjFile"],
        ["TemplateTypeParameter", "syntaxCopy"],
        ["TemplateTypeParameter", "toCBuffer"],
        ["ThisExp", "clone"],
        ["ThisExp", "doInline"],
        ["ThisExp", "semantic"],
        ["ThisExp", "toCBuffer"],
        ["TypeArray", "dotExp"],
        ["Type", "equals"],
        ["TypeInfoDeclaration", "toSymbol"],
        ["TypeNext", "constConv"],
        ["TypeNext", "reliesOnTident"],
        ["TypeNext", "toDecoBuffer"],
        ["TypeQualified", "size"],
        ["TypeQualified", "toJson"],
        ["Type", "toChars"],
        ["UnaExp", "apply"],
        ["UnaExp", "doInline"],
        ["UnaExp", "dump"],
        ["UnaExp", "inlineScan"],
        ["UnaExp", "interpret"],
        ["UnaExp", "optimize"],
        ["UnaExp", "semantic"],
        ["UnaExp", "syntaxCopy"],
        ["UnaExp", "toCBuffer"],
        ["VarDeclaration", "semantic"],
        ["VarDeclaration", "syntaxCopy"],
        ["VarDeclaration", "toJson"],
        ["VarDeclaration", "toObjFile"],
        ["VarDeclaration", "toSymbol"],
        ["*", "accept"],
        ["*", "visit"],
        ["AttribDeclaration", "setScope"],
        ["AttribDeclaration", "importAll"],
        ["CompoundStatement", "semantic"],
        ["CompoundStatement", "flatten"]
    ],
    "nonfinalclasses" :
    [
        "AggregateDeclaration",
        "AssignExp",
        "AttribDeclaration",
        "BinAssignExp",
        "BinExp",
        "ClassDeclaration",
        "CompoundStatement",
        "Condition",
        "ConditionalDeclaration",
        "Declaration",
        "DefaultInitExp",
        "Dsymbol",
        "DVCondition",
        "Expression",
        "ExpStatement",
        "FuncDeclaration",
        "IdentifierExp",
        "Initializer",
        "Lexer",
        "Library",
        "Package",
        "ScopeDsymbol",
        "Section",
        "Statement",
        "StatementRewriteWalker",
        "StaticCtorDeclaration",
        "StaticDtorDeclaration",
        "StoppableVisitor",
        "StorageClassDeclaration",
        "StructDeclaration",
        "SymbolExp",
        "TemplateInstance",
        "TemplateTypeParameter",
        "TemplateParameter",
        "ThisExp",
        "TypeArray",
        "Type",
        "TypeInfoDeclaration",
        "TypeNext",
        "TypeQualified",
        "Type",
        "UnaExp",
        "VarDeclaration",
        "Visitor"
    ]
}
