TIIPair {...}{.final.} = object
  key*, val*: int

TIIPairSeq = seq[TIIPair]

TIITable {...}{.final.} = object
  counter*: int
  data*: TIIPairSeq

TIdentIter = object
  h*: Hash
  name*: PIdent

TTabIter = object
  h: Hash

InvalidKey = -9223372036854775808

proc typekinds(t: PType) {...}{.deprecated, raises: [], tags: [].}

proc skipConvAndClosure(n: PNode): PNode {...}{.raises: [], tags: [].}

proc sameValue(a, b: PNode): bool {...}{.raises: [ERecoverableError], tags: [].}

proc leValue(a, b: PNode): bool {...}{.raises: [ERecoverableError], tags: [].}

proc weakLeValue(a, b: PNode): TImplication {...}{.raises: [ERecoverableError],
    tags: [].}

proc lookupInRecord(n: PNode; field: PIdent): PSym {...}{.raises: [], tags: [].}

proc getModule(s: PSym): PSym {...}{.raises: [], tags: [].}

proc fromSystem(op: PSym): bool {...}{.inline, raises: [], tags: [].}

proc getSymFromList(list: PNode; ident: PIdent; start: int = 0): PSym {...}{.
    raises: [], tags: [].}

proc getNamedParamFromList(list: PNode; ident: PIdent): PSym {...}{.raises: [],
    tags: [].}

proc hashNode(p: RootRef): Hash {...}{.raises: [], tags: [].}

proc mustRehash(length, counter: int): bool {...}{.raises: [], tags: [].}

proc makeYamlString(s: string): Rope {...}{.raises: [], tags: [].}

proc lineInfoToStr(conf: ConfigRef; info: TLineInfo): Rope {...}{.raises: [],
    tags: [].}

proc treeToYaml(conf: ConfigRef; n: PNode; indent: int = 0;
                maxRecDepth: int = -1): Rope {...}{.raises: [Exception],
    tags: [RootEffect].}

proc typeToYaml(conf: ConfigRef; n: PType; indent: int = 0;
                maxRecDepth: int = -1): Rope {...}{.raises: [Exception],
    tags: [RootEffect].}

proc symToYaml(conf: ConfigRef; n: PSym; indent: int = 0; maxRecDepth: int = -1): Rope {...}{.
    raises: [Exception], tags: [RootEffect].}

proc debug(n: PSym; conf: ConfigRef = nil) {...}{.exportc: "debugSym", deprecated,
    raises: [Exception], tags: [RootEffect].}

proc debug(n: PType; conf: ConfigRef = nil) {...}{.exportc: "debugType", deprecated,
    raises: [Exception], tags: [RootEffect].}

proc debug(n: PNode; conf: ConfigRef = nil) {...}{.exportc: "debugNode", deprecated,
    raises: [Exception], tags: [RootEffect].}

proc nextTry(h, maxHash: Hash): Hash {...}{.inline, raises: [], tags: [].}

proc objectSetContains(t: TObjectSet; obj: RootRef): bool {...}{.raises: [], tags: [].}

proc objectSetIncl(t: var TObjectSet; obj: RootRef) {...}{.raises: [], tags: [].}

proc objectSetContainsOrIncl(t: var TObjectSet; obj: RootRef): bool {...}{.
    raises: [], tags: [].}

proc strTableContains(t: TStrTable; n: PSym): bool {...}{.raises: [], tags: [].}

proc symTabReplace(t: var TStrTable; prevSym: PSym; newSym: PSym) {...}{.raises: [],
    tags: [].}

proc strTableAdd(t: var TStrTable; n: PSym) {...}{.raises: [], tags: [].}

proc strTableInclReportConflict(t: var TStrTable; n: PSym;
                                onConflictKeepOld = false): PSym {...}{.raises: [],
    tags: [].}

proc strTableIncl(t: var TStrTable; n: PSym; onConflictKeepOld = false): bool {...}{.
    discardable, raises: [], tags: [].}

proc strTableGet(t: TStrTable; name: PIdent): PSym {...}{.raises: [], tags: [].}

proc nextIdentIter(ti: var TIdentIter; tab: TStrTable): PSym {...}{.raises: [],
    tags: [].}

proc initIdentIter(ti: var TIdentIter; tab: TStrTable; s: PIdent): PSym {...}{.
    raises: [], tags: [].}

proc nextIdentExcluding(ti: var TIdentIter; tab: TStrTable; excluding: IntSet): PSym {...}{.
    raises: [], tags: [].}

proc firstIdentExcluding(ti: var TIdentIter; tab: TStrTable; s: PIdent;
                         excluding: IntSet): PSym {...}{.raises: [], tags: [].}

proc nextIter(ti: var TTabIter; tab: TStrTable): PSym {...}{.raises: [], tags: [].}

proc initTabIter(ti: var TTabIter; tab: TStrTable): PSym {...}{.raises: [], tags: [].}

proc idTableHasObjectAsKey(t: TIdTable; key: PIdObj): bool {...}{.raises: [],
    tags: [].}

proc idTableGet(t: TIdTable; key: PIdObj): RootRef {...}{.raises: [], tags: [].}

proc idTableGet(t: TIdTable; key: int): RootRef {...}{.raises: [], tags: [].}

proc idTablePut(t: var TIdTable; key: PIdObj; val: RootRef) {...}{.raises: [],
    tags: [].}

proc idNodeTableGet(t: TIdNodeTable; key: PIdObj): PNode {...}{.raises: [], tags: [].}

proc idNodeTablePut(t: var TIdNodeTable; key: PIdObj; val: PNode) {...}{.raises: [],
    tags: [].}

proc initIiTable(x: var TIITable) {...}{.raises: [], tags: [].}

proc iiTableGet(t: TIITable; key: int): int {...}{.raises: [], tags: [].}

proc iiTablePut(t: var TIITable; key, val: int) {...}{.raises: [], tags: [].}

proc isAddrNode(n: PNode): bool {...}{.raises: [], tags: [].}

proc listSymbolNames(symbols: openArray[PSym]): string {...}{.raises: [], tags: [].}

proc isDiscriminantField(n: PNode): bool {...}{.raises: [], tags: [].}

iterator items(tab: TStrTable): PSym {...}{.raises: [], tags: [].}

iterator pairs(t: TIdTable): tuple[key: int, value: RootRef] {...}{.raises: [],
    tags: [].}

iterator idTablePairs(t: TIdTable): tuple[key: PIdObj, val: RootRef] {...}{.
    raises: [], tags: [].}

iterator pairs(t: TIdNodeTable): tuple[key: PIdObj, val: PNode] {...}{.raises: [],
    tags: [].}

template debug(x: PSym | PType | PNode) {...}{.deprecated.}

template debug(x: auto) {...}{.deprecated.}

template mdbg(): bool {...}{.deprecated.}