float {...}{.magic: Float.}

float32 {...}{.magic: Float32.}

float64 {...}{.magic: Float.}

char {...}{.magic: Char.}

string {...}{.magic: String.}

cstring {...}{.magic: Cstring.}

pointer {...}{.magic: Pointer.}

typedesc {...}{.magic: TypeDesc.}

ptr[T] {...}{.magic: Pointer.}

ref[T] {...}{.magic: Pointer.}

void {...}{.magic: "VoidType".}

auto {...}{.magic: Expr.}

any = distinct auto

untyped {...}{.magic: Expr.}

typed {...}{.magic: Stmt.}

int {...}{.magic: "Int".}

int8 {...}{.magic: "Int8".}

int16 {...}{.magic: "Int16".}

int32 {...}{.magic: "Int32".}

int64 {...}{.magic: "Int64".}

uint {...}{.magic: "UInt".}

uint8 {...}{.magic: "UInt8".}

uint16 {...}{.magic: "UInt16".}

uint32 {...}{.magic: "UInt32".}

uint64 {...}{.magic: "UInt64".}

bool {...}{.magic: "Bool".} = enum
  false = 0, true = 1

SomeSignedInt = int | int8 | int16 | int32 | int64

SomeUnsignedInt = uint | uint8 | uint16 | uint32 | uint64

SomeInteger = SomeSignedInt | SomeUnsignedInt

SomeOrdinal = int | int8 | int16 | int32 | int64 | bool | enum | uint | uint8 |
    uint16 |
    uint32 |
    uint64

BiggestInt = int64

SomeFloat = float | float32 | float64

SomeNumber = SomeInteger | SomeFloat

Ordinal[T] {...}{.magic: Ordinal.}

static[T] {...}{.magic: "Static".}

type[T] {...}{.magic: "Type".}

TypeOfMode = enum
  typeOfProc,                 ## Prefer the interpretation that means `x` is a proc call.
  typeOfIter                  ## Prefer the interpretation that means `x` is an iterator call.

range[T] {...}{.magic: "Range".}

array[I; T] {...}{.magic: "Array".}

openArray[T] {...}{.magic: "OpenArray".}

varargs[T] {...}{.magic: "Varargs".}

seq[T] {...}{.magic: "Seq".}

set[T] {...}{.magic: "Set".}

UncheckedArray[T] {...}{.magic: "UncheckedArray".}

sink[T] {...}{.magic: "BuiltinType".}

lent[T] {...}{.magic: "BuiltinType".}

HSlice[T; U] = object
  a*: T                        ## The lower bound (inclusive).
  b*: U                        ## The upper bound (inclusive).
  

Slice[T] = HSlice[T, T]

byte = uint8

Natural = range[0 .. high(int)]

Positive = range[1 .. high(int)]

RootObj {...}{.compilerproc, inheritable.} = object

RootRef = ref RootObj

RootEffect {...}{.compilerproc.} = object of RootObj

TimeEffect = object of RootEffect

IOEffect = object of RootEffect

ReadIOEffect = object of IOEffect

WriteIOEffect = object of IOEffect

ExecIOEffect = object of IOEffect

StackTraceEntry = object
  procname*: cstring           ## Name of the proc that is currently executing.
  line*: int                   ## Line number of the proc that is currently executing.
  filename*: cstring           ## Filename of the proc that is currently executing.
  when NimStackTraceMsgs:
      frameMsg*: string ## When a stacktrace is generated in a given frame and
                      ## rendered at a later time, we should ensure the stacktrace
                      ## data isn't invalidated; any pointer into PFrame is
                      ## subject to being invalidated so shouldn't be stored.
    
  

Exception {...}{.compilerproc, magic: "Exception".} = object of RootObj
  parent*: ref Exception        ## Parent exception (can be used as a stack).
  name*: cstring               ## The exception's name is its Nim identifier.
               ## This field is filled automatically in the
               ## ``raise`` statement.
  msg* {...}{.exportc: "message".}: string ## The exception's message. Not
                                  ## providing an exception message
                                  ## is bad style.
  when defined(js):
      trace: string

  else:
      trace: seq[StackTraceEntry]

  up: ref Exception

Defect = object of Exception

CatchableError = object of Exception

IOError = object of CatchableError

EOFError = object of IOError

OSError = object of CatchableError
  errorCode*: int32            ## OS-defined error code describing this error.
  

LibraryError = object of OSError

ResourceExhaustedError = object of CatchableError

ArithmeticError = object of Defect

DivByZeroError = object of ArithmeticError

OverflowError = object of ArithmeticError

AccessViolationError = object of Defect

AssertionError = object of Defect

ValueError = object of CatchableError

KeyError = object of ValueError

OutOfMemError = object of Defect

IndexError = object of Defect

FieldError = object of Defect

RangeError = object of Defect

StackOverflowError = object of Defect

ReraiseError = object of Defect

ObjectAssignmentError = object of Defect

ObjectConversionError = object of Defect

FloatingPointError = object of Defect

FloatInvalidOpError = object of FloatingPointError

FloatDivByZeroError = object of FloatingPointError

FloatOverflowError = object of FloatingPointError

FloatUnderflowError = object of FloatingPointError

FloatInexactError = object of FloatingPointError

DeadThreadError = object of Defect

NilAccessError = object of Defect

JsRoot = ref object of RootObj
  

owned[T] {...}{.magic: "BuiltinType".}

Endianness = enum
  littleEndian, bigEndian

TaintedString = string

ByteAddress = int

BiggestFloat = float64

BiggestUInt = uint64

clong {...}{.importc: "long", nodecl.} = int32

culong {...}{.importc: "unsigned long", nodecl.} = uint32

cchar {...}{.importc: "char", nodecl.} = char

cschar {...}{.importc: "signed char", nodecl.} = int8

cshort {...}{.importc: "short", nodecl.} = int16

cint {...}{.importc: "int", nodecl.} = int32

csize {...}{.importc: "size_t", nodecl, deprecated: "use `csize_t` instead".} = int

csize_t {...}{.importc: "size_t", nodecl.} = uint

clonglong {...}{.importc: "long long", nodecl.} = int64

cfloat {...}{.importc: "float", nodecl.} = float32

cdouble {...}{.importc: "double", nodecl.} = float64

clongdouble {...}{.importc: "long double", nodecl.} = BiggestFloat

cuchar {...}{.importc: "unsigned char", nodecl.} = char

cushort {...}{.importc: "unsigned short", nodecl.} = uint16

cuint {...}{.importc: "unsigned int", nodecl.} = uint32

culonglong {...}{.importc: "unsigned long long", nodecl.} = uint64

cstringArray {...}{.importc: "char**", nodecl.} = ptr UncheckedArray[cstring]

PFloat32 = ptr float32

PFloat64 = ptr float64

PInt64 = ptr int64

PInt32 = ptr int32

AllocStats = object
  allocCount: int
  deallocCount: int

AtomType = SomeNumber | pointer | ptr | char | bool

GC_Strategy = enum
  gcThroughput,               ## optimize for throughput
  gcResponsiveness,           ## optimize for responsiveness (default)
  gcOptimizeTime,             ## optimize for speed
  gcOptimizeSpace             ## optimize for memory footprint

PFrame = ptr TFrame

TFrame {...}{.importc, nodecl, final.} = object
  prev*: PFrame                ## Previous frame; used for chaining the call stack.
  procname*: cstring           ## Name of the proc that is currently executing.
  line*: int                   ## Line number of the proc that is currently executing.
  filename*: cstring           ## Filename of the proc that is currently executing.
  len*: int16                  ## Length of the inspectable slots.
  calldepth*: int16            ## Used for max call depth checking.
  when NimStackTraceMsgs:
      frameMsgLen*: int        ## end position in frameMsgBuf for this frame.
    
  

FileSeekPos = enum
  fspSet,                     ## Seek to absolute value
  fspCur,                     ## Seek relative to current position
  fspEnd                      ## Seek relative to end

ForeignCell = object
  data*: pointer
  owner: ptr GcHeap

BackwardsIndex = distinct int

NimNode {...}{.magic: "PNimrodNode".} = ref NimNodeObj

ForLoopStmt {...}{.compilerproc.} = object

programResult: int

globalRaiseHook: proc (e: ref Exception): bool {...}{.nimcall, gcsafe, locks: 0.}

localRaiseHook: proc (e: ref Exception): bool {...}{.nimcall, gcsafe, locks: 0.}

outOfMemHook: proc () {...}{.nimcall, tags: [], gcsafe, locks: 0, raises: [].}

unhandledExceptionHook: proc (e: ref Exception) {...}{.nimcall, tags: [], gcsafe, locks: 0,
    raises: [].}

errorMessageWriter: (proc (msg: string) {...}{.tags: [WriteIOEffect], gcsafe, locks: 0,
                                      nimcall.})

onUnhandledException: (proc (errorMsg: string) {...}{.nimcall.})

nimvm: bool = false

on = true

off = false

appType: string = ""

NoFakeVars = false

isMainModule: bool = false

CompileDate: string = "0000-00-00"

CompileTime: string = "00:00:00"

cpuEndian: Endianness = littleEndian

hostOS: string = ""

hostCPU: string = ""

nimEnableCovariance = false

QuitSuccess = 0

QuitFailure = 1

Inf = 0x7FF0000000000000'f64

NegInf = 0xFFF0000000000000'f64

NaN = 0x7FF7FFFFFFFFFFFF'f64

nimCoroutines = false

NimMajor: int = 1

NimMinor: int = 2

NimPatch: int = 0

NimVersion: string = "1.2.0"

nativeStackTraceSupported = false

proc `not`(x: bool): bool {...}{.magic: "Not", noSideEffect.}

proc `and`(x, y: bool): bool {...}{.magic: "And", noSideEffect.}

proc `or`(x, y: bool): bool {...}{.magic: "Or", noSideEffect.}

proc `xor`(x, y: bool): bool {...}{.magic: "Xor", noSideEffect.}

proc compileOption(option: string): bool {...}{.magic: "CompileOption", noSideEffect.}

proc compileOption(option, arg: string): bool {...}{.magic: "CompileOptionArg", noSideEffect.}

proc `or`(a, b: typedesc): typedesc {...}{.magic: "TypeTrait", noSideEffect.}

proc `and`(a, b: typedesc): typedesc {...}{.magic: "TypeTrait", noSideEffect.}

proc `not`(a: typedesc): typedesc {...}{.magic: "TypeTrait", noSideEffect.}

proc defined(x: untyped): bool {...}{.magic: "Defined", noSideEffect, compileTime.}

proc runnableExamples(body: untyped) {...}{.magic: "RunnableExamples".}

proc declared(x: untyped): bool {...}{.magic: "Defined", noSideEffect, compileTime.}

proc declaredInScope(x: untyped): bool {...}{.magic: "DefinedInScope", noSideEffect,
                                     compileTime.}

proc `addr`[T](x: var T): ptr T {...}{.magic: "Addr", noSideEffect.}

proc unsafeAddr[T](x: T): ptr T {...}{.magic: "Addr", noSideEffect.}

proc typeof(x: untyped; mode = typeOfIter): typedesc {...}{.magic: "TypeOf", noSideEffect,
    compileTime.}

proc internalNew[T](a: var ref T) {...}{.magic: "New", noSideEffect.}

proc new[T](a: var ref T; finalizer: proc (x: ref T) {...}{.nimcall.}) {...}{.magic: "NewFinalize",
    noSideEffect.}

proc wasMoved[T](obj: var T) {...}{.magic: "WasMoved", noSideEffect.}