GraphViz .dot file

Jump to D main()

.modulefilename

Used by:

• @property bool std.stdio.File.ByLine!(char, char).ByLine.empty()
• @property bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.empty()
• void std.stdio.File.ByLine!(char, char).ByLine.popFront()
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()
• ulong std.stdio.File.readln!(char).readln(ref char[], dchar)
• void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[])
• @property char[] std.stdio.File.ByLine!(char, char).ByLine.front()
• @property char[] std.stdio.File.ByLineImpl!(char, char).ByLineImpl.front()
• pure nothrow @safe void std.stdio.File.ByLine!(char, char).ByLine.__fieldPostBlit()
• void std.stdio.File.LockingTextWriter.put!(dchar).put(dchar)
• std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.byLine!(char, char).byLine(std.string.KeepTerminator, char)
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__fieldPostBlit()

.modulefilename22

Used by:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayload.MNgFNaNbNcNdNfZNgS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImpl
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.isInitialized.MxFNaNbNdNfZb
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit.MFNaNbNfZv
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv

.modulefilename43

Used by:

• pure nothrow @safe void std.array.popFront!(immutable(char)[]).popFront(ref immutable(char)[][])
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])
• std.array.Appender!(immutable(char)[][]).Appender.datainout(pure nothrow @property @trusted inout(immutable(char)[])[] function())
• pure nothrow ref @safe std.array.Appender!(immutable(char)[][]).Appender std.array.Appender!(immutable(char)[][]).Appender.__ctor(immutable(char)[][])
• pure @property @safe dchar std.array.back!(char).back(char[])
• pure nothrow ref @property @safe immutable(char)[] std.array.front!(immutable(char)[]).front(immutable(char)[][])

.modulefilename46

Used by:

• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)

.modulefilename63

Used by:

• pure nothrow @safe void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldPostBlit()

.str5

Used by:

• void core.demangle.Demangle.parseIntegerValue(char[], char)

TypeInfo_Aya.__init

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)

void gc.gc.GC.freeNoSync(void*)

Used by:

• void gc.gc.GC.free(void*)
• void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)

Uses:

• onInvalidMemoryOperationError

void gc.gc.GC.initialize()

Uses:

• gc.gc.GCMutex.__Class
• onOutOfMemoryError
• calloc@plt
• byte[72] gc.gc.GC.mutexStorage
• gc.gc.GCMutex gc.gc.GC.gcLock
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

void gc.gc.GC.removeRoot(void*)

Uses:

• memmove@plt
• gc.gc.GCMutex gc.gc.GC.gcLock

ulong gc.gc.GC.fullCollect()

Uses:

• ulong gc.gc.Gcx.fullcollect()
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

gc.gc.BlkInfo gc.gc.GC.queryNoSync(void*)

Uses:

• gc.gc.BlkInfo gc.gc.Gcx.getInfo(void*)

void gc.gc.GC.removeRange(void*)

Uses:

• memmove@plt
• gc.gc.GCMutex gc.gc.GC.gcLock

void* gc.gc.GC.addrOfNoSync(void*)

Uses:

• void* gc.gc.Gcx.findBase(void*)

ulong gc.gc.GC.extendNoSync(void*, ulong, ulong)

Used by:

• ulong gc.gc.GC.extend(void*, ulong, ulong)

Uses:

• memset@plt
• onInvalidMemoryOperationError

void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)

Used by:

• void* gc.gc.GC.calloc(ulong, uint, ulong*)
• void* gc.gc.GC.malloc(ulong, uint, ulong*)
• void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)

Uses:

• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)
• int gc.gc.Gcx.allocPage(ubyte)
• onOutOfMemoryError
• ulong gc.gc.Gcx.fullcollect()
• void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)
• onInvalidMemoryOperationError
• void gc.gc.Gcx.setBits(gc.gc.Pool*, ulong, uint)

byte[72] gc.gc.GC.mutexStorage

Used by:

• void gc.gc.GC.initialize()

ulong gc.gc.GC.sizeOfNoSync(void*)

Used by:

• ulong gc.gc.GC.sizeOf(void*)

void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)

Used by:

• void* gc.gc.GC.realloc(void*, ulong, uint, ulong*)

Uses:

• ulong gc.bits.GCBits.test(ulong)
• memset@plt
• onInvalidMemoryOperationError
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• void gc.gc.GC.freeNoSync(void*)
• void gc.gc.Gcx.setBits(gc.gc.Pool*, ulong, uint)
• memcpy@plt

void gc.gc.GC.getStatsNoSync(out gc.stats.GCStats)

Used by:

• void gc.gc.GC.getStats(out gc.stats.GCStats)

void gc.gc.GC.fullCollectNoStack()

Uses:

• ulong gc.gc.Gcx.fullcollect()
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

void gc.gc.GC.Dtor()

Uses:

• free@plt
• void gc.gc.Gcx.Dtor()

void gc.gc.GC.free(void*)

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock
• void gc.gc.GC.freeNoSync(void*)

void gc.gc.GC.check(void*)

Uses:

• gc.gc.GCMutex gc.gc.GC.gcLock

gc.gc.BlkInfo gc.gc.GC.query(void*)

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

void* gc.gc.GC.addrOf(void*)

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

void* gc.gc.GC.calloc(ulong, uint, ulong*)

Uses:

• memset@plt
• _d_eh_resume_unwind
• _d_eh_handle_collision
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• gc.gc.GCMutex gc.gc.GC.gcLock

void gc.gc.GC.enable()

Uses:

• gc.gc.GCMutex gc.gc.GC.gcLock

ulong gc.gc.GC.extend(void*, ulong, ulong)

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• ulong gc.gc.GC.extendNoSync(void*, ulong, ulong)
• gc.gc.GCMutex gc.gc.GC.gcLock

gc.gc.GCMutex gc.gc.GC.gcLock

Used by:

• uint gc.gc.GC.setAttr(void*, uint)
• void gc.gc.GC.enable()
• @property int delegate(int delegate(ref gc.gc.Range)) gc.gc.GC.rangeIter()
• void gc.gc.GC.free(void*)
• @property int delegate(int delegate(ref void*)) gc.gc.GC.rootIter()
• void gc.gc.GC.disable()
• uint gc.gc.GC.clrAttr(void*, uint)
• void gc.gc.GC.check(void*)
• ulong gc.gc.GC.fullCollect()
• void* gc.gc.GC.addrOf(void*)
• ulong gc.gc.GC.extend(void*, ulong, ulong)
• void gc.gc.GC.minimize()
• void gc.gc.GC.addRoot(void*)
• void gc.gc.GC.removeRoot(void*)
• void gc.gc.GC.addRange(void*, ulong)
• void* gc.gc.GC.malloc(ulong, uint, ulong*)
• ulong gc.gc.GC.reserve(ulong)
• void* gc.gc.GC.realloc(void*, ulong, uint, ulong*)
• ulong gc.gc.GC.sizeOf(void*)
• void gc.gc.GC.getStats(out gc.stats.GCStats)
• void gc.gc.GC.initialize()
• gc.gc.BlkInfo gc.gc.GC.query(void*)
• void gc.gc.GC.removeRange(void*)
• void gc.gc.GC.fullCollectNoStack()
• uint gc.gc.GC.getAttr(void*)
• void* gc.gc.GC.calloc(ulong, uint, ulong*)

void* gc.gc.GC.malloc(ulong, uint, ulong*)

Uses:

• memset@plt
• _d_eh_resume_unwind
• _d_eh_handle_collision
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• gc.gc.GCMutex gc.gc.GC.gcLock

ulong gc.gc.GC.sizeOf(void*)

Uses:

• ulong gc.gc.GC.sizeOfNoSync(void*)
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

gc.gc.GC.__Class

Used by:

• gc_init

void gc.gc.GC.addRoot(void*)

Uses:

• malloc@plt
• free@plt
• onOutOfMemoryError
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock
• memcpy@plt

uint gc.gc.GC.clrAttr(void*, uint)

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock
• uint gc.gc.GC.clrAttr(void*, uint).uint go()

uint gc.gc.GC.clrAttr(void*, uint).uint go()

Used by:

• uint gc.gc.GC.clrAttr(void*, uint)

Uses:

• ulong gc.bits.GCBits.test(ulong)

void gc.gc.GC.disable()

Uses:

• gc.gc.GCMutex gc.gc.GC.gcLock

uint gc.gc.GC.getAttr(void*)

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock
• uint gc.gc.GC.getAttr(void*).uint go()

uint gc.gc.GC.getAttr(void*).uint go()

Used by:

• uint gc.gc.GC.getAttr(void*)

Uses:

• ulong gc.bits.GCBits.test(ulong)

void* gc.gc.GC.realloc(void*, ulong, uint, ulong*)

Uses:

• memset@plt
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock
• void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)

ulong gc.gc.GC.reserve(ulong)

Uses:

• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)
• _d_eh_resume_unwind
• _d_eh_handle_collision
• onInvalidMemoryOperationError
• gc.gc.GCMutex gc.gc.GC.gcLock

uint gc.gc.GC.setAttr(void*, uint)

Uses:

• uint gc.gc.GC.setAttr(void*, uint).uint go()
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

uint gc.gc.GC.setAttr(void*, uint).uint go()

Used by:

• uint gc.gc.GC.setAttr(void*, uint)

Uses:

• ulong gc.bits.GCBits.test(ulong)
• void gc.gc.Gcx.setBits(gc.gc.Pool*, ulong, uint)

void gc.gc.GC.addRange(void*, ulong)

Uses:

• malloc@plt
• free@plt
• onOutOfMemoryError
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock
• memcpy@plt

void gc.gc.GC.getStats(out gc.stats.GCStats)

Uses:

• void gc.gc.GC.getStatsNoSync(out gc.stats.GCStats)
• gc.gc.GCMutex gc.gc.GC.gcLock

void gc.gc.GC.minimize()

Uses:

• void gc.gc.Gcx.minimize()
• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

@property int delegate(int delegate(ref void*)) gc.gc.GC.rootIter()

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

@property int delegate(int delegate(ref gc.gc.Range)) gc.gc.GC.rangeIter()

Uses:

• _d_eh_resume_unwind
• _d_eh_handle_collision
• gc.gc.GCMutex gc.gc.GC.gcLock

ulong gc.gc.Gcx.fullcollect()

Used by:

• void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)
• void gc.gc.GC.fullCollectNoStack()
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• ulong gc.gc.GC.fullCollect()

Uses:

• ulong* gc.bits.GCBits.base()
• pure nothrow @safe int core.bitop.bsf(ulong)
• thread_processGCMarks
• ulong gc.bits.GCBits.test(ulong)
• void gc.gc.Gcx.mark(void*, void*, int)
• onInvalidMemoryOperationError
• thread_suspendAll
• void gc.bits.GCBits.zero()
• void gc.bits.GCBits.set(ulong)
• void gc.bits.GCBits.copy(gc.bits.GCBits*)
• ulong gc.bits.GCBits.testClear(ulong)
• thread_scanAll
• thread_resumeAll
• rt_finalize2

void gc.gc.Gcx.Dtor()

Used by:

• void gc.gc.GC.Dtor()

Uses:

• free@plt
• void gc.gc.Pool.Dtor()

void gc.gc.Gcx.mark(void*, void*)

Uses:

• void gc.gc.Gcx.mark(void*, void*, int)

void gc.gc.Gcx.mark(void*, void*, int)

Used by:

• void gc.gc.Gcx.mark(void*, void*)
• ulong gc.gc.Gcx.fullcollect()

Uses:

• ulong gc.bits.GCBits.test(ulong)
• void gc.bits.GCBits.set(ulong)
• ulong gc.bits.GCBits.testSet(ulong)

gc.gc.BlkInfo gc.gc.Gcx.getInfo(void*)

Used by:

• gc.gc.BlkInfo gc.gc.GC.queryNoSync(void*)

Uses:

• ulong gc.bits.GCBits.test(ulong)

gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)

Used by:

• void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)
• ulong gc.gc.GC.reserve(ulong)
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)

Uses:

• void gc.gc.Pool.initialize(ulong, bool)
• free@plt
• void gc.gc.Pool.Dtor()
• calloc@plt
• realloc@plt
• memmove@plt

void gc.gc.Gcx.setBits(gc.gc.Pool*, ulong, uint)

Used by:

• uint gc.gc.GC.setAttr(void*, uint).uint go()
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)

Uses:

• void gc.bits.GCBits.alloc(ulong)

void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)

Used by:

• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)

Uses:

• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)
• ulong gc.gc.Gcx.fullcollect()
• void gc.gc.Gcx.minimize()
• memset@plt

void* gc.gc.Gcx.findBase(void*)

Used by:

• void* gc.gc.GC.addrOfNoSync(void*)

gc.gc.IsMarked gc.gc.Gcx.isMarked(void*)

Uses:

• ulong gc.bits.GCBits.test(ulong)

void gc.gc.Gcx.minimize()

Used by:

• void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)
• void gc.gc.GC.minimize()

Uses:

• free@plt
• void gc.gc.Pool.Dtor()

int gc.gc.Gcx.rootIter(int delegate(ref void*))

int gc.gc.Gcx.allocPage(ubyte)

Used by:

• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)

int gc.gc.Gcx.rangeIter(int delegate(ref gc.gc.Range))

void gc.gc.Pool.initialize(ulong, bool)

Used by:

• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)

Uses:

• malloc@plt
• void gc.bits.GCBits.alloc(ulong)
• onOutOfMemoryError
• memset@plt
• void* gc.os.os_mem_map(ulong)

void gc.gc.Pool.Dtor()

Used by:

• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)
• void gc.gc.Gcx.minimize()
• void gc.gc.Gcx.Dtor()

Uses:

• int gc.os.os_mem_unmap(void*, ulong)
• free@plt
• void gc.bits.GCBits.Dtor()

gc.gc.GCMutex gc.gc.GCMutex.__ctor()

Uses:

• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

gc.gc.GCMutex.__Class

Used by:

• void gc.gc.GC.initialize()

void* gc.os.os_mem_map(ulong)

Used by:

• void gc.gc.Pool.initialize(ulong, bool)

Uses:

• mmap64@plt

int gc.os.os_mem_unmap(void*, ulong)

Used by:

• void gc.gc.Pool.Dtor()

Uses:

• munmap@plt

void gc.bits.GCBits.set(ulong)

Used by:

• ulong gc.gc.Gcx.fullcollect()
• void gc.gc.Gcx.mark(void*, void*, int)

void gc.bits.GCBits.Dtor()

Used by:

• void gc.gc.Pool.Dtor()

Uses:

• free@plt

ulong* gc.bits.GCBits.base()

Used by:

• ulong gc.gc.Gcx.fullcollect()

void gc.bits.GCBits.copy(gc.bits.GCBits*)

Used by:

• ulong gc.gc.Gcx.fullcollect()

Uses:

• memcpy@plt

ulong gc.bits.GCBits.test(ulong)

Used by:

• uint gc.gc.GC.setAttr(void*, uint).uint go()
• gc.gc.IsMarked gc.gc.Gcx.isMarked(void*)
• ulong gc.gc.Gcx.fullcollect()
• void gc.gc.Gcx.mark(void*, void*, int)
• uint gc.gc.GC.getAttr(void*).uint go()
• uint gc.gc.GC.clrAttr(void*, uint).uint go()
• void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)
• gc.gc.BlkInfo gc.gc.Gcx.getInfo(void*)

void gc.bits.GCBits.zero()

Used by:

• ulong gc.gc.Gcx.fullcollect()

Uses:

• memset@plt

void gc.bits.GCBits.alloc(ulong)

Used by:

• void gc.gc.Pool.initialize(ulong, bool)
• void gc.gc.Gcx.setBits(gc.gc.Pool*, ulong, uint)

Uses:

• onOutOfMemoryError
• calloc@plt

ulong gc.bits.GCBits.testSet(ulong)

Used by:

• void gc.gc.Gcx.mark(void*, void*, int)

ulong gc.bits.GCBits.testClear(ulong)

Used by:

• ulong gc.gc.Gcx.fullcollect()

gc.gc.GC gc.proxy._gc

Used by:

• gc_qalloc
• gc_clrAttr
• gc_reserve
• gc_query
• gc_enable
• gc_extend
• gc_sizeOf
• gc_malloc
• gc_calloc
• gc_disable
• gc_setAttr
• gc_free
• gc_realloc
• gc_addrOf
• gc_removeRange
• gc_init
• gc_collect
• gc_minimize
• gc_term
• gc_getAttr
• gc_removeRoot
• gc_addRoot
• gc_addRange

gc.proxy.Proxy* gc.proxy.proxy

Used by:

• gc_qalloc
• gc_clrAttr
• gc_reserve
• gc_query
• gc_enable
• gc_extend
• gc_sizeOf
• gc_malloc
• gc_calloc
• gc_disable
• gc_setAttr
• gc_free
• gc_realloc
• gc_addrOf
• gc_removeRange
• gc_collect
• gc_minimize
• gc_getAttr
• gc_removeRoot
• gc_addRoot
• gc_addRange

gc.proxy.Proxy gc.proxy.pthis

Used by:

• gc_init

rt.util.container.Array!(rt.sections_linux.DSO*).Array rt.sections_linux._loadedDSOs

Used by:

• int rt.sections_linux.DSO.opApply(scope int delegate(ref rt.sections_linux.DSO))
• int rt.sections_linux.DSO.opApplyReverse(scope int delegate(ref rt.sections_linux.DSO))
• _d_dso_registry

void rt.sections_linux.finiSections()

Used by:

• rt_term

Uses:

• bool rt.sections_linux._isRuntimeInitialized

void rt.sections_linux.initSections()

Used by:

• rt_init

Uses:

• bool rt.sections_linux._isRuntimeInitialized

void rt.sections_linux.finiTLSRanges(rt.util.container.Array!(void[]).Array*)

Used by:

• void rt.tlsgc.destroy(rt.tlsgc.Data*)

Uses:

• void* rt.util.container.xrealloc(void*, ulong)
• memset@plt

rt.util.container.Array!(void[]).Array* rt.sections_linux.initTLSRanges()

Used by:

• rt.tlsgc.Data* rt.tlsgc.init()

void rt.sections_linux.scanTLSRanges(rt.util.container.Array!(void[]).Array*, scope void delegate(void*, void*))

Used by:

• void rt.tlsgc.scan(rt.tlsgc.Data*, scope void delegate(void*, void*))

nothrow bool rt.sections_linux.findDSOInfoForAddr(const(void*), core.sys.linux.link.dl_phdr_info*).extern (C) nothrow int callback(core.sys.linux.link.dl_phdr_info*, ulong, void*)

bool rt.sections_linux._isRuntimeInitialized

Used by:

• void rt.sections_linux.finiSections()
• void rt.sections_linux.initSections()
• _d_dso_registry

nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))

Used by:

• _d_dso_registry

Uses:

• strlen@plt
• _d_execBssEndAddr
• stderr@@GLIBC_2.2.5
• _d_execBssBegAddr
• dl_iterate_phdr@plt
• __progname_full@@GLIBC_2.2.5
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• fprintf@plt

rt.sections_linux.DSO.moduleGroupinout(ref @property inout(rt.minfo.ModuleGroup) function())

Used by:

• extern (C) void rt.minfo.rt_moduleTlsCtor().int __foreachbody1(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody1(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleCtor().int __foreachbody1(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleTlsDtor().int __foreachbody1(ref rt.sections_linux.DSO)

int rt.sections_linux.DSO.opApplyReverse(scope int delegate(ref rt.sections_linux.DSO))

Used by:

• rt_moduleDtor
• rt_moduleTlsDtor

Uses:

• rt.util.container.Array!(rt.sections_linux.DSO*).Array rt.sections_linux._loadedDSOs

rt.sections_linux.DSO.modulesinout(@property inout(object.ModuleInfo*)[] function())

Used by:

• int rt.minfo.moduleinfos_apply(scope int delegate(ref object.ModuleInfo*)).int __foreachbody2(ref rt.sections_linux.DSO)

Uses:

• rt.minfo.ModuleGroup.modulesinout(@property inout(object.ModuleInfo*)[] function())

int rt.sections_linux.DSO.opApply(scope int delegate(ref rt.sections_linux.DSO))

Used by:

• int rt.minfo.moduleinfos_apply(scope int delegate(ref object.ModuleInfo*))
• rt_moduleCtor
• void rt.memory.initStaticDataGC()
• rt_moduleTlsCtor

Uses:

• rt.util.container.Array!(rt.sections_linux.DSO*).Array rt.sections_linux._loadedDSOs

rt.sections_linux.DSO.gcRangesinout(@property inout(void[])[] function())

Used by:

• void rt.memory.initStaticDataGC().int __foreachbody1(ref rt.sections_linux.DSO)

dchar rt.util.utf.decode(const(char[]), ref ulong)

Used by:

• _aApplycd1

Uses:

• onUnicodeError

pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

Used by:

• const(pure nothrow @safe ulong function(const(void*))) object.TypeInfo_Struct.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_double.TypeInfo_d.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_real.TypeInfo_e.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ashort.TypeInfo_As.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_ulong.TypeInfo_m.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Along.TypeInfo_Al.getHash
• const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_Array.getHash
• _aaGetHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_cdouble.TypeInfo_r.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Aint.TypeInfo_Ai.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_long.TypeInfo_l.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_cfloat.TypeInfo_q.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ag.getHash
• const(nothrow @trusted ulong function()) object.TypeInfo.toHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_creal.TypeInfo_c.getHash

pure nothrow @trusted int rt.util.string.dstrcmp(const(char[]), const(char[]))

Used by:

• int object.TypeInfo.opCmp(Object)
• const(int function(const(void*), const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ah.compare

Uses:

• memcmp@plt

void* rt.util.container.xrealloc(void*, ulong)

Used by:

• void rt.sections_linux.finiTLSRanges(rt.util.container.Array!(void[]).Array*)
• _d_dso_registry

Uses:

• free@plt
• onOutOfMemoryError
• realloc@plt

void rt.minfo.ModuleGroup.runTlsCtors()

Used by:

• _d_dso_registry

Uses:

• pure nothrow @property void function()* object.ModuleInfo.tlsctor()

void rt.minfo.ModuleGroup.runTlsDtors()

Used by:

• _d_dso_registry

Uses:

• pure nothrow @property void function()* object.ModuleInfo.tlsdtor()

ref rt.minfo.ModuleGroup rt.minfo.ModuleGroup.__ctor(object.ModuleInfo*[])

Used by:

• _d_dso_registry

rt.minfo.ModuleGroup.modulesinout(@property inout(object.ModuleInfo*)[] function())

Used by:

• _d_dso_registry
• rt.sections_linux.DSO.modulesinout(@property inout(object.ModuleInfo*)[] function())

void rt.minfo.ModuleGroup.runCtors()

Used by:

• extern (C) void rt.minfo.rt_moduleCtor().int __foreachbody1(ref rt.sections_linux.DSO)
• _d_dso_registry

Uses:

• pure nothrow @property void function()* object.ModuleInfo.ictor()
• pure nothrow @property uint object.ModuleInfo.flags()
• pure nothrow @property void object.ModuleInfo.flags(uint)
• pure nothrow @property void function()* object.ModuleInfo.ctor()

void rt.minfo.ModuleGroup.runDtors()

Used by:

• _d_dso_registry

Uses:

• pure nothrow @property void function()* object.ModuleInfo.dtor()
• pure nothrow @property uint object.ModuleInfo.flags()
• pure nothrow @property void object.ModuleInfo.flags(uint)

void rt.minfo.ModuleGroup.sortCtors()

Used by:

• extern (C) void rt.minfo.rt_moduleCtor().int __foreachbody1(ref rt.sections_linux.DSO)
• _d_dso_registry

Uses:

• free@plt
• _d_eh_resume_unwind
• calloc@plt
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)

void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)

Used by:

• void rt.minfo.ModuleGroup.sortCtors()

Uses:

• malloc@plt
• pure nothrow @property object.ModuleInfo*[] object.ModuleInfo.importedModules()
• free@plt
• _d_throw_exception
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• pure nothrow @property uint object.ModuleInfo.flags()
• pure nothrow @property void object.ModuleInfo.flags(uint)
• _d_newclass
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• _d_arrayappendT
• Exception.__init

extern (C) void rt.minfo.rt_moduleCtor().int __foreachbody1(ref rt.sections_linux.DSO)

Uses:

• rt.sections_linux.DSO.moduleGroupinout(ref @property inout(rt.minfo.ModuleGroup) function())
• void rt.minfo.ModuleGroup.sortCtors()
• void rt.minfo.ModuleGroup.runCtors()

extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody1(ref rt.sections_linux.DSO)

Uses:

• pure nothrow @property void function()* object.ModuleInfo.dtor()
• free@plt
• rt.sections_linux.DSO.moduleGroupinout(ref @property inout(rt.minfo.ModuleGroup) function())
• pure nothrow @property uint object.ModuleInfo.flags()
• pure nothrow @property void object.ModuleInfo.flags(uint)

extern (C) void rt.minfo.rt_moduleTlsCtor().int __foreachbody1(ref rt.sections_linux.DSO)

Uses:

• rt.sections_linux.DSO.moduleGroupinout(ref @property inout(rt.minfo.ModuleGroup) function())
• pure nothrow @property void function()* object.ModuleInfo.tlsctor()

extern (C) void rt.minfo.rt_moduleTlsDtor().int __foreachbody1(ref rt.sections_linux.DSO)

Uses:

• rt.sections_linux.DSO.moduleGroupinout(ref @property inout(rt.minfo.ModuleGroup) function())
• pure nothrow @property void function()* object.ModuleInfo.tlsdtor()

int rt.minfo.moduleinfos_apply(scope int delegate(ref object.ModuleInfo*))

Used by:

• int object.ModuleInfo.opApply(scope int delegate(ref object.ModuleInfo*))

Uses:

• int rt.sections_linux.DSO.opApply(scope int delegate(ref rt.sections_linux.DSO))

int rt.minfo.moduleinfos_apply(scope int delegate(ref object.ModuleInfo*)).int __foreachbody2(ref rt.sections_linux.DSO)

Uses:

• rt.sections_linux.DSO.modulesinout(@property inout(object.ModuleInfo*)[] function())

extern (C) void[] rt.qsort._adSort(void[], TypeInfo).extern (C) int cmp(const(void*), const(void*), void*)

void rt.tlsgc.processGCMarks(rt.tlsgc.Data*, scope int delegate(void*))

Used by:

• thread_processGCMarks

Uses:

• void rt.lifetime.processGCMarks(rt.lifetime.BlkInfo*, scope int delegate(void*))

rt.tlsgc.Data* rt.tlsgc.init()

Used by:

• thread_attachThis

Uses:

• malloc@plt
• rt.util.container.Array!(void[]).Array* rt.sections_linux.initTLSRanges()

void rt.tlsgc.scan(rt.tlsgc.Data*, scope void delegate(void*, void*))

Used by:

• void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*)

Uses:

• void rt.sections_linux.scanTLSRanges(rt.util.container.Array!(void[]).Array*, scope void delegate(void*, void*))

void rt.tlsgc.destroy(rt.tlsgc.Data*)

Used by:

• void core.thread.Thread.__dtor()

Uses:

• void rt.sections_linux.finiTLSRanges(rt.util.container.Array!(void[]).Array*)
• free@plt

shared(ulong) rt.dmain2._initCount

Used by:

• rt_init
• rt_term

void rt.dmain2.printThrowable(object.Throwable)

Used by:

• rt_init
• rt_term
• _d_run_main

Uses:

• stderr@@GLIBC_2.2.5
• _d_dynamic_cast
• fprintf@plt

void rt.dmain2.printThrowable(object.Throwable).nothrow void sink(const(char[]))

Uses:

• stderr@@GLIBC_2.2.5
• fprintf@plt

rt.dmain2.CArgs rt.dmain2._cArgs

Used by:

• _d_run_main

immutable(char)[][] rt.dmain2._d_args

Used by:

• _d_run_main

void rt.memory.initStaticDataGC()

Used by:

• rt_init

Uses:

• int rt.sections_linux.DSO.opApply(scope int delegate(ref rt.sections_linux.DSO))

void rt.memory.initStaticDataGC().int __foreachbody1(ref rt.sections_linux.DSO)

Uses:

• nothrow void core.memory.GC.addRange(const(void*), ulong)
• rt.sections_linux.DSO.gcRangesinout(@property inout(void[])[] function())

void rt.lifetime._staticDtor1()

Uses:

• free@plt

bool function(Object)* rt.lifetime.collectHandler

Used by:

• rt_finalize2

void rt.lifetime.processGCMarks(rt.lifetime.BlkInfo*, scope int delegate(void*))

Used by:

• void rt.tlsgc.processGCMarks(rt.tlsgc.Data*, scope int delegate(void*))

bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)

Used by:

• _d_arraysetlengthiT
• _d_arrayappendcTX
• _d_arraysetlengthT

Uses:

• _d_monitorenter
• _d_eh_resume_unwind
• _d_eh_handle_collision
• _d_monitorexit

int rt.monitor_.inited

Used by:

• _STI_monitor_staticctor
• _STD_monitor_staticdtor

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_cdouble.TypeInfo_r.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_cdouble.TypeInfo_r.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_cdouble.TypeInfo_r.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_cdouble.TypeInfo_r.equals

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_cdouble.TypeInfo_r.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_cdouble.TypeInfo_r.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_cdouble.TypeInfo_r.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

const(pure nothrow @trusted int function(out TypeInfo, out TypeInfo)) rt.typeinfo.ti_cdouble.TypeInfo_r.argTypes

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_cdouble.TypeInfo_r.toString

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_idouble.TypeInfo_p.toString

rt.typeinfo.ti_Ag.TypeInfo_Aa.nextinout(pure nothrow @property inout(TypeInfo) function())

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Aa.getHash

const(immutable(char)[] function()) rt.typeinfo.ti_Ag.TypeInfo_Aa.toString

rt.typeinfo.ti_Ag.TypeInfo_Ab.nextinout(pure nothrow @property inout(TypeInfo) function())

const(immutable(char)[] function()) rt.typeinfo.ti_Ag.TypeInfo_Ab.toString

rt.typeinfo.ti_Ag.TypeInfo_Ag.nextinout(pure nothrow @property inout(TypeInfo) function())

const(bool function(const(void*), const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ag.equals

Uses:

• memcmp@plt

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ag.compare

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ag.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

bool rt.typeinfo.ti_Ag.TypeInfo_Ag.opEquals(Object)

Uses:

• bool object.TypeInfo.opEquals(Object)

const(immutable(char)[] function()) rt.typeinfo.ti_Ag.TypeInfo_Ag.toString

rt.typeinfo.ti_Ag.TypeInfo_Ah.nextinout(pure nothrow @property inout(TypeInfo) function())

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ah.compare

Uses:

• pure nothrow @trusted int rt.util.string.dstrcmp(const(char[]), const(char[]))

const(immutable(char)[] function()) rt.typeinfo.ti_Ag.TypeInfo_Ah.toString

rt.typeinfo.ti_Ag.TypeInfo_Av.nextinout(pure nothrow @property inout(TypeInfo) function())

const(immutable(char)[] function()) rt.typeinfo.ti_Ag.TypeInfo_Av.toString

rt.typeinfo.ti_Ag.TypeInfo_Axa.nextinout(pure nothrow @property inout(TypeInfo) function())

const(immutable(char)[] function()) rt.typeinfo.ti_Ag.TypeInfo_Axa.toString

rt.typeinfo.ti_Ag.TypeInfo_Aya.nextinout(pure nothrow @property inout(TypeInfo) function())

const(immutable(char)[] function()) rt.typeinfo.ti_Ag.TypeInfo_Aya.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_int.TypeInfo_i.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_int.TypeInfo_i.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_int.TypeInfo_i.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_int.TypeInfo_i.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_int.TypeInfo_i.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_int.TypeInfo_i.toString

rt.typeinfo.ti_Aint.TypeInfo_Ai.nextinout(pure nothrow @property inout(TypeInfo) function())

const(bool function(const(void*), const(void*))) rt.typeinfo.ti_Aint.TypeInfo_Ai.equals

Uses:

• memcmp@plt

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Aint.TypeInfo_Ai.compare

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Aint.TypeInfo_Ai.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

bool rt.typeinfo.ti_Aint.TypeInfo_Ai.opEquals(Object)

Uses:

• bool object.TypeInfo.opEquals(Object)

const(immutable(char)[] function()) rt.typeinfo.ti_Aint.TypeInfo_Ai.toString

rt.typeinfo.ti_Aint.TypeInfo_Ak.nextinout(pure nothrow @property inout(TypeInfo) function())

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Aint.TypeInfo_Ak.compare

const(immutable(char)[] function()) rt.typeinfo.ti_Aint.TypeInfo_Ak.toString

rt.typeinfo.ti_Aint.TypeInfo_Aw.nextinout(pure nothrow @property inout(TypeInfo) function())

const(immutable(char)[] function()) rt.typeinfo.ti_Aint.TypeInfo_Aw.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_byte.TypeInfo_g.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_byte.TypeInfo_g.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_byte.TypeInfo_g.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_byte.TypeInfo_g.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_byte.TypeInfo_g.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_byte.TypeInfo_g.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_char.TypeInfo_a.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_char.TypeInfo_a.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_char.TypeInfo_a.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_char.TypeInfo_a.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_char.TypeInfo_a.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_char.TypeInfo_a.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_char.TypeInfo_a.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_long.TypeInfo_l.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_long.TypeInfo_l.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_long.TypeInfo_l.equals

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_long.TypeInfo_l.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_long.TypeInfo_l.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_long.TypeInfo_l.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_long.TypeInfo_l.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_real.TypeInfo_e.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_real.TypeInfo_e.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_real.TypeInfo_e.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_real.TypeInfo_e.equals

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_real.TypeInfo_e.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_real.TypeInfo_e.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_real.TypeInfo_e.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_real.TypeInfo_e.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_uint.TypeInfo_k.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_uint.TypeInfo_k.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_uint.TypeInfo_k.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_uint.TypeInfo_k.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_uint.TypeInfo_k.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_uint.TypeInfo_k.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_void.TypeInfo_v.swap

const(pure nothrow @property @trusted uint function()) rt.typeinfo.ti_void.TypeInfo_v.flags

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_void.TypeInfo_v.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_void.TypeInfo_v.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_void.TypeInfo_v.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_void.TypeInfo_v.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_void.TypeInfo_v.toString

rt.typeinfo.ti_Along.TypeInfo_Al.nextinout(pure nothrow @property inout(TypeInfo) function())

const(bool function(const(void*), const(void*))) rt.typeinfo.ti_Along.TypeInfo_Al.equals

Uses:

• memcmp@plt

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Along.TypeInfo_Al.compare

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Along.TypeInfo_Al.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

bool rt.typeinfo.ti_Along.TypeInfo_Al.opEquals(Object)

Uses:

• bool object.TypeInfo.opEquals(Object)

const(immutable(char)[] function()) rt.typeinfo.ti_Along.TypeInfo_Al.toString

rt.typeinfo.ti_Along.TypeInfo_Am.nextinout(pure nothrow @property inout(TypeInfo) function())

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Along.TypeInfo_Am.compare

const(immutable(char)[] function()) rt.typeinfo.ti_Along.TypeInfo_Am.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_creal.TypeInfo_c.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_creal.TypeInfo_c.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_creal.TypeInfo_c.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_creal.TypeInfo_c.equals

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_creal.TypeInfo_c.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_creal.TypeInfo_c.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_creal.TypeInfo_c.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

const(pure nothrow @trusted int function(out TypeInfo, out TypeInfo)) rt.typeinfo.ti_creal.TypeInfo_c.argTypes

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_creal.TypeInfo_c.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_dchar.TypeInfo_w.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_dchar.TypeInfo_w.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_dchar.TypeInfo_w.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_dchar.TypeInfo_w.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_dchar.TypeInfo_w.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_dchar.TypeInfo_w.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_dchar.TypeInfo_w.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_float.TypeInfo_f.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_float.TypeInfo_f.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_float.TypeInfo_f.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_float.TypeInfo_f.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_float.TypeInfo_f.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_float.TypeInfo_f.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_float.TypeInfo_f.toString

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_ireal.TypeInfo_j.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_short.TypeInfo_s.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_short.TypeInfo_s.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_short.TypeInfo_s.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_short.TypeInfo_s.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_short.TypeInfo_s.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_short.TypeInfo_s.toString

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_ubyte.TypeInfo_b.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_ubyte.TypeInfo_h.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_ubyte.TypeInfo_h.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_ubyte.TypeInfo_h.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_ubyte.TypeInfo_h.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_ubyte.TypeInfo_h.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_ubyte.TypeInfo_h.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_ulong.TypeInfo_m.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_ulong.TypeInfo_m.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_ulong.TypeInfo_m.equals

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_ulong.TypeInfo_m.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_ulong.TypeInfo_m.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_ulong.TypeInfo_m.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_ulong.TypeInfo_m.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_wchar.TypeInfo_u.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_wchar.TypeInfo_u.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_wchar.TypeInfo_u.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_wchar.TypeInfo_u.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_wchar.TypeInfo_u.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_wchar.TypeInfo_u.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_wchar.TypeInfo_u.toString

rt.typeinfo.ti_Ashort.TypeInfo_As.nextinout(pure nothrow @property inout(TypeInfo) function())

const(bool function(const(void*), const(void*))) rt.typeinfo.ti_Ashort.TypeInfo_As.equals

Uses:

• memcmp@plt

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Ashort.TypeInfo_As.compare

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ashort.TypeInfo_As.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

bool rt.typeinfo.ti_Ashort.TypeInfo_As.opEquals(Object)

Uses:

• bool object.TypeInfo.opEquals(Object)

const(immutable(char)[] function()) rt.typeinfo.ti_Ashort.TypeInfo_As.toString

rt.typeinfo.ti_Ashort.TypeInfo_At.nextinout(pure nothrow @property inout(TypeInfo) function())

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Ashort.TypeInfo_At.compare

const(immutable(char)[] function()) rt.typeinfo.ti_Ashort.TypeInfo_At.toString

rt.typeinfo.ti_Ashort.TypeInfo_Au.nextinout(pure nothrow @property inout(TypeInfo) function())

const(immutable(char)[] function()) rt.typeinfo.ti_Ashort.TypeInfo_Au.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_cfloat.TypeInfo_q.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_cfloat.TypeInfo_q.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_cfloat.TypeInfo_q.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_cfloat.TypeInfo_q.equals

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_cfloat.TypeInfo_q.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_cfloat.TypeInfo_q.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_cfloat.TypeInfo_q.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

const(pure nothrow @trusted int function(out TypeInfo, out TypeInfo)) rt.typeinfo.ti_cfloat.TypeInfo_q.argTypes

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_cfloat.TypeInfo_q.toString

const(pure nothrow @trusted const(void)[] function()) rt.typeinfo.ti_double.TypeInfo_d.init

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_double.TypeInfo_d.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_double.TypeInfo_d.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_double.TypeInfo_d.equals

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_double.TypeInfo_d.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_double.TypeInfo_d.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_double.TypeInfo_d.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_double.TypeInfo_d.toString

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_ifloat.TypeInfo_o.toString

const(pure nothrow @trusted void function(void*, void*)) rt.typeinfo.ti_ushort.TypeInfo_t.swap

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_ushort.TypeInfo_t.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_ushort.TypeInfo_t.equals

const(pure nothrow @trusted int function(const(void*), const(void*))) rt.typeinfo.ti_ushort.TypeInfo_t.compare

const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_ushort.TypeInfo_t.getHash

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_ushort.TypeInfo_t.toString

rt.critical_.D_CRITICAL_SECTION* rt.critical_.dcs_list

Used by:

• _STD_critical_term
• _STI_critical_init

ubyte* ldc.eh.get_sleb128(ubyte*, ref long)

Used by:

• _d_eh_personality
• ubyte* ldc.eh.get_encoded_value(ubyte*, ref ulong, ubyte, void*)

Uses:

• fatalerror

bool ldc.eh._d_exception.__xopEquals(ref const(ldc.eh._d_exception), ref const(ldc.eh._d_exception))

Uses:

• memcmp@plt
• bool object.opEquals(const(Object), const(Object))

ubyte* ldc.eh.get_encoded_value(ubyte*, ref ulong, ubyte, void*)

Used by:

• _d_eh_personality

Uses:

• fatalerror
• _Unwind_GetDataRelBase@plt
• _Unwind_GetTextRelBase@plt
• ubyte* ldc.eh.get_sleb128(ubyte*, ref long)
• _Unwind_GetRegionStart@plt

char[8] ldc.eh._d_exception_class

Used by:

• _d_throw_exception

ulong ldc.eh.get_size_of_encoded_value(ubyte)

Uses:

• fatalerror

void ldc.eh._d_getLanguageSpecificTables(void*, ref ubyte*, ref ubyte*, ref ubyte*, ref ubyte)

Used by:

• _d_eh_personality

Uses:

• fatalerror
• _Unwind_GetLanguageSpecificData@plt

pure nothrow @safe bool std.functional.binaryFun!("a == b").binaryFun!(dchar, char).binaryFun(dchar, char)

Used by:

• pure @safe bool std.algorithm.endsWith!("a == b", char[], char).endsWith(char[], char)

void std.concurrency.MessageBox.put(ref std.concurrency.Message)

Used by:

• void std.concurrency._staticDtor1()

Uses:

• _d_monitorenter
• _d_allocmemoryT
• std.concurrency.List.TS3std11concurrency7MessageZ.List.Node.__init
• _d_eh_resume_unwind
• _d_eh_handle_collision
• _d_monitorexit
• @property std.concurrency.Tid std.concurrency.thisTid()

void std.concurrency.MessageBox.close()

Used by:

• void std.concurrency._staticDtor1()

Uses:

• _d_monitorenter
• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)
• _d_monitorexit
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)

Used by:

• void std.concurrency.MessageBox.close()

Uses:

• _aaDelX
• @trusted std.variant.VariantException std.variant.VariantException.__ctor(TypeInfo, TypeInfo)
• _d_throw_exception
• bool object.opEquals(Object, Object)
• _d_newclass
• std.variant.VariantException.__init
• const(@property @trusted TypeInfo function()) std.variant.VariantN!(32uL).VariantN.type

std.concurrency.MessageBox std.concurrency.MessageBox.__ctor()

Uses:

• core.sync.mutex.Mutex.__init
• core.sync.condition.Condition.__init
• _d_newclass
• core.sync.condition.Condition core.sync.condition.Condition.__ctor(core.sync.mutex.Mutex)
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

immutable(char)[][][std.concurrency.Tid] std.concurrency.namesByTid

Used by:

• void std.concurrency._staticDtor3()

void std.concurrency._staticDtor1()

Used by:

• std.concurrency.__dtor

Uses:

• void std.concurrency.MessageBox.close()
• void std.concurrency.MessageBox.put(ref std.concurrency.Message)
• @property std.concurrency.Tid std.concurrency.thisTid()
• bool object.opEquals(Object, Object)
• _aaKeys
• std.variant.VariantN.Vm32Z.VariantN.__init

void std.concurrency._staticDtor3()

Used by:

• std.concurrency.__dtor

Uses:

• core.sync.mutex.Mutex std.concurrency.registryLock
• _d_monitorenter
• _aaInX
• _aaDelX
• @property std.concurrency.Tid std.concurrency.thisTid()
• _d_monitorexit
• immutable(char)[][][std.concurrency.Tid] std.concurrency.namesByTid
• std.concurrency.Tid[immutable(char)[]] std.concurrency.tidByName

core.sync.mutex.Mutex std.concurrency.registryLock

Used by:

• void std.concurrency._staticDtor3()
• void std.concurrency._sharedStaticCtor2()

void std.concurrency._sharedStaticCtor2()

Uses:

• core.sync.mutex.Mutex std.concurrency.registryLock
• core.sync.mutex.Mutex.__init
• _d_newclass
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

bool std.concurrency.List!(std.concurrency.Message).List.Node.__xopEquals(ref const(std.concurrency.List!(std.concurrency.Message).List.Node), ref const(std.concurrency.List!(std.concurrency.Message).List.Node))

Uses:

• const(@trusted bool function(ref const(std.variant.VariantN!(32uL).VariantN))) std.variant.VariantN!(32uL).VariantN.opEquals!(const(std.variant.VariantN!(32uL).VariantN)).opEquals

std.concurrency.List.TS3std11concurrency7MessageZ.List.Node.__init

Used by:

• void std.concurrency.MessageBox.put(ref std.concurrency.Message)

bool std.concurrency.Tid.__xopEquals(ref const(std.concurrency.Tid), ref const(std.concurrency.Tid))

Uses:

• bool object.opEquals(const(Object), const(Object))

std.concurrency.__dtor

Uses:

• void std.concurrency._staticDtor3()
• void std.concurrency._staticDtor1()

@property std.concurrency.Tid std.concurrency.thisTid()

Used by:

• void std.concurrency._staticDtor3()
• void std.concurrency.MessageBox.put(ref std.concurrency.Message)
• void std.concurrency._staticDtor1()

Uses:

• core.sync.mutex.Mutex.__init
• core.sync.condition.Condition.__init
• _d_newclass
• core.sync.condition.Condition core.sync.condition.Condition.__ctor(core.sync.mutex.Mutex)
• memcpy@plt
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

std.concurrency.Tid[immutable(char)[]] std.concurrency.tidByName

Used by:

• void std.concurrency._staticDtor3()

pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)

Uses:

• _d_array_bounds
• _d_array_slice_copy

pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

Used by:

• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])

Uses:

• _d_allocmemoryT
• std.format.FormatException.__init
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_arraysetcapacity
• _d_arraycatT
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

std.utf.UTFException.__init

Used by:

• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])
• pure @safe void std.utf.encode(ref char[], dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)

immutable(char)[] std.utf.UTFException.toString()

Uses:

• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• immutable(char)[] object.Throwable.toString()
• _d_arrayappendT

pure nothrow @safe bool std.utf.isValidDchar(dchar)

Used by:

• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)

pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)

Used by:

• pure @property @safe dchar std.array.back!(char).back(char[])

Uses:

• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• _d_assert
• _d_array_bounds
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• _d_assert_msg
• .modulefilename46

pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)

Used by:

• pure @property @safe dchar std.array.back!(char).back(char[])

Uses:

• _d_throw_exception
• _d_array_bounds
• _d_assert_msg
• _d_newclass
• .modulefilename46
• memcpy@plt
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)

Used by:

• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)

Uses:

• _d_assert
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException outOfBounds()
• _d_throw_exception
• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• _d_newarrayvT
• .modulefilename46
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException invalidUTF()

pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException invalidUTF()

Used by:

• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)

Uses:

• _d_array_bounds
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])

pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException outOfBounds()

Used by:

• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)

Uses:

• _d_array_bounds
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])

pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])

Used by:

• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException outOfBounds()
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException invalidUTF()

Uses:

• _d_array_bounds
• _d_newclass
• std.utf.UTFException.__init
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])

Uses:

• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• _d_throw_exception
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])

pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])

Used by:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

Uses:

• _d_array_bounds
• _d_newclass
• std.utf.UTFException.__init
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

pure @safe void std.utf.encode(ref char[], dchar)

Used by:

• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)

Uses:

• _d_throw_exception
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_arrayappendcTX
• _d_newclass
• std.utf.UTFException.__init
• _d_arrayappendT

pure @safe ulong std.utf.encode(ref char[4], dchar)

Used by:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• _d_throw_exception
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• std.utf.UTFException.__init

pure nothrow @safe char[] std.utf.toUTF8(out char[4], dchar)

Used by:

• void std.stdio.File.LockingTextWriter.put!(dchar).put(dchar)

std.stdio.File.ByLineImpl!(char, char).ByLineImpl* std.conv.emplace!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl, std.stdio.File, std.string.KeepTerminator, char).emplace(std.stdio.File.ByLineImpl!(char, char).ByLineImpl*, ref std.stdio.File, ref std.string.KeepTerminator, ref char)

Used by:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.initialize.MFKS3std5stdio4FileKE3std6string14KeepTerminatorKaZv

Uses:

• ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• pure nothrow @trusted std.stdio.File.ByLineImpl!(char, char).ByLineImpl* std.conv.emplaceInitializer!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl).emplaceInitializer(std.stdio.File.ByLineImpl!(char, char).ByLineImpl*)
• const(void function(ref const(std.stdio.File))) std.stdio.File.__cpctor

pure nothrow @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(immutable(char)[]).to(immutable(char)[])

Used by:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])

pure immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)

Used by:

• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.stdName
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)

Uses:

• strlen@plt
• _adDupT

pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong).to(ulong)

Used by:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])

Uses:

• _adDupT

pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])

Uses:

• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

std.conv.ConvException.__init

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])

pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()

Uses:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure nothrow @safe int core.bitop.bsr(ulong)
• _d_throw_exception
• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass
• std.conv.ConvException.__init
• std.conv.ConvOverflowException.__init
• _d_arrayappendT
• pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()

Uses:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure nothrow @safe int core.bitop.bsr(ulong)
• _d_throw_exception
• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass
• std.conv.ConvException.__init
• std.conv.ConvOverflowException.__init
• _d_arrayappendT
• pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

pure @safe immutable(char)[] std.conv.text!(immutable(char)[], const(char)[]).text(immutable(char)[], const(char)[])

Used by:

• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int).pure @safe immutable(char)[] __dgliteral7()

Uses:

• _adDupT
• _d_arrayappendT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()

Uses:

• _d_newclass
• std.conv.ConvException.__init
• pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

Uses:

• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

std.conv.ConvOverflowException.__init

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])

Used by:

• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

Uses:

• _d_arrayappendT

pure @safe immutable(char)[] std.conv.text!(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).text(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])

Used by:

• pure @safe immutable(char)[] std.string.format!(char, int).format(const(char[]), int).pure @safe object.Throwable __dgliteral4()

Uses:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])

pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])

Used by:

• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])

Uses:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• _d_allocmemoryT
• std.format.FormatSpec.TaZ.FormatSpec.__init
• _d_arraysetcapacity
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)
• _d_arrayappendT

pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])

Used by:

• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• pure @safe immutable(char)[] std.conv.text!(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).text(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

Uses:

• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong).to(ulong)
• pure nothrow @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(immutable(char)[]).to(immutable(char)[])
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _adDupT
• _d_arrayappendT

pure nothrow @trusted std.stdio.File.ByLineImpl!(char, char).ByLineImpl* std.conv.emplaceInitializer!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl).emplaceInitializer(std.stdio.File.ByLineImpl!(char, char).ByLineImpl*)

Used by:

• std.stdio.File.ByLineImpl!(char, char).ByLineImpl* std.conv.emplace!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl, std.stdio.File, std.string.KeepTerminator, char).emplace(std.stdio.File.ByLineImpl!(char, char).ByLineImpl*, ref std.stdio.File, ref std.string.KeepTerminator, ref char)

Uses:

• memcpy@plt

pure nothrow @safe int std.conv.to!(int).to!(int).to(int)

Used by:

• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)

immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Used by:

• _Dmain

Uses:

• const(pure nothrow void function(ref const(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult))) std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__cpctor
• @property bool std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.empty()
• void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.popFront()
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])
• _d_eh_handle_collision
• void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldDtor()
• _d_eh_resume_unwind
• std.array.Appender!(immutable(char)[][]).Appender.datainout(pure nothrow @property @trusted inout(immutable(char)[])[] function())
• pure nothrow @safe std.array.Appender!(immutable(char)[][]).Appender std.array.appender!(immutable(char)[][], immutable(char)[]).appender()
• @property immutable(char)[] std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.front()

pure @property @safe dchar std.array.back!(char).back(char[])

Used by:

• pure @safe bool std.algorithm.endsWith!("a == b", char[], char).endsWith(char[], char)

Uses:

• .modulefilename43
• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)
• _d_assert_msg

pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))

Used by:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()
• pure @safe bool std.algorithm.endsWith!("a == b", char[], char).endsWith(char[], char)

pure nothrow @property @safe bool std.array.empty!(immutable(char)[]).empty(const(immutable(char)[][]))

Used by:

• void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[][]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[][])

pure nothrow ref @property @safe immutable(char)[] std.array.front!(immutable(char)[]).front(immutable(char)[][])

Used by:

• void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[][]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[][])

Uses:

• .modulefilename43
• _d_array_bounds
• _d_assert_msg

pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)

Used by:

• pure nothrow @safe void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[]).put(ref std.array.Appender!(immutable(char)[]).Appender, immutable(char)[])
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure nothrow @safe void std.format.formatUnsigned!(std.array.Appender!(immutable(char)[]).Appender, char).formatUnsigned(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec, uint, bool)

Uses:

• _d_allocmemoryT
• TypeInfo_Aya.__init
• pure nothrow core.memory.BlkInfo_ core.memory.GC.qalloc(ulong, uint)
• pure nothrow @safe ulong std.array.appenderNewCapacity!(1uL).appenderNewCapacity(ulong, ulong)
• pure nothrow ulong core.memory.GC.extend(void*, ulong, ulong)
• memcpy@plt

bool std.array.Appender!(immutable(char)[]).Appender.Data.__xopEquals(ref const(std.array.Appender!(immutable(char)[]).Appender.Data), ref const(std.array.Appender!(immutable(char)[]).Appender.Data))

Uses:

• _adEq2

pure nothrow @safe void std.array.popFront!(immutable(char)[]).popFront(ref immutable(char)[][])

Used by:

• void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[][]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[][])

Uses:

• .modulefilename43
• _d_array_bounds
• _d_assert_msg

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• .modulefilename43
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)
• _d_array_bounds
• _d_assert_msg
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[]).pure nothrow @trusted immutable(char)[][] bigDataFun()

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[]).pure nothrow @trusted immutable(char)[][] bigDataFun()

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])

Uses:

• _d_array_bounds

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])

Uses:

• _d_allocmemoryT
• pure nothrow @safe ulong std.array.appenderNewCapacity!(16uL).appenderNewCapacity(ulong, ulong)
• memset@plt
• _d_array_bounds
• _d_arraysetlengthT

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted ulong __lambda2()

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted ulong __lambda3()

Uses:

• pure nothrow ulong core.memory.GC.extend(void*, ulong, ulong)

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted core.memory.BlkInfo_ __lambda4()

Uses:

• pure nothrow core.memory.BlkInfo_ core.memory.GC.qalloc(ulong, uint)

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted void __lambda5()

Uses:

• memcpy@plt

pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted immutable(char)[][] __lambda6()

Uses:

• _d_array_bounds

bool std.array.Appender!(immutable(char)[][]).Appender.Data.__xopEquals(ref const(std.array.Appender!(immutable(char)[][]).Appender.Data), ref const(std.array.Appender!(immutable(char)[][]).Appender.Data))

Uses:

• _adEq2

std.array.Appender!(immutable(char)[][]).Appender.datainout(pure nothrow @property @trusted inout(immutable(char)[])[] function())

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• .modulefilename43
• _d_assert_msg

pure nothrow ref @safe std.array.Appender!(immutable(char)[][]).Appender std.array.Appender!(immutable(char)[][]).Appender.__ctor(immutable(char)[][])

Used by:

• pure nothrow @safe std.array.Appender!(immutable(char)[][]).Appender std.array.appender!(immutable(char)[][], immutable(char)[]).appender()

Uses:

• _d_allocmemoryT
• .modulefilename43
• _d_assert

std.array.Appender.TAAyaZ.Appender.__ctor.MFNaNbNcNfAAyaZS3std5array18__T8AppenderTAAyaZ8Appender9__lambda2MFNbNeZm

Uses:

• pure nothrow @property ulong object.capacity!(immutable(char)[]).capacity(immutable(char)[][])

std.array.Appender.TAAyaZ.Appender.__ctor.MFNaNbNcNfAAyaZS3std5array18__T8AppenderTAAyaZ8Appender9__lambda3MFNbNeZAAya

Uses:

• _d_array_bounds

pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()

Used by:

• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• void std.stdio.File.close()

Uses:

• _d_allocmemoryT
• _d_arraysetcapacity

pure nothrow @safe std.array.Appender!(immutable(char)[][]).Appender std.array.appender!(immutable(char)[][], immutable(char)[]).appender()

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• memset@plt
• pure nothrow ref @safe std.array.Appender!(immutable(char)[][]).Appender std.array.Appender!(immutable(char)[][]).Appender.__ctor(immutable(char)[][])

pure nothrow @safe ulong std.array.appenderNewCapacity!(1uL).appenderNewCapacity(ulong, ulong)

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)

Uses:

• pure nothrow @safe int core.bitop.bsr(ulong)

pure nothrow @safe ulong std.array.appenderNewCapacity!(16uL).appenderNewCapacity(ulong, ulong)

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)

Uses:

• pure nothrow @safe ulong std.algorithm.max!(ulong, int).max(ulong, int)
• pure nothrow @safe int core.bitop.bsr(ulong)
• pure nothrow @safe ulong std.algorithm.max!(ulong, ulong).max(ulong, ulong)

pure nothrow @safe bool std.ascii.isDigit(dchar)

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()

void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[])

Used by:

• void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[][]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[][])

Uses:

• void std.range.doPut!(std.stdio.File.LockingTextWriter, immutable(char)[]).doPut(ref std.stdio.File.LockingTextWriter, ref immutable(char)[])

void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[][]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[][])

Used by:

• std.algorithm.copy.TAAyaTS3std5stdio4File17LockingTextWriterZ.copy.FAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter11genericImplFAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter

Uses:

• void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[])
• pure nothrow @safe void std.array.popFront!(immutable(char)[]).popFront(ref immutable(char)[][])
• pure nothrow @property @safe bool std.array.empty!(immutable(char)[]).empty(const(immutable(char)[][]))
• pure nothrow ref @property @safe immutable(char)[] std.array.front!(immutable(char)[]).front(immutable(char)[][])

void std.range.doPut!(std.stdio.File.LockingTextWriter, immutable(char)[]).doPut(ref std.stdio.File.LockingTextWriter, ref immutable(char)[])

Used by:

• void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[])

Uses:

• void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[])

pure nothrow @safe void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[]).put(ref std.array.Appender!(immutable(char)[]).Appender, immutable(char)[])

Used by:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.concurrency.Tid, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.concurrency.Tid, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• _d_array_bounds
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• _d_array_slice_copy

ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)

Used by:

• ulong std.stdio.File.readln!(char).readln(ref char[], dchar)

Uses:

• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• memcpy@plt
• _d_arrayappendcTX
• fgetwc_unlocked@plt
• _d_throw_exception
• funlockfile@plt
• pure nothrow ulong core.memory.GC.sizeOf(void*)
• free@plt
• pure @safe void std.utf.encode(ref char[], dchar)
• strerror_r@plt
• pure immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)
• std.stdio.StdioException.__init
• getdelim@plt
• fwide@plt
• ferror@plt
• _adDupT
• nothrow @property @trusted int core.stdc.errno.errno()
• _d_newclass
• flockfile@plt
• _d_arraysetlengthiT
• _d_eh_resume_unwind

std.stdio.StdioException.__init

Used by:

• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)

extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stderrImpl

Used by:

• std_stdio_static_this

extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stdoutImpl

Used by:

• std_stdio_static_this

extern (C) void std.stdio.std_stdio_static_this().std.stdio.File.Impl stdinImpl

Used by:

• std_stdio_static_this

void std.stdio.File.__postblit()

Used by:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__fieldPostBlit()

ulong std.stdio.File.readln!(char).readln(ref char[], dchar)

Used by:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()

Uses:

• .modulefilename
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• _d_assert_msg
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)

ulong std.stdio.File.readln!(char).readln(ref char[], dchar).pure nothrow @safe const(char)[] __dgliteral3()

void std.stdio.File.ByLine!(char, char).ByLine.__fieldDtor()

Used by:

• std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.map!(main9__lambda1).map!(std.stdio.File.ByLine!(char, char).ByLine).map(std.stdio.File.ByLine!(char, char).ByLine)
• void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldDtor()
• ref std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__ctor(std.stdio.File.ByLine!(char, char).ByLine)

Uses:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv

pure nothrow @safe void std.stdio.File.ByLine!(char, char).ByLine.__fieldPostBlit()

Used by:

• const(pure nothrow void function(ref const(std.stdio.File.ByLine!(char, char).ByLine))) std.stdio.File.ByLine!(char, char).ByLine.__cpctor
• pure nothrow @safe void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldPostBlit()

Uses:

• _d_assert
• .modulefilename
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit.MFNaNbNfZv

@property bool std.stdio.File.ByLine!(char, char).ByLine.empty()

Used by:

• @property bool std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.empty()

Uses:

• @property bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.empty()
• .modulefilename
• _d_assert_msg
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayload.MNgFNaNbNcNdNfZNgS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImpl

@property char[] std.stdio.File.ByLine!(char, char).ByLine.front()

Used by:

• @property immutable(char)[] std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.front()

Uses:

• .modulefilename
• _d_assert_msg
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayload.MNgFNaNbNcNdNfZNgS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImpl
• @property char[] std.stdio.File.ByLineImpl!(char, char).ByLineImpl.front()

ref std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.ByLine!(char, char).ByLine.__ctor(std.stdio.File, std.string.KeepTerminator, char)

Used by:

• std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.byLine!(char, char).byLine(std.string.KeepTerminator, char)

Uses:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__ctor.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.__ctor.MFNcKS3std5stdio4FileKE3std6string14KeepTerminatorKaZS3std8typecons109__T10RefCountedTS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z10RefCounted
• _d_eh_handle_collision
• _d_eh_resume_unwind
• void std.stdio.File.__dtor()

const(pure nothrow void function(ref const(std.stdio.File.ByLine!(char, char).ByLine))) std.stdio.File.ByLine!(char, char).ByLine.__cpctor

Used by:

• std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.map!(main9__lambda1).map!(std.stdio.File.ByLine!(char, char).ByLine).map(std.stdio.File.ByLine!(char, char).ByLine)
• ref std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__ctor(std.stdio.File.ByLine!(char, char).ByLine)

Uses:

• pure nothrow @safe void std.stdio.File.ByLine!(char, char).ByLine.__fieldPostBlit()

void std.stdio.File.ByLine!(char, char).ByLine.popFront()

Used by:

• void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.popFront()

Uses:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()
• .modulefilename
• _d_assert_msg
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayload.MNgFNaNbNcNdNfZNgS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImpl

std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.byLine!(char, char).byLine(std.string.KeepTerminator, char)

Used by:

• _Dmain

Uses:

• .modulefilename
• memset@plt
• ref std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.ByLine!(char, char).ByLine.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• _d_assert_msg
• const(void function(ref const(std.stdio.File))) std.stdio.File.__cpctor

void std.stdio.File.LockingTextWriter.put!(dchar).put(dchar)

Used by:

• void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[]).int __foreachbody3(ref dchar)

Uses:

• fputc_unlocked@plt
• .modulefilename
• pure nothrow @safe char[] std.utf.toUTF8(out char[4], dchar)
• _d_array_bounds
• fputwc_unlocked@plt
• _d_assert_msg

void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[])

Used by:

• void std.range.doPut!(std.stdio.File.LockingTextWriter, immutable(char)[]).doPut(ref std.stdio.File.LockingTextWriter, ref immutable(char)[])

Uses:

• int std.exception.errnoEnforce!(int, "/opt/ldc2-0.14/include/d/std/stdio.d", 2026uL).errnoEnforce(int, lazy immutable(char)[])
• _aApplycd1
• .modulefilename
• fwrite@plt
• _d_assert_msg

void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[]).pure nothrow @safe immutable(char)[] __dgliteral2()

void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[]).int __foreachbody3(ref dchar)

Uses:

• void std.stdio.File.LockingTextWriter.put!(dchar).put(dchar)

std.stdio.File.LockingTextWriter.__ctor.MFNcKS3std5stdio4FileZS3std5stdio4File17LockingTextWriter12__dgliteral2MFNaNbNfZAxa

void std.stdio.File.LockingTextWriter.__dtor()

Used by:

• std.stdio.File.LockingTextWriter std.algorithm.copy!(immutable(char)[][], std.stdio.File.LockingTextWriter).copy(immutable(char)[][], std.stdio.File.LockingTextWriter)
• _Dmain
• std.algorithm.copy.TAAyaTS3std5stdio4File17LockingTextWriterZ.copy.FAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter11genericImplFAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter

Uses:

• funlockfile@plt

const(void function(ref const(std.stdio.File.LockingTextWriter))) std.stdio.File.LockingTextWriter.__cpctor

Used by:

• std.stdio.File.LockingTextWriter std.algorithm.copy!(immutable(char)[][], std.stdio.File.LockingTextWriter).copy(immutable(char)[][], std.stdio.File.LockingTextWriter)
• std.algorithm.copy.TAAyaTS3std5stdio4File17LockingTextWriterZ.copy.FAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter11genericImplFAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter

Uses:

• flockfile@plt

std.stdio.File.LockingTextWriter std.stdio.File.lockingTextWriter()

Used by:

• _Dmain

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• fwide@plt
• flockfile@plt

void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__fieldDtor()

Uses:

• void std.stdio.File.__dtor()

bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__xopEquals(ref const(std.stdio.File.ByLineImpl!(char, char).ByLineImpl), ref const(std.stdio.File.ByLineImpl!(char, char).ByLineImpl))

Uses:

• _adEq2

void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__fieldPostBlit()

Uses:

• void std.stdio.File.__postblit()
• _d_assert
• .modulefilename

@property bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.empty()

Used by:

• @property bool std.stdio.File.ByLine!(char, char).ByLine.empty()

Uses:

• .modulefilename
• const(pure nothrow @property bool function()) std.stdio.File.isOpen
• pure shared(core.stdc.stdio._IO_FILE)* std.stdio.File.getFP()
• _d_assert_msg
• ungetc@plt
• fgetc@plt
• void std.stdio.File.detach()

@property char[] std.stdio.File.ByLineImpl!(char, char).ByLineImpl.front()

Used by:

• @property char[] std.stdio.File.ByLine!(char, char).ByLine.front()

Uses:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()
• .modulefilename
• _d_assert_msg

ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__ctor(std.stdio.File, std.string.KeepTerminator, char)

Used by:

• std.stdio.File.ByLineImpl!(char, char).ByLineImpl* std.conv.emplace!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl, std.stdio.File, std.string.KeepTerminator, char).emplace(std.stdio.File.ByLineImpl!(char, char).ByLineImpl*, ref std.stdio.File, ref std.string.KeepTerminator, ref char)

Uses:

• _d_eh_handle_collision
• _d_eh_resume_unwind
• const(void function(ref const(std.stdio.File))) std.stdio.File.__cpctor
• void std.stdio.File.__dtor()

void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()

Used by:

• void std.stdio.File.ByLine!(char, char).ByLine.popFront()
• @property char[] std.stdio.File.ByLineImpl!(char, char).ByLineImpl.front()

Uses:

• _d_assert
• ulong std.stdio.File.readln!(char).readln(ref char[], dchar)
• pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))
• .modulefilename
• const(pure nothrow @property bool function()) std.stdio.File.isOpen
• _d_array_bounds
• _d_assert_msg
• pure @safe bool std.algorithm.endsWith!("a == b", char[], char).endsWith(char[], char)
• ref inout(char[]) object.assumeSafeAppend!(char).assumeSafeAppend(ref inout(char[]))
• void std.stdio.File.detach()

void std.stdio.File.close()

Used by:

• void std.stdio.File.__dtor()
• void std.stdio.File.detach()

Uses:

• pclose@plt
• std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_throw_exception
• free@plt
• _d_arraycatnT
• _d_eh_resume_unwind
• _d_newclass
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• fclose@plt
• std.exception.ErrnoException.__init
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)

pure shared(core.stdc.stdio._IO_FILE)* std.stdio.File.getFP()

Used by:

• @property bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.empty()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

std.stdio.File.getFP.MFNaZPOS4core4stdc5stdio8_IO_FILE12__dgliteral1MFNaNbNfZAxa

void std.stdio.File.__dtor()

Used by:

• ref std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.ByLine!(char, char).ByLine.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__fieldDtor()

Uses:

• void std.stdio.File.close()

void std.stdio.File.detach()

Used by:

• @property bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.empty()
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()

Uses:

• void std.stdio.File.close()

const(pure nothrow @property bool function()) std.stdio.File.isOpen

Used by:

• @property bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.empty()
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()

const(void function(ref const(std.stdio.File))) std.stdio.File.__cpctor

Used by:

• std.stdio.File.ByLineImpl!(char, char).ByLineImpl* std.conv.emplace!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl, std.stdio.File, std.string.KeepTerminator, char).emplace(std.stdio.File.ByLineImpl!(char, char).ByLineImpl*, ref std.stdio.File, ref std.string.KeepTerminator, ref char)
• ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.byLine!(char, char).byLine(std.string.KeepTerminator, char)

std.stdio.File std.stdio.stdin

Used by:

• std_stdio_static_this

std.stdio.File std.stdio.stderr

Used by:

• std_stdio_static_this

std.stdio.File std.stdio.stdout

Used by:

• std_stdio_static_this

pure @safe int std.format.getNthInt!().getNthInt(uint)

Used by:

• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

Uses:

• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_newclass

pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• pure @safe immutable(char)[] std.string.format!(char, int).format(const(char[]), int).pure @safe object.Throwable __dgliteral4()
• pure @safe bool std.exception.enforceEx!(std.format.FormatException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe int std.format.getNthInt!().getNthInt(uint)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

Uses:

• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor()

Uses:

• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

std.format.FormatException.__init

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• pure @safe immutable(char)[] std.string.format!(char, int).format(const(char[]), int).pure @safe object.Throwable __dgliteral4()
• pure @safe bool std.exception.enforceEx!(std.format.FormatException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe int std.format.getNthInt!().getNthInt(uint)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)

Used by:

• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

Uses:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_array_bounds
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• _d_array_slice_copy
• _d_newclass

pure ref @safe std.format.FormatSpec!(char).FormatSpec std.format.FormatSpec!(char).FormatSpec.__ctor(const(char[]))

Used by:

• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)

std.format.FormatSpec.TaZ.FormatSpec.__init

Used by:

• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()

Used by:

• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)

Uses:

• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• std.format.FormatException.__init
• _d_throw_exception
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_array_bounds
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• pure nothrow @safe bool std.ascii.isDigit(dchar)
• Exception.__init
• _adDupT
• _d_arrayappendT
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• std.conv.ConvOverflowException.__init

pure nothrow @property @safe void std.format.FormatSpec!(char).FormatSpec.flDash(bool)

Used by:

• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)

pure @safe void std.format.enforceValidFormatSpec!(std.concurrency.Tid, char).enforceValidFormatSpec(ref std.format.FormatSpec!(char).FormatSpec).pure nothrow @safe immutable(char)[] __dgliteral2()

pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)

Used by:

• pure void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_array_bounds
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• _d_newclass
• pure nothrow @safe void std.format.formatUnsigned!(std.array.Appender!(immutable(char)[]).Appender, char).formatUnsigned(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec, uint, bool)

pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)

Used by:

• pure void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_array_bounds
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• _d_newclass
• pure nothrow @safe void std.format.formatUnsigned!(std.array.Appender!(immutable(char)[]).Appender, char).formatUnsigned(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec, uint, bool)

pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)

Used by:

• pure void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_array_bounds
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• _d_newclass
• pure nothrow @safe void std.format.formatUnsigned!(std.array.Appender!(immutable(char)[]).Appender, char).formatUnsigned(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec, uint, bool)

pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)

Used by:

• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])

Uses:

• _d_array_bounds
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt

pure @safe void std.format.enforceValidFormatSpec!(std.concurrency.MessageBox, char).enforceValidFormatSpec(ref std.format.FormatSpec!(char).FormatSpec).pure nothrow @safe immutable(char)[] __dgliteral2()

pure nothrow @safe void std.format.formatUnsigned!(std.array.Appender!(immutable(char)[]).Appender, char).formatUnsigned(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec, uint, bool)

Used by:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• _d_array_bounds
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• memcpy@plt

pure void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)

pure void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)

pure void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)

pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)

Used by:

• void std.stdio.File.close()

Uses:

• std.format.FormatSpec.TaZ.FormatSpec.__init
• _d_array_bounds
• pure @safe int std.format.getNthInt!().getNthInt(uint)
• pure nothrow @property @safe void std.format.FormatSpec!(char).FormatSpec.flDash(bool)
• pure @safe bool std.exception.enforceEx!(std.format.FormatException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)
• pure ref @safe std.format.FormatSpec!(char).FormatSpec std.format.FormatSpec!(char).FormatSpec.__ctor(const(char[]))
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure nothrow @safe int std.conv.to!(int).to!(int).to(int)

pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int).pure @safe immutable(char)[] __dgliteral7()

Uses:

• pure @safe immutable(char)[] std.conv.text!(immutable(char)[], const(char)[]).text(immutable(char)[], const(char)[])

pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)

Used by:

• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)

Uses:

• std.format.FormatSpec.TaZ.FormatSpec.__init
• _d_throw_exception
• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_array_bounds
• pure @safe int std.format.getNthInt!().getNthInt(uint)
• _d_newclass
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• std.conv.ConvOverflowException.__init
• _adDupT
• _d_arrayappendT

pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

Used by:

• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

Uses:

• std.format.FormatSpec.TaZ.FormatSpec.__init
• _d_throw_exception
• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_array_bounds
• pure @safe int std.format.getNthInt!().getNthInt(uint)
• _d_newclass
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• std.conv.ConvOverflowException.__init
• _adDupT
• _d_arrayappendT

void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.concurrency.Tid, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.concurrency.Tid, ref std.format.FormatSpec!(char).FormatSpec)

Used by:

• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

Uses:

• pure @safe bool std.exception.enforceEx!(std.format.FormatException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)
• pure nothrow @safe void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[]).put(ref std.array.Appender!(immutable(char)[]).Appender, immutable(char)[])

pure @safe immutable(char)[] std.string.format!(char, int).format(const(char[]), int).pure @safe object.Throwable __dgliteral4()

Uses:

• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• pure @safe immutable(char)[] std.conv.text!(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).text(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])

pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)

Used by:

• immutable(char)[] std.utf.UTFException.toString()

Uses:

• _d_allocmemoryT
• std.format.FormatException.__init
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_arraysetcapacity
• _d_newclass
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)

@trusted std.variant.VariantException std.variant.VariantException.__ctor(TypeInfo, TypeInfo)

Used by:

• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

Uses:

• _d_arraycatnT
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

std.variant.VariantException.__init

Used by:

• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(void).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• @trusted int std.variant.VariantN!(32uL).VariantN.opCmp!(std.variant.VariantN!(32uL).VariantN).opCmp(std.variant.VariantN!(32uL).VariantN)

@trusted long std.variant.VariantN!(32uL).VariantN.handler!(void).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

Uses:

• _d_throw_exception
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• bool object.opEquals(Object, Object)
• _d_newclass
• std.variant.VariantException.__init

@trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

Uses:

• std.format.FormatSpec.TaZ.FormatSpec.__init
• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• const(@trusted int function(ref const(std.variant.VariantN!(32uL).VariantN))) std.variant.VariantN!(32uL).VariantN.opCmp
• @trusted std.variant.VariantException std.variant.VariantException.__ctor(TypeInfo, TypeInfo)
• _d_throw_exception
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.concurrency.Tid, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.concurrency.Tid, ref std.format.FormatSpec!(char).FormatSpec)
• bool object.opEquals(Object, Object)
• const(@property @trusted TypeInfo function()) std.variant.VariantN!(32uL).VariantN.type
• _d_newclass
• std.variant.VariantException.__init
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• std.variant.VariantN.Vm32Z.VariantN.__init
• ldc.dso_ctor.3std8datetime

const(@property @trusted TypeInfo function()) std.variant.VariantN!(32uL).VariantN.type

Used by:

• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

@trusted int std.variant.VariantN!(32uL).VariantN.opCmp!(std.variant.VariantN!(32uL).VariantN).opCmp(std.variant.VariantN!(32uL).VariantN)

Used by:

• const(@trusted int function(ref const(std.variant.VariantN!(32uL).VariantN))) std.variant.VariantN!(32uL).VariantN.opCmp

Uses:

• _d_throw_exception
• _d_arraycatnT
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• std.variant.VariantException.__init

const(@trusted bool function(ref const(std.variant.VariantN!(32uL).VariantN))) std.variant.VariantN!(32uL).VariantN.opEquals!(const(std.variant.VariantN!(32uL).VariantN)).opEquals

Used by:

• bool std.concurrency.List!(std.concurrency.Message).List.Node.__xopEquals(ref const(std.concurrency.List!(std.concurrency.Message).List.Node), ref const(std.concurrency.List!(std.concurrency.Message).List.Node))

const(@trusted int function(ref const(std.variant.VariantN!(32uL).VariantN))) std.variant.VariantN!(32uL).VariantN.opCmp

Used by:

• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

Uses:

• @trusted int std.variant.VariantN!(32uL).VariantN.opCmp!(std.variant.VariantN!(32uL).VariantN).opCmp(std.variant.VariantN!(32uL).VariantN)

std.variant.VariantN.Vm32Z.VariantN.__init

Used by:

• void std.concurrency._staticDtor1()
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

const(nothrow bool function(long)) std.datetime.PosixTimeZone.dstInEffect

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)
• _d_array_bounds

const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

Used by:

• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)
• _d_array_bounds

const(nothrow @property bool function()) std.datetime.PosixTimeZone.hasDST

const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)
• _d_array_bounds
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)
• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)
• _d_array_bounds
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)
• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds

const(nothrow bool function(long)) std.datetime.SimpleTimeZone.dstInEffect

const(nothrow core.time.Duration function(long)) std.datetime.SimpleTimeZone.utcOffsetAt

const(nothrow @property bool function()) std.datetime.SimpleTimeZone.hasDST

const(nothrow long function(long)) std.datetime.SimpleTimeZone.tzToUTC

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "hnsecs").convert(long)

const(nothrow long function(long)) std.datetime.SimpleTimeZone.utcToTZ

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "hnsecs").convert(long)

const(nothrow bool function(long)) std.datetime.UTC.dstInEffect

const(nothrow core.time.Duration function(long)) std.datetime.UTC.utcOffsetAt

Uses:

• pure nothrow @safe core.time.Duration core.time.dur!("hnsecs").dur(long)

immutable(pure immutable(std.datetime.UTC) function()) std.datetime.UTC.__ctor

const(nothrow @property bool function()) std.datetime.UTC.hasDST

const(nothrow long function(long)) std.datetime.UTC.tzToUTC

const(nothrow long function(long)) std.datetime.UTC.utcToTZ

std.datetime.Clock std.datetime.Clock.__ctor()

const(nothrow core.time.Duration function(long)) std.datetime.TimeZone.utcOffsetAt

Uses:

• pure nothrow @safe core.time.Duration core.time.dur!("hnsecs").dur(long)

const(nothrow @property immutable(char)[] function()) std.datetime.TimeZone.name

const(nothrow @property immutable(char)[] function()) std.datetime.TimeZone.dstName

const(nothrow @property immutable(char)[] function()) std.datetime.TimeZone.stdName

const(nothrow bool function(long)) std.datetime.LocalTime.dstInEffect

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)
• localtime@plt

immutable(immutable(std.datetime.LocalTime) function()) std.datetime.LocalTime.__ctor

const(nothrow @property bool function()) std.datetime.LocalTime.hasDST

Uses:

• __daylight@@GLIBC_2.2.5

const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName

Uses:

• pure immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)
• _d_eh_resume_unwind
• __tzname@@GLIBC_2.2.5

const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.stdName

Uses:

• pure immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)
• _d_eh_resume_unwind
• __tzname@@GLIBC_2.2.5

const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)
• localtime@plt
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)

const(nothrow long function(long)) std.datetime.LocalTime.utcToTZ

Uses:

• pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)
• localtime@plt
• pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)

std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit.MFNaNbNfZv

Used by:

• pure nothrow @safe void std.stdio.File.ByLine!(char, char).ByLine.__fieldPostBlit()

Uses:

• _d_assert
• .modulefilename22
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.isInitialized.MxFNaNbNdNfZb

std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.isInitialized.MxFNaNbNdNfZb

Used by:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayload.MNgFNaNbNcNdNfZNgS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImpl
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit.MFNaNbNfZv
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv

Uses:

• .modulefilename22
• _d_assert_msg

std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.initialize.MFKS3std5stdio4FileKE3std6string14KeepTerminatorKaZv

Used by:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__ctor.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.__ctor.MFNcKS3std5stdio4FileKE3std6string14KeepTerminatorKaZS3std8typecons109__T10RefCountedTS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z10RefCounted

Uses:

• malloc@plt
• std.stdio.File.ByLineImpl!(char, char).ByLineImpl* std.conv.emplace!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl, std.stdio.File, std.string.KeepTerminator, char).emplace(std.stdio.File.ByLineImpl!(char, char).ByLineImpl*, ref std.stdio.File, ref std.string.KeepTerminator, ref char)
• pure @safe void* std.exception.enforce!(void*).enforce(void*, lazy const(char)[], immutable(char)[], ulong)
• nothrow void core.memory.GC.addRange(const(void*), ulong)

std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.initialize.MFKS3std5stdio4FileKE3std6string14KeepTerminatorKaZv12__dgliteral5MFNaNbNfZAxa

std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayload.MNgFNaNbNcNdNfZNgS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImpl

Used by:

• @property bool std.stdio.File.ByLine!(char, char).ByLine.empty()
• void std.stdio.File.ByLine!(char, char).ByLine.popFront()
• @property char[] std.stdio.File.ByLine!(char, char).ByLine.front()

Uses:

• .modulefilename22
• _d_assert_msg
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.isInitialized.MxFNaNbNdNfZb

std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__ctor.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.__ctor.MFNcKS3std5stdio4FileKE3std6string14KeepTerminatorKaZS3std8typecons109__T10RefCountedTS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z10RefCounted

Used by:

• ref std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.ByLine!(char, char).ByLine.__ctor(std.stdio.File, std.string.KeepTerminator, char)

Uses:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.initialize.MFKS3std5stdio4FileKE3std6string14KeepTerminatorKaZv

std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv

Used by:

• void std.stdio.File.ByLine!(char, char).ByLine.__fieldDtor()

Uses:

• _d_assert
• void object.destroy!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl).destroy(ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl)
• nothrow void core.memory.GC.removeRange(const(void*))
• free@plt
• .modulefilename22
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.isInitialized.MxFNaNbNdNfZb

pure nothrow @safe ulong std.algorithm.max!(ulong, int).max(ulong, int)

Used by:

• pure nothrow @safe ulong std.array.appenderNewCapacity!(16uL).appenderNewCapacity(ulong, ulong)

pure nothrow @safe ulong std.algorithm.max!(ulong, ulong).max(ulong, ulong)

Used by:

• pure nothrow @safe ulong std.array.appenderNewCapacity!(16uL).appenderNewCapacity(ulong, ulong)

std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.map!(main9__lambda1).map!(std.stdio.File.ByLine!(char, char).ByLine).map(std.stdio.File.ByLine!(char, char).ByLine)

Used by:

• _Dmain

Uses:

• void std.stdio.File.ByLine!(char, char).ByLine.__fieldDtor()
• _d_eh_handle_collision
• _d_eh_resume_unwind
• const(pure nothrow void function(ref const(std.stdio.File.ByLine!(char, char).ByLine))) std.stdio.File.ByLine!(char, char).ByLine.__cpctor
• ref std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__ctor(std.stdio.File.ByLine!(char, char).ByLine)

pure @safe bool std.algorithm.endsWith!("a == b", char[], char).endsWith(char[], char)

Used by:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()

Uses:

• pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))
• pure @property @safe dchar std.array.back!(char).back(char[])
• pure nothrow @safe bool std.functional.binaryFun!("a == b").binaryFun!(dchar, char).binaryFun(dchar, char)

std.stdio.File.LockingTextWriter std.algorithm.copy!(immutable(char)[][], std.stdio.File.LockingTextWriter).copy(immutable(char)[][], std.stdio.File.LockingTextWriter)

Used by:

• _Dmain

Uses:

• void std.stdio.File.LockingTextWriter.__dtor()
• _d_eh_handle_collision
• _d_eh_resume_unwind
• const(void function(ref const(std.stdio.File.LockingTextWriter))) std.stdio.File.LockingTextWriter.__cpctor
• std.algorithm.copy.TAAyaTS3std5stdio4File17LockingTextWriterZ.copy.FAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter11genericImplFAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter

std.algorithm.copy.TAAyaTS3std5stdio4File17LockingTextWriterZ.copy.FAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter11genericImplFAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter

Used by:

• std.stdio.File.LockingTextWriter std.algorithm.copy!(immutable(char)[][], std.stdio.File.LockingTextWriter).copy(immutable(char)[][], std.stdio.File.LockingTextWriter)

Uses:

• void std.stdio.File.LockingTextWriter.__dtor()
• _d_eh_handle_collision
• _d_eh_resume_unwind
• void std.range.put!(std.stdio.File.LockingTextWriter, immutable(char)[][]).put(ref std.stdio.File.LockingTextWriter, immutable(char)[][])
• const(void function(ref const(std.stdio.File.LockingTextWriter))) std.stdio.File.LockingTextWriter.__cpctor

void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldDtor()

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• void std.stdio.File.ByLine!(char, char).ByLine.__fieldDtor()

pure nothrow @safe void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldPostBlit()

Used by:

• const(pure nothrow void function(ref const(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult))) std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__cpctor

Uses:

• _d_assert
• pure nothrow @safe void std.stdio.File.ByLine!(char, char).ByLine.__fieldPostBlit()
• .modulefilename63

@property bool std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.empty()

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• @property bool std.stdio.File.ByLine!(char, char).ByLine.empty()
• _d_assert_msg

@property immutable(char)[] std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.front()

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• void pipeline.main().pure @safe immutable(char)[] __lambda1!(char[]).__lambda1(char[])
• _d_assert_msg
• @property char[] std.stdio.File.ByLine!(char, char).ByLine.front()

ref std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__ctor(std.stdio.File.ByLine!(char, char).ByLine)

Used by:

• std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.map!(main9__lambda1).map!(std.stdio.File.ByLine!(char, char).ByLine).map(std.stdio.File.ByLine!(char, char).ByLine)

Uses:

• void std.stdio.File.ByLine!(char, char).ByLine.__fieldDtor()
• _d_eh_handle_collision
• _d_eh_resume_unwind
• const(pure nothrow void function(ref const(std.stdio.File.ByLine!(char, char).ByLine))) std.stdio.File.ByLine!(char, char).ByLine.__cpctor

const(pure nothrow void function(ref const(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult))) std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__cpctor

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• pure nothrow @safe void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldPostBlit()

void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.popFront()

Used by:

• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

Uses:

• void std.stdio.File.ByLine!(char, char).ByLine.popFront()
• _d_assert_msg

int std.exception.errnoEnforce!(int, "/opt/ldc2-0.14/include/d/std/stdio.d", 2026uL).errnoEnforce(int, lazy immutable(char)[])

Used by:

• void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[])

Uses:

• std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_throw_exception
• _d_newclass
• memcpy@plt

std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)

Used by:

• int std.exception.errnoEnforce!(int, "/opt/ldc2-0.14/include/d/std/stdio.d", 2026uL).errnoEnforce(int, lazy immutable(char)[])
• void std.stdio.File.close()

Uses:

• strlen@plt
• _d_arraycatnT
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• nothrow @property @trusted int core.stdc.errno.errno()
• strerror_r@plt
• _adDupT

std.exception.ErrnoException.__init

Used by:

• void std.stdio.File.close()

pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

Used by:

• ulong std.stdio.File.readln!(char).readln(ref char[], dchar)
• pure shared(core.stdc.stdio._IO_FILE)* std.stdio.File.getFP()
• std.stdio.File.LockingTextWriter std.stdio.File.lockingTextWriter()

Uses:

• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)

Used by:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• void std.stdio.File.close()

Uses:

• _d_throw_exception

pure @safe void* std.exception.enforce!(void*).enforce(void*, lazy const(char)[], immutable(char)[], ulong)

Used by:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.initialize.MFKS3std5stdio4FileKE3std6string14KeepTerminatorKaZv

Uses:

• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

pure @safe bool std.exception.enforceEx!(std.format.FormatException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)

Used by:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.concurrency.Tid, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.concurrency.Tid, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)

Uses:

• std.format.FormatException.__init
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_newclass

pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• void std.concurrency.MessageBox.close()
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• pure @safe void* std.exception.enforce!(void*).enforce(void*, lazy const(char)[], immutable(char)[], ulong)
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

Uses:

• _d_throw_exception
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• Exception.__init
• _adDupT

void std.stdiobase._sharedStaticCtor1()

Uses:

• std_stdio_static_this

nothrow @property @trusted int core.stdc.errno.errno()

Used by:

• std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)
• void core.thread.Thread.sleep(core.time.Duration)
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• void core.thread.suspend(core.thread.Thread)
• _d_run_main

Uses:

• getErrno

nothrow @property @trusted int core.stdc.errno.errno(int)

Used by:

• void core.thread.suspend(core.thread.Thread)

Uses:

• setErrno

core.sys.posix.sys.types.pthread_mutex_t* core.sync.mutex.Mutex.handleAddr()

Used by:

• bool core.sync.condition.Condition.wait(core.time.Duration)
• void core.sync.condition.Condition.wait()

@trusted void core.sync.mutex.Mutex.lock()

Uses:

• pthread_mutex_lock@plt
• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_newclass
• core.sync.exception.SyncException.__init

core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

Used by:

• void std.concurrency._sharedStaticCtor2()
• thread_init
• void gc.gc.GC.initialize()
• @property std.concurrency.Tid std.concurrency.thisTid()
• std.concurrency.MessageBox std.concurrency.MessageBox.__ctor()
• gc.gc.GCMutex gc.gc.GCMutex.__ctor()

Uses:

• pthread_mutexattr_init@plt
• pthread_mutexattr_settype@plt
• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• pthread_mutex_init@plt
• _d_eh_resume_unwind
• _d_eh_handle_collision
• pthread_mutexattr_destroy@plt
• _d_newclass
• core.sync.exception.SyncException.__init

void core.sync.mutex.Mutex.__dtor()

Used by:

• thread_term

Uses:

• pthread_mutex_destroy@plt

core.sync.mutex.Mutex.__init

Used by:

• void std.concurrency._sharedStaticCtor2()
• @property std.concurrency.Tid std.concurrency.thisTid()
• std.concurrency.MessageBox std.concurrency.MessageBox.__ctor()

@trusted void core.sync.mutex.Mutex.unlock()

Uses:

• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• pthread_mutex_unlock@plt
• _d_newclass
• core.sync.exception.SyncException.__init

core.sync.mutex.Mutex.__Class

Used by:

• thread_init

bool core.sync.mutex.Mutex.tryLock()

Uses:

• pthread_mutex_trylock@plt

void core.sync.config.mktspec(ref core.sys.posix.signal.timespec, core.time.Duration)

Used by:

• bool core.sync.condition.Condition.wait(core.time.Duration)

Uses:

• pure nothrow @safe long core.time.getUnitsFromHNSecs!("seconds").getUnitsFromHNSecs(long)
• pure nothrow @safe core.time.Duration core.time.dur!("seconds").dur(long)
• pure nothrow @safe core.time.Duration core.time.dur!("nsecs").dur(long)
• const(pure nothrow @property @safe int function()) core.time.FracSec.nsecs
• gettimeofday@plt
• const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec

bool core.sync.condition.Condition.wait(core.time.Duration)

Uses:

• pthread_cond_timedwait@plt
• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• core.sys.posix.sys.types.pthread_mutex_t* core.sync.mutex.Mutex.handleAddr()
• _d_newclass
• void core.sync.config.mktspec(ref core.sys.posix.signal.timespec, core.time.Duration)
• core.sync.exception.SyncException.__init

void core.sync.condition.Condition.wait()

Uses:

• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• core.sys.posix.sys.types.pthread_mutex_t* core.sync.mutex.Mutex.handleAddr()
• pthread_cond_wait@plt
• _d_newclass
• core.sync.exception.SyncException.__init

@property core.sync.mutex.Mutex core.sync.condition.Condition.mutex()

core.sync.condition.Condition core.sync.condition.Condition.__ctor(core.sync.mutex.Mutex)

Used by:

• @property std.concurrency.Tid std.concurrency.thisTid()
• std.concurrency.MessageBox std.concurrency.MessageBox.__ctor()

Uses:

• pthread_cond_init@plt
• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_newclass
• core.sync.exception.SyncException.__init

void core.sync.condition.Condition.__dtor()

Uses:

• pthread_cond_destroy@plt

core.sync.condition.Condition.__init

Used by:

• @property std.concurrency.Tid std.concurrency.thisTid()
• std.concurrency.MessageBox std.concurrency.MessageBox.__ctor()

void core.sync.condition.Condition.notify()

Uses:

• pthread_cond_signal@plt
• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_newclass
• core.sync.exception.SyncException.__init

void core.sync.condition.Condition.notifyAll()

Uses:

• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• pthread_cond_broadcast@plt
• _d_newclass
• core.sync.exception.SyncException.__init

pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• bool core.sync.condition.Condition.wait(core.time.Duration)
• void core.sync.condition.Condition.wait()
• void core.sync.condition.Condition.notifyAll()
• @trusted void core.sync.mutex.Mutex.unlock()
• core.sync.condition.Condition core.sync.condition.Condition.__ctor(core.sync.mutex.Mutex)
• @trusted void core.sync.mutex.Mutex.lock()
• void core.sync.condition.Condition.notify()
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

Uses:

• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

core.sync.exception.SyncException.__init

Used by:

• bool core.sync.condition.Condition.wait(core.time.Duration)
• void core.sync.condition.Condition.wait()
• void core.sync.condition.Condition.notifyAll()
• @trusted void core.sync.mutex.Mutex.unlock()
• core.sync.condition.Condition core.sync.condition.Condition.__ctor(core.sync.mutex.Mutex)
• @trusted void core.sync.mutex.Mutex.lock()
• void core.sync.condition.Condition.notify()
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()

immutable(long) core.time.TickDuration.ticksPerSec

Used by:

• @trusted void core.time.TickDuration._sharedStaticCtor1()

@trusted void core.time.TickDuration._sharedStaticCtor1()

Uses:

• immutable(long) core.time.TickDuration.ticksPerSec
• _d_throw_exception
• immutable(core.time.TickDuration) core.time.TickDuration.appOrigin
• core.time.TimeException.__init
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• clock_gettime@plt
• _d_newclass
• clock_getres@plt

immutable(core.time.TickDuration) core.time.TickDuration.appOrigin

Used by:

• @trusted void core.time.TickDuration._sharedStaticCtor1()

core.time.TimeException.__init

Used by:

• const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec
• @trusted void core.time.TickDuration._sharedStaticCtor1()

pure nothrow @safe core.time.Duration core.time.dur!("msecs").dur(long)

Used by:

• thread_suspendAll

pure nothrow @safe core.time.Duration core.time.dur!("nsecs").dur(long)

Used by:

• void core.sync.config.mktspec(ref core.sys.posix.signal.timespec, core.time.Duration)

pure nothrow @safe core.time.Duration core.time.dur!("usecs").dur(long)

Used by:

• thread_suspendAll

pure nothrow @safe core.time.Duration core.time.dur!("hnsecs").dur(long)

Used by:

• const(nothrow core.time.Duration function(long)) std.datetime.TimeZone.utcOffsetAt
• const(nothrow core.time.Duration function(long)) std.datetime.UTC.utcOffsetAt

pure nothrow @safe core.time.Duration core.time.dur!("seconds").dur(long)

Used by:

• void core.sync.config.mktspec(ref core.sys.posix.signal.timespec, core.time.Duration)

pure nothrow @safe long core.time.getUnitsFromHNSecs!("seconds").getUnitsFromHNSecs(long)

Used by:

• void core.thread.Thread.sleep(core.time.Duration)
• void core.sync.config.mktspec(ref core.sys.posix.signal.timespec, core.time.Duration)

pure nothrow @safe long core.time.convert!("hnsecs", "hnsecs").convert(long)

Used by:

• const(nothrow long function(long)) std.datetime.SimpleTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.SimpleTimeZone.tzToUTC

pure nothrow @safe long core.time.convert!("hnsecs", "seconds").convert(long)

Used by:

• const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC
• const(nothrow bool function(long)) std.datetime.PosixTimeZone.dstInEffect
• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.LocalTime.utcToTZ
• const(nothrow bool function(long)) std.datetime.LocalTime.dstInEffect
• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

pure nothrow @safe long core.time.convert!("seconds", "hnsecs").convert(long)

Used by:

• const(nothrow long function(long)) std.datetime.LocalTime.tzToUTC
• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• const(nothrow long function(long)) std.datetime.LocalTime.utcToTZ
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC

const(pure nothrow @property @safe int function()) core.time.FracSec.nsecs

Used by:

• void core.thread.Thread.sleep(core.time.Duration)
• void core.sync.config.mktspec(ref core.sys.posix.signal.timespec, core.time.Duration)

const(pure nothrow @safe int function(core.time.Duration)) core.time.Duration.opCmp

Used by:

• thread_suspendAll

const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec

Used by:

• void core.thread.Thread.sleep(core.time.Duration)
• void core.sync.config.mktspec(ref core.sys.posix.signal.timespec, core.time.Duration)

Uses:

• _d_throw_exception
• core.time.TimeException.__init
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_eh_resume_unwind
• _d_newclass

pure nothrow @safe int core.bitop.bsf(ulong)

Used by:

• ulong gc.gc.Gcx.fullcollect()

pure nothrow @safe int core.bitop.bsr(ulong)

Used by:

• pure nothrow @safe ulong std.array.appenderNewCapacity!(16uL).appenderNewCapacity(ulong, ulong)
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• _d_arrayappendcTX
• pure nothrow @safe ulong std.array.appenderNewCapacity!(1uL).appenderNewCapacity(ulong, ulong)

nothrow void core.memory.GC.removeRange(const(void*))

Used by:

• _d_dso_registry
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv

Uses:

• gc_removeRange

pure nothrow void core.memory.GC.free(void*)

Used by:

• _aaDelX
• const(void function(void*, void*)) object.TypeInfo_StaticArray.swap

Uses:

• gc_free

pure nothrow ulong core.memory.GC.extend(void*, ulong, ulong)

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted ulong __lambda3()
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)

Uses:

• gc_extend

pure nothrow void* core.memory.GC.malloc(ulong, uint)

Used by:

• _aaKeys

Uses:

• gc_malloc

pure nothrow core.memory.BlkInfo_ core.memory.GC.qalloc(ulong, uint)

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted core.memory.BlkInfo_ __lambda4()

Uses:

• gc_qalloc

pure nothrow ulong core.memory.GC.sizeOf(void*)

Used by:

• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)

Uses:

• gc_sizeOf

nothrow void core.memory.GC.addRange(const(void*), ulong)

Used by:

• void rt.memory.initStaticDataGC().int __foreachbody1(ref rt.sections_linux.DSO)
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize.TS3std5stdio4FileTE3std6string14KeepTerminatorTaZ.initialize.MFKS3std5stdio4FileKE3std6string14KeepTerminatorKaZv
• _d_dso_registry

Uses:

• gc_addRange

uint core.thread.suspendDepth

Used by:

• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.add(core.thread.Thread)
• thread_suspendAll
• thread_resumeAll

core.thread.__shared_ctor

Uses:

• sched_get_priority_min@plt
• pthread_self@plt
• const(int) core.thread.Thread.PRIORITY_MAX
• sysconf@plt
• const(int) core.thread.Thread.PRIORITY_DEFAULT
• sched_get_priority_max@plt
• pthread_getschedparam@plt
• const(int) core.thread.Thread.PRIORITY_MIN
• const(ulong) core.thread.PAGESIZE

extern (C) void core.thread.thread_joinAll().int __foreachbody1(ref core.thread.Thread)

Uses:

• _d_monitorenter
• _d_eh_resume_unwind
• _d_eh_handle_collision
• _d_monitorexit
• void core.thread.Thread.remove(core.thread.Thread)

extern (C) void core.thread.thread_scanAll(scope void delegate(void*, void*)).void __lambda2!(core.thread.ScanType, void*, void*).__lambda2(core.thread.ScanType, void*, void*)

core.thread.ThreadException.__init

Used by:

• void core.thread.Thread.sleep(core.time.Duration)
• void core.thread.resume(core.thread.Thread)
• thread_joinAll
• void core.thread.suspend(core.thread.Thread)

void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*)

Used by:

• extern (C) void core.thread.thread_scanAllType(scope void delegate(core.thread.ScanType, void*, void*)).void __lambda2!(void*).__lambda2(void*)

Uses:

• core.thread.Thread core.thread.Thread.sm_tbeg
• uint core.thread.Thread.sm_this
• _d_eh_resume_unwind
• void rt.tlsgc.scan(rt.tlsgc.Data*, scope void delegate(void*, void*))
• pthread_getspecific@plt
• core.thread.Thread.Context* core.thread.Thread.sm_cbeg

void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*).void __lambda3!(void*, void*).__lambda3(void*, void*)

bool core.thread.multiThreadedFlag

Used by:

• thread_attachThis
• thread_suspendAll
• thread_resumeAll

void core.thread._sharedStaticDtor2()

Uses:

• core.thread.Thread core.thread.Thread.sm_tbeg
• void core.thread.Thread.remove(core.thread.Thread)

void core.thread.callWithStackShell(scope void delegate(void*))

Used by:

• thread_suspendHandler
• thread_scanAll

extern (C) void core.thread.thread_scanAllType(scope void delegate(core.thread.ScanType, void*, void*)).void __lambda2!(void*).__lambda2(void*)

Uses:

• void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*)

extern (C) void core.thread.thread_suspendHandler(int).void op(void*)

Uses:

• sigdelset@plt
• sem_post@plt
• uint core.thread.Thread.sm_this
• sigfillset@plt
• pthread_getspecific@plt
• sigsuspend@plt

void core.thread.Fiber._staticCtor4()

core.thread.Fiber core.thread.Fiber.__ctor()

void core.thread.Fiber.__dtor()

Uses:

• _d_monitorenter
• _d_monitorexit
• munmap@plt
• core.thread.Thread.Context* core.thread.Thread.sm_cbeg
• ulong core.thread.Thread.sm_clen

const(int) core.thread.Thread.PRIORITY_MAX

Used by:

• core.thread.__shared_ctor

const(int) core.thread.Thread.PRIORITY_MIN

Used by:

• core.thread.__shared_ctor

const(int) core.thread.Thread.PRIORITY_DEFAULT

Used by:

• core.thread.__shared_ctor

void core.thread.Thread.add(core.thread.Thread)

Used by:

• thread_attachThis

Uses:

• _d_monitorenter
• core.thread.Thread core.thread.Thread.sm_tbeg
• ulong core.thread.Thread.sm_tlen
• sched_yield@plt
• uint core.thread.suspendDepth
• _d_eh_resume_unwind
• _d_eh_handle_collision
• _d_monitorexit

void core.thread.Thread.add(core.thread.Thread.Context*)

Used by:

• thread_attachThis

Uses:

• _d_monitorenter
• sched_yield@plt
• uint core.thread.suspendDepth
• _d_eh_resume_unwind
• _d_eh_handle_collision
• _d_monitorexit
• core.thread.Thread.Context* core.thread.Thread.sm_cbeg
• ulong core.thread.Thread.sm_clen

void core.thread.Thread.sleep(core.time.Duration)

Used by:

• thread_suspendAll

Uses:

• pure nothrow @safe long core.time.getUnitsFromHNSecs!("seconds").getUnitsFromHNSecs(long)
• _d_throw_exception
• const(pure nothrow @property @safe int function()) core.time.FracSec.nsecs
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec
• nothrow @property @trusted int core.stdc.errno.errno()
• _d_newclass
• nanosleep@plt
• core.thread.ThreadException.__init

core.thread.Thread core.thread.Thread.__ctor()

void core.thread.Thread.__dtor()

Uses:

• pthread_detach@plt
• void rt.tlsgc.destroy(rt.tlsgc.Data*)

byte[72][2] core.thread.Thread._locks

Used by:

• thread_init
• thread_suspendAll
• thread_resumeAll

void core.thread.Thread.remove(core.thread.Thread)

Used by:

• void core.thread._sharedStaticDtor2()
• void core.thread.resume(core.thread.Thread)
• thread_suspendAll
• extern (C) void core.thread.thread_joinAll().int __foreachbody1(ref core.thread.Thread)
• void core.thread.suspend(core.thread.Thread)

Uses:

• _d_monitorenter
• core.thread.Thread core.thread.Thread.sm_tbeg
• ulong core.thread.Thread.sm_tlen
• _d_eh_resume_unwind
• _d_eh_handle_collision
• _d_monitorexit
• bool object.opEquals(Object, Object)
• core.thread.Thread.Context* core.thread.Thread.sm_cbeg
• ulong core.thread.Thread.sm_clen

int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))

Used by:

• thread_joinAll

Uses:

• _d_monitorenter
• core.thread.Thread core.thread.Thread.sm_tbeg
• _d_eh_resume_unwind
• _d_eh_handle_collision
• _d_monitorexit

core.thread.Thread.Context* core.thread.Thread.sm_cbeg

Used by:

• void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*)
• void core.thread.Fiber.__dtor()
• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.remove(core.thread.Thread)

ulong core.thread.Thread.sm_clen

Used by:

• void core.thread.Fiber.__dtor()
• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.remove(core.thread.Thread)

core.thread.Thread core.thread.Thread.sm_main

Used by:

• thread_attachThis
• thread_init

core.thread.Thread core.thread.Thread.sm_tbeg

Used by:

• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• void core.thread._sharedStaticDtor2()
• void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*)
• thread_processGCMarks
• void core.thread.Thread.remove(core.thread.Thread)
• void core.thread.Thread.add(core.thread.Thread)
• thread_suspendAll
• thread_resumeAll

uint core.thread.Thread.sm_this

Used by:

• extern (C) void core.thread.thread_suspendHandler(int).void op(void*)
• thread_attachThis
• void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*)
• thread_term
• thread_suspendAll
• thread_stackBottom
• thread_resumeAll

ulong core.thread.Thread.sm_tlen

Used by:

• void core.thread.Thread.remove(core.thread.Thread)
• void core.thread.Thread.add(core.thread.Thread)

void core.thread.resume(core.thread.Thread)

Used by:

• thread_resumeAll

Uses:

• _d_throw_exception
• pthread_self@plt
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• void core.thread.Thread.remove(core.thread.Thread)
• _d_newclass
• pthread_kill@plt
• core.thread.ThreadException.__init

void core.thread.suspend(core.thread.Thread)

Used by:

• thread_suspendAll

Uses:

• _d_throw_exception
• pthread_self@plt
• nothrow @property @trusted int core.stdc.errno.errno(int)
• sem_wait@plt
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• void core.thread.Thread.remove(core.thread.Thread)
• nothrow @property @trusted int core.stdc.errno.errno()
• _d_newclass
• pthread_kill@plt
• core.thread.ThreadException.__init

const(ulong) core.thread.PAGESIZE

Used by:

• core.thread.__shared_ctor

void core.runtime._staticCtor1()

Uses:

• rt_setTraceHandler

extern (C) bool core.runtime.runModuleUnitTests().int __foreachbody3(ref object.ModuleInfo*)

Uses:

• pure nothrow @property void function()* object.ModuleInfo.unitTest()
• stderr@@GLIBC_2.2.5
• _d_eh_resume_unwind
• fprintf@plt

extern (C) bool core.runtime.runModuleUnitTests().extern (C) void unittestSegvHandler(int, core.sys.posix.signal.siginfo_t*, void*)

Uses:

• memset@plt
• backtrace@plt
• backtrace_symbols_fd@plt

extern (C) bool core.runtime.runModuleUnitTests().void printErr(const(char[]))

Uses:

• stderr@@GLIBC_2.2.5
• fprintf@plt

object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)

Uses:

• memset@plt
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo10getBasePtrFZPPv
• _d_newclass
• thread_stackBottom
• backtrace_symbols@plt
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__initZ

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo

Uses:

• memset@plt
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo10getBasePtrFZPPv
• thread_stackBottom
• backtrace_symbols@plt

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo10getBasePtrFZPPv

Used by:

• object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__ctorMFZC4core7runtime19defaultTraceHandlerFPvZC6object9Throwable9TraceInfo16DefaultTraceInfo

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__dtorMFZv

Uses:

• free@plt

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo6__initZ

Used by:

• object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMxFAxaKG4096aZAxa

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMxFMDFKmKxAaZiZi

Uses:

• memchr@plt
• char[] core.demangle.demangle(const(char)[], char[])
• memmove@plt
• memcpy@plt

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMxFMDFKmKxAaZiZi

Uses:

• strlen@plt
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMxFAxaKG4096aZAxa
• memset@plt

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMxFMDFKxAaZiZi

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7opApplyMxFMDFKxAaZiZi16__T9__lambda2TmZ9__lambda2MFKmKxAaZi

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMxFZAya

core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMxFZAya14__foreachbody1MFNfKmKxAaZi

Uses:

• _d_arraycatT
• _d_arrayappendT

bool function()* core.runtime.Runtime.sm_moduleUnitTester

Used by:

• runModuleUnitTests

void core.demangle.Demangle.parseLName()

Used by:

• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseSymbolName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.put(const(char)[])

void core.demangle.Demangle.parseValue(char[], char)

Used by:

• void core.demangle.Demangle.parseTemplateArgs()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• void core.demangle.Demangle.parseIntegerValue(char[], char)
• char[] core.demangle.Demangle.put(const(char)[])
• void core.demangle.Demangle.parseReal()

void core.demangle.Demangle.parseFuncAttr()

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.put(const(char)[])

core.demangle.Demangle.ParseException.__Class

Used by:

• void core.demangle.Demangle.error(immutable(char)[])
• void core.demangle.Demangle.parseTemplateInstanceName()

void core.demangle.Demangle.parseSymbolName()

Used by:

• char[] core.demangle.Demangle.parseQualifiedName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• void core.demangle.Demangle.parseTemplateInstanceName()
• _d_eh_resume_unwind
• bool core.demangle.Demangle.mayBeTemplateInstanceName()
• void core.demangle.Demangle.parseLName()

void core.demangle.Demangle.parseMangledName()

Used by:

• char[] core.demangle.Demangle.doDemangle!(_D4core8demangle8Demangle16parseMangledNameMFZv).doDemangle()

Uses:

• char[] core.demangle.Demangle.parseQualifiedName()
• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])

core.demangle.Demangle.OverflowException.__Class

Used by:

• void core.demangle.Demangle.overflow(immutable(char)[])

void core.demangle.Demangle.parseIntegerValue(char[], char)

Used by:

• void core.demangle.Demangle.parseValue(char[], char)

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• .str5
• char[] core.demangle.Demangle.put(const(char)[])

void core.demangle.Demangle.parseTemplateArgs()

Used by:

• void core.demangle.Demangle.parseTemplateInstanceName()

Uses:

• char[] core.demangle.Demangle.parseQualifiedName()
• void core.demangle.Demangle.parseValue(char[], char)
• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])

char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)

Used by:

• char[] core.demangle.Demangle.parseType(char[])

Uses:

• _d_throw_exception
• void core.demangle.Demangle.parseCallConvention()
• void core.demangle.Demangle.parseFuncAttr()
• void core.demangle.Demangle.parseFuncArguments()
• _d_eh_resume_unwind
• _d_eh_handle_collision
• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])

void core.demangle.Demangle.parseFuncArguments()

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()

Uses:

• char[] core.demangle.Demangle.parseType(char[])
• char[] core.demangle.Demangle.put(const(char)[])

char[] core.demangle.Demangle.parseQualifiedName()

Used by:

• void core.demangle.Demangle.parseMangledName()
• char[] core.demangle.Demangle.parseType(char[])
• void core.demangle.Demangle.parseTemplateArgs()

Uses:

• void core.demangle.Demangle.parseSymbolName()
• void core.demangle.Demangle.parseCallConvention()
• void core.demangle.Demangle.parseFuncAttr()
• void core.demangle.Demangle.parseFuncArguments()
• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])

void core.demangle.Demangle.parseCallConvention()

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.put(const(char)[])

bool core.demangle.Demangle.mayBeTemplateInstanceName()

Used by:

• void core.demangle.Demangle.parseSymbolName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• _d_eh_resume_unwind

void core.demangle.Demangle.parseTemplateInstanceName()

Used by:

• void core.demangle.Demangle.parseSymbolName()

Uses:

• void core.demangle.Demangle.error(immutable(char)[])
• core.demangle.Demangle.ParseException.__Class
• _d_throw_exception
• _d_eh_resume_unwind
• void core.demangle.Demangle.parseLName()
• char[] core.demangle.Demangle.put(const(char)[])
• void core.demangle.Demangle.parseTemplateArgs()

char[] core.demangle.Demangle.put(const(char)[])

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()
• void core.demangle.Demangle.parseCallConvention()
• void core.demangle.Demangle.parseFuncAttr()
• void core.demangle.Demangle.parseFuncArguments()
• void core.demangle.Demangle.parseValue(char[], char)
• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseLName()
• void core.demangle.Demangle.parseIntegerValue(char[], char)
• void core.demangle.Demangle.parseMangledName()
• void core.demangle.Demangle.parseReal()
• char[] core.demangle.Demangle.parseType(char[])
• void core.demangle.Demangle.parseTemplateArgs()

Uses:

• _d_arraysetlengthiT
• memcpy@plt
• void core.demangle.Demangle.overflow(immutable(char)[])

void core.demangle.Demangle.error(immutable(char)[])

Used by:

• void core.demangle.Demangle.parseCallConvention()
• void core.demangle.Demangle.parseFuncAttr()
• void core.demangle.Demangle.parseValue(char[], char)
• void core.demangle.Demangle.parseTemplateInstanceName()
• void core.demangle.Demangle.parseSymbolName()
• void core.demangle.Demangle.parseLName()
• void core.demangle.Demangle.parseIntegerValue(char[], char)
• bool core.demangle.Demangle.mayBeTemplateInstanceName()
• void core.demangle.Demangle.parseMangledName()
• void core.demangle.Demangle.parseReal()
• char[] core.demangle.Demangle.parseType(char[])

Uses:

• core.demangle.Demangle.ParseException.__Class
• _d_throw_exception

char[] core.demangle.Demangle.doDemangle!(_D4core8demangle8Demangle16parseMangledNameMFZv).doDemangle()

Used by:

• char[] core.demangle.demangle(const(char)[], char[])

Uses:

• _d_arraysetlengthiT
• _d_eh_resume_unwind
• void core.demangle.Demangle.parseMangledName()
• memcpy@plt

core.demangle.Demangle.__init

Used by:

• char[] core.demangle.demangle(const(char)[], char[])

void core.demangle.Demangle.overflow(immutable(char)[])

Used by:

• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])

Uses:

• core.demangle.Demangle.OverflowException.__Class
• _d_throw_exception

void core.demangle.Demangle.parseReal()

Used by:

• void core.demangle.Demangle.parseValue(char[], char)

Uses:

• strtold@plt
• snprintf@plt
• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.put(const(char)[])

char[] core.demangle.Demangle.parseType(char[])

Used by:

• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• char[] core.demangle.Demangle.parseQualifiedName()
• void core.demangle.Demangle.parseFuncArguments()
• void core.demangle.Demangle.parseMangledName()
• void core.demangle.Demangle.parseTemplateArgs()

Uses:

• char[] core.demangle.Demangle.parseQualifiedName()
• _d_arraysetlengthiT
• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• void core.demangle.Demangle.error(immutable(char)[])
• char[] core.demangle.Demangle.put(const(char)[])
• void core.demangle.Demangle.overflow(immutable(char)[])

char[] core.demangle.demangle(const(char)[], char[])

Used by:

• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo7fixlineMxFAxaKG4096aZAxa

Uses:

• char[] core.demangle.Demangle.doDemangle!(_D4core8demangle8Demangle16parseMangledNameMFZv).doDemangle()
• core.demangle.Demangle.__init

core.exception.RangeError.__init

Used by:

• onRangeError

core.exception.AssertError.__init

Used by:

• _d_assert
• _d_assert_msg

core.exception.FinalizeError.__init

Used by:

• onFinalizeError

const(@safe immutable(char)[] function()) core.exception.FinalizeError.toString

Uses:

• _d_arraycatT

nothrow void function(immutable(char)[], ulong, immutable(char)[])* core.exception._assertHandler

Used by:

• _d_assert
• _d_assert_msg

core.exception.OutOfMemoryError.__Class

Used by:

• onOutOfMemoryError

const(@trusted immutable(char)[] function()) core.exception.OutOfMemoryError.toString

Uses:

• immutable(char)[] object.Throwable.toString()

core.exception.UnicodeException.__init

Used by:

• onUnicodeError

core.exception.InvalidMemoryOperationError.__Class

Used by:

• onInvalidMemoryOperationError

const(@trusted immutable(char)[] function()) core.exception.InvalidMemoryOperationError.toString

Uses:

• immutable(char)[] object.Throwable.toString()

pure nothrow @property object.ModuleInfo*[] object.ModuleInfo.importedModules()

Used by:

• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)

pure nothrow @property void function()* object.ModuleInfo.ctor()

Used by:

• void rt.minfo.ModuleGroup.runCtors()

pure nothrow @property void function()* object.ModuleInfo.dtor()

Used by:

• void rt.minfo.ModuleGroup.runDtors()
• extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody1(ref rt.sections_linux.DSO)

pure nothrow @property immutable(char)[] object.ModuleInfo.name()

Used by:

• _d_array_bounds
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))

Uses:

• strlen@plt

pure nothrow @property uint object.ModuleInfo.flags()

Used by:

• void rt.minfo.ModuleGroup.runDtors()
• extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody1(ref rt.sections_linux.DSO)
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• void rt.minfo.ModuleGroup.runCtors()

pure nothrow @property void object.ModuleInfo.flags(uint)

Used by:

• void rt.minfo.ModuleGroup.runDtors()
• extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody1(ref rt.sections_linux.DSO)
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• void rt.minfo.ModuleGroup.runCtors()

pure nothrow @property void function()* object.ModuleInfo.ictor()

Used by:

• void rt.minfo.ModuleGroup.runCtors()

int object.ModuleInfo.opApply(scope int delegate(ref object.ModuleInfo*))

Used by:

• runModuleUnitTests

Uses:

• int rt.minfo.moduleinfos_apply(scope int delegate(ref object.ModuleInfo*))

pure nothrow @property void function()* object.ModuleInfo.tlsctor()

Used by:

• extern (C) void rt.minfo.rt_moduleTlsCtor().int __foreachbody1(ref rt.sections_linux.DSO)
• void rt.minfo.ModuleGroup.runTlsCtors()

pure nothrow @property void function()* object.ModuleInfo.tlsdtor()

Used by:

• void rt.minfo.ModuleGroup.runTlsDtors()
• extern (C) void rt.minfo.rt_moduleTlsDtor().int __foreachbody1(ref rt.sections_linux.DSO)

pure nothrow @property void function()* object.ModuleInfo.unitTest()

Used by:

• extern (C) bool core.runtime.runModuleUnitTests().int __foreachbody3(ref object.ModuleInfo*)

object.Throwable.TraceInfo function(void*)* object.traceHandler

Used by:

• rt_setTraceHandler

object.TypeInfo_Array.nextinout(pure nothrow @property inout(TypeInfo) function())

const(void function(void*, void*)) object.TypeInfo_Array.swap

const(pure nothrow @property @safe uint function()) object.TypeInfo_Array.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Array.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_Array.equals

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Array.talign

const(int function(const(void*), const(void*))) object.TypeInfo_Array.compare

const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_Array.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

nothrow @safe int object.TypeInfo_Array.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Array.opEquals(Object)

Uses:

• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Array.toString

Uses:

• _d_arraycatT

const(pure nothrow @property @safe const(TypeInfo_Class) function()) object.TypeInfo_Class.info

const(pure nothrow @property @safe uint function()) object.TypeInfo_Class.flags

const(pure nothrow @property const(object.OffsetTypeInfo)[] function()) object.TypeInfo_Class.offTi

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Class.tsize

const(Object function()) object.TypeInfo_Class.create

Uses:

• _d_newclass

const(bool function(const(void*), const(void*))) object.TypeInfo_Class.equals

const(pure nothrow @property @safe immutable(void)* function()) object.TypeInfo_Class.rtInfo

const(int function(const(void*), const(void*))) object.TypeInfo_Class.compare

const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_Class.getHash

bool object.TypeInfo_Class.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Class.toString

const(pure nothrow @property @safe const(TypeInfo_Class) function()) object.TypeInfo_Class.typeinfo

const(pure nothrow @safe const(void)[] function()) object.TypeInfo_Const.init

object.TypeInfo_Const.nextinout(pure nothrow @property inout(TypeInfo) function())

const(void function(void*, void*)) object.TypeInfo_Const.swap

const(pure nothrow @property @safe uint function()) object.TypeInfo_Const.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Const.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_Const.equals

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Const.talign

const(int function(const(void*), const(void*))) object.TypeInfo_Const.compare

const(nothrow @safe ulong function(const(void*))) object.TypeInfo_Const.getHash

nothrow @safe int object.TypeInfo_Const.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Const.opEquals(Object)

Uses:

• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Const.toString

Uses:

• _d_arraycatnT

const(immutable(char)[] function()) object.TypeInfo_Inout.toString

Uses:

• _d_arraycatnT

const(void function(void*, void*)) object.TypeInfo_Tuple.swap

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Tuple.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_Tuple.equals

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Tuple.talign

const(int function(const(void*), const(void*))) object.TypeInfo_Tuple.compare

const(void function(void*)) object.TypeInfo_Tuple.destroy

const(nothrow @safe ulong function(const(void*))) object.TypeInfo_Tuple.getHash

nothrow @safe int object.TypeInfo_Tuple.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Tuple.opEquals(Object)

Uses:

• _d_dynamic_cast

const(void function(void*)) object.TypeInfo_Tuple.postblit

const(immutable(char)[] function()) object.TypeInfo_Tuple.toString

Uses:

• _d_arrayappendcTX
• _d_arrayappendT

const(immutable(char)[] function()) object.TypeInfo_Shared.toString

Uses:

• _d_arraycatnT

const(pure nothrow @safe const(void)[] function()) object.TypeInfo_Struct.init

const(pure nothrow @property @safe uint function()) object.TypeInfo_Struct.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Struct.tsize

const(pure nothrow @trusted bool function(const(void*), const(void*))) object.TypeInfo_Struct.equals

Uses:

• memcmp@plt

const(pure nothrow @property @safe immutable(void)* function()) object.TypeInfo_Struct.rtInfo

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Struct.talign

const(pure nothrow @trusted int function(const(void*), const(void*))) object.TypeInfo_Struct.compare

Uses:

• memcmp@plt

const(void function(void*)) object.TypeInfo_Struct.destroy

const(pure nothrow @safe ulong function(const(void*))) object.TypeInfo_Struct.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

nothrow @safe int object.TypeInfo_Struct.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Struct.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

const(void function(void*)) object.TypeInfo_Struct.postblit

const(immutable(char)[] function()) object.TypeInfo_Struct.toString

const(pure nothrow @safe const(void)[] function()) object.TypeInfo_Vector.init

object.TypeInfo_Vector.nextinout(pure nothrow @property inout(TypeInfo) function())

const(void function(void*, void*)) object.TypeInfo_Vector.swap

const(pure nothrow @property @safe uint function()) object.TypeInfo_Vector.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Vector.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_Vector.equals

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Vector.talign

const(int function(const(void*), const(void*))) object.TypeInfo_Vector.compare

const(nothrow @safe ulong function(const(void*))) object.TypeInfo_Vector.getHash

nothrow @safe int object.TypeInfo_Vector.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Vector.opEquals(Object)

Uses:

• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Vector.toString

Uses:

• _d_arraycatnT

pure nothrow @property immutable(char)[] object.MemberInfo_field.name()

pure nothrow @property ulong object.MemberInfo_field.offset()

pure nothrow @property TypeInfo object.MemberInfo_field.typeInfo()

object.TypeInfo_Pointer.nextinout(pure nothrow @property inout(TypeInfo) function())

const(void function(void*, void*)) object.TypeInfo_Pointer.swap

const(pure nothrow @property @safe uint function()) object.TypeInfo_Pointer.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Pointer.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_Pointer.equals

const(int function(const(void*), const(void*))) object.TypeInfo_Pointer.compare

const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_Pointer.getHash

bool object.TypeInfo_Pointer.opEquals(Object)

Uses:

• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Pointer.toString

Uses:

• _d_arraycatT

const(pure nothrow @safe const(void)[] function()) object.TypeInfo_Typedef.init

object.TypeInfo_Typedef.nextinout(pure nothrow @property inout(TypeInfo) function())

const(void function(void*, void*)) object.TypeInfo_Typedef.swap

const(pure nothrow @property @safe uint function()) object.TypeInfo_Typedef.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Typedef.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_Typedef.equals

const(pure nothrow @property @safe immutable(void)* function()) object.TypeInfo_Typedef.rtInfo

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Typedef.talign

const(int function(const(void*), const(void*))) object.TypeInfo_Typedef.compare

const(nothrow @safe ulong function(const(void*))) object.TypeInfo_Typedef.getHash

nothrow @safe int object.TypeInfo_Typedef.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Typedef.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Typedef.toString

const(pure nothrow @property @safe uint function()) object.TypeInfo_Delegate.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Delegate.tsize

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Delegate.talign

nothrow @safe int object.TypeInfo_Delegate.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_Delegate.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Delegate.toString

Uses:

• _d_arraycatT

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Function.tsize

bool object.TypeInfo_Function.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Function.toString

Uses:

• _d_arraycatT

pure nothrow @property ulong object.capacity!(immutable(char)[]).capacity(immutable(char)[][])

Used by:

• std.array.Appender.TAAyaZ.Appender.__ctor.MFNaNbNcNfAAyaZS3std5array18__T8AppenderTAAyaZ8Appender9__lambda2MFNbNeZm

Uses:

• _d_arraysetcapacity

const(pure nothrow @property @safe uint function()) object.TypeInfo_Interface.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_Interface.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_Interface.equals

const(int function(const(void*), const(void*))) object.TypeInfo_Interface.compare

const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_Interface.getHash

bool object.TypeInfo_Interface.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_Interface.toString

const(immutable(char)[] function()) object.TypeInfo_Invariant.toString

Uses:

• _d_arraycatnT

pure nothrow @property void* object.MemberInfo_function.fp()

pure nothrow @property immutable(char)[] object.MemberInfo_function.name()

pure nothrow @property uint object.MemberInfo_function.flags()

pure nothrow @property TypeInfo object.MemberInfo_function.typeInfo()

const(pure nothrow @safe const(void)[] function()) object.TypeInfo_StaticArray.init

object.TypeInfo_StaticArray.nextinout(pure nothrow @property inout(TypeInfo) function())

const(void function(void*, void*)) object.TypeInfo_StaticArray.swap

Uses:

• pure nothrow void core.memory.GC.free(void*)
• _d_newarrayT
• memcpy@plt

const(pure nothrow @property @safe uint function()) object.TypeInfo_StaticArray.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_StaticArray.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo_StaticArray.equals

const(pure nothrow @property @safe ulong function()) object.TypeInfo_StaticArray.talign

const(int function(const(void*), const(void*))) object.TypeInfo_StaticArray.compare

const(void function(void*)) object.TypeInfo_StaticArray.destroy

const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_StaticArray.getHash

nothrow @safe int object.TypeInfo_StaticArray.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_StaticArray.opEquals(Object)

Uses:

• _d_dynamic_cast

const(void function(void*)) object.TypeInfo_StaticArray.postblit

const(immutable(char)[] function()) object.TypeInfo_StaticArray.toString

Uses:

• _d_arraycatT
• _d_arraycatnT

ref inout(char[]) object.assumeSafeAppend!(char).assumeSafeAppend(ref inout(char[]))

Used by:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()

Uses:

• _d_arrayshrinkfit

object.TypeInfo_AssociativeArray.nextinout(pure nothrow @property inout(TypeInfo) function())

const(pure nothrow @property @safe uint function()) object.TypeInfo_AssociativeArray.flags

const(pure nothrow @property @safe ulong function()) object.TypeInfo_AssociativeArray.tsize

const(@trusted bool function(const(void*), const(void*))) object.TypeInfo_AssociativeArray.equals

Uses:

• _aaEqual

const(pure nothrow @property @safe ulong function()) object.TypeInfo_AssociativeArray.talign

const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_AssociativeArray.getHash

Uses:

• _aaGetHash

nothrow @safe int object.TypeInfo_AssociativeArray.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo_AssociativeArray.opEquals(Object)

Uses:

• _d_dynamic_cast

const(immutable(char)[] function()) object.TypeInfo_AssociativeArray.toString

Uses:

• _d_arraycatnT

pure nothrow @safe object.Error object.Error.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• _d_assert
• onRangeError
• _d_assert_msg
• onFinalizeError

void object.destroy!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl).destroy(ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl)

Used by:

• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv

Uses:

• _d_array_bounds
• memset@plt
• _d_array_slice_copy

int object.Object.opCmp(Object)

Uses:

• _d_throw_exception
• _d_arraycatT
• _d_newclass
• Exception.__init

nothrow @trusted ulong object.Object.toHash()

bool object.Object.opEquals(Object)

immutable(char)[] object.Object.toString()

const(pure nothrow @safe const(void)[] function()) object.TypeInfo.init

object.TypeInfo.nextinout(pure nothrow @property inout(TypeInfo) function())

const(void function(void*, void*)) object.TypeInfo.swap

const(pure nothrow @property @safe uint function()) object.TypeInfo.flags

const(const(object.OffsetTypeInfo)[] function()) object.TypeInfo.offTi

int object.TypeInfo.opCmp(Object)

Uses:

• _d_dynamic_cast
• pure nothrow @trusted int rt.util.string.dstrcmp(const(char[]), const(char[]))

const(pure nothrow @property @safe ulong function()) object.TypeInfo.tsize

const(bool function(const(void*), const(void*))) object.TypeInfo.equals

const(pure nothrow @property @safe immutable(void)* function()) object.TypeInfo.rtInfo

const(pure nothrow @property @safe ulong function()) object.TypeInfo.talign

const(nothrow @trusted ulong function()) object.TypeInfo.toHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)
• _d_eh_resume_unwind

const(int function(const(void*), const(void*))) object.TypeInfo.compare

const(void function(void*)) object.TypeInfo.destroy

const(nothrow @trusted ulong function(const(void*))) object.TypeInfo.getHash

nothrow @safe int object.TypeInfo.argTypes(out TypeInfo, out TypeInfo)

bool object.TypeInfo.opEquals(Object)

Used by:

• bool rt.typeinfo.ti_Aint.TypeInfo_Ai.opEquals(Object)
• bool rt.typeinfo.ti_Ag.TypeInfo_Ag.opEquals(Object)
• bool rt.typeinfo.ti_Ashort.TypeInfo_As.opEquals(Object)
• bool rt.typeinfo.ti_Along.TypeInfo_Al.opEquals(Object)

Uses:

• _adEq2
• _d_dynamic_cast

const(void function(void*)) object.TypeInfo.postblit

const(immutable(char)[] function()) object.TypeInfo.toString

bool object.opEquals(Object, Object)

Used by:

• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)
• _d_eh_handle_collision
• void std.concurrency._staticDtor1()
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(void).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• void core.thread.Thread.remove(core.thread.Thread)
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)

bool object.opEquals(const(Object), const(Object))

Used by:

• bool std.concurrency.Tid.__xopEquals(ref const(std.concurrency.Tid), ref const(std.concurrency.Tid))
• bool ldc.eh._d_exception.__xopEquals(ref const(ldc.eh._d_exception), ref const(ldc.eh._d_exception))

pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

Used by:

• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(void).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• void core.thread.suspend(core.thread.Thread)
• const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec
• void core.thread.resume(core.thread.Thread)
• std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• pure nothrow @safe std.format.FormatException std.format.FormatException.__ctor()
• @trusted void core.time.TickDuration._sharedStaticCtor1()
• @trusted std.variant.VariantException std.variant.VariantException.__ctor(TypeInfo, TypeInfo)
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• pure @safe void std.utf.encode(ref char[], dchar)
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• pure nothrow @safe core.sync.exception.SyncException core.sync.exception.SyncException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_array_slice_copy
• onUnicodeError
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• @trusted int std.variant.VariantN!(32uL).VariantN.opCmp!(std.variant.VariantN!(32uL).VariantN).opCmp(std.variant.VariantN!(32uL).VariantN)
• thread_joinAll
• void core.thread.Thread.sleep(core.time.Duration)

immutable(char)[] object.Throwable.toString()

Used by:

• const(@trusted immutable(char)[] function()) core.exception.OutOfMemoryError.toString
• const(@trusted immutable(char)[] function()) core.exception.InvalidMemoryOperationError.toString
• immutable(char)[] std.utf.UTFException.toString()

immutable(char)[] object.Throwable.toString().nothrow @safe void __lambda1!(const(char[])).__lambda1(const(char[]))

Uses:

• _d_arrayappendT

const(void function(scope void delegate(const(char[])))) object.Throwable.toString

Uses:

• _d_toObject
• _d_eh_resume_unwind

const(void function(scope void delegate(const(char[])))) object.Throwable.toString.int __foreachbody2(ref const(char[]))

void pipeline.main().pure @safe immutable(char)[] __lambda1!(char[]).__lambda1(char[])

Used by:

• @property immutable(char)[] std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.front()

Uses:

• _adDupT

Exception.__init

Used by:

• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• _d_array_slice_copy
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• int object.Object.opCmp(Object)

_Dmain

Uses:

• std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.map!(main9__lambda1).map!(std.stdio.File.ByLine!(char, char).ByLine).map(std.stdio.File.ByLine!(char, char).ByLine)
• _adSort
• std.stdio.File.LockingTextWriter std.algorithm.copy!(immutable(char)[][], std.stdio.File.LockingTextWriter).copy(immutable(char)[][], std.stdio.File.LockingTextWriter)
• void std.stdio.File.LockingTextWriter.__dtor()
• std.stdio.File.LockingTextWriter std.stdio.File.lockingTextWriter()
• std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.byLine!(char, char).byLine(std.string.KeepTerminator, char)
• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)

_STD_critical_term

Used by:

• rt_init
• rt_term

Uses:

• rt.critical_.D_CRITICAL_SECTION* rt.critical_.dcs_list
• pthread_mutex_destroy@plt

_STD_monitor_staticdtor

Used by:

• rt_init
• rt_term

Uses:

• pthread_mutex_destroy@plt
• int rt.monitor_.inited
• pthread_mutexattr_destroy@plt

_STI_critical_init

Used by:

• rt_init

Uses:

• rt.critical_.D_CRITICAL_SECTION* rt.critical_.dcs_list
• pthread_mutexattr_init@plt
• pthread_mutexattr_settype@plt
• pthread_mutex_init@plt

_STI_monitor_staticctor

Used by:

• rt_init

Uses:

• pthread_mutexattr_init@plt
• pthread_mutexattr_settype@plt
• pthread_mutex_init@plt
• int rt.monitor_.inited

_Unwind_GetDataRelBase@plt

Used by:

• ubyte* ldc.eh.get_encoded_value(ubyte*, ref ulong, ubyte, void*)

_Unwind_GetIP@plt

Used by:

• _d_eh_personality

_Unwind_GetLanguageSpecificData@plt

Used by:

• void ldc.eh._d_getLanguageSpecificTables(void*, ref ubyte*, ref ubyte*, ref ubyte*, ref ubyte)

_Unwind_GetRegionStart@plt

Used by:

• _d_eh_personality
• ubyte* ldc.eh.get_encoded_value(ubyte*, ref ulong, ubyte, void*)

_Unwind_GetTextRelBase@plt

Used by:

• ubyte* ldc.eh.get_encoded_value(ubyte*, ref ulong, ubyte, void*)

_Unwind_RaiseException@plt

Used by:

• _d_throw_exception

_Unwind_Resume@plt

Used by:

• _d_eh_resume_unwind
• _d_eh_handle_collision

_Unwind_SetGR@plt

Used by:

• _d_eh_personality

_Unwind_SetIP@plt

Used by:

• _d_eh_personality

__daylight@@GLIBC_2.2.5

Used by:

• const(nothrow @property bool function()) std.datetime.LocalTime.hasDST

__errno_location@plt

Used by:

• getErrno
• setErrno

__gmon_start__@plt

__init_array_end

Used by:

• _start
• __libc_csu_init

__init_array_start

Used by:

• __libc_csu_init

__libc_csu_fini

__libc_csu_init

Uses:

• __init_array_start
• __init_array_end

__libc_start_main@plt

Used by:

• _start

__progname_full@@GLIBC_2.2.5

Used by:

• nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))

__tls_get_addr@plt

Used by:

• _d_dso_registry

__tzname@@GLIBC_2.2.5

Used by:

• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.stdName
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName

_aApplycd1

Used by:

• void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[])

Uses:

• dchar rt.util.utf.decode(const(char[]), ref ulong)

_aaDelX

Used by:

• void std.concurrency._staticDtor3()
• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)

Uses:

• pure nothrow void core.memory.GC.free(void*)

_aaEqual

Used by:

• const(@trusted bool function(const(void*), const(void*))) object.TypeInfo_AssociativeArray.equals

Uses:

• _d_dynamic_cast

_aaGetHash

Used by:

• const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_AssociativeArray.getHash

Uses:

• _d_dynamic_cast
• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong)

_aaInX

Used by:

• void std.concurrency._staticDtor3()

_aaKeys

Used by:

• void std.concurrency._staticDtor1()

Uses:

• pure nothrow void* core.memory.GC.malloc(ulong, uint)
• memcpy@plt

_adDupT

Used by:

• void pipeline.main().pure @safe immutable(char)[] __lambda1!(char[]).__lambda1(char[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong).to(ulong)
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure @safe immutable(char)[] std.conv.text!(immutable(char)[], const(char)[]).text(immutable(char)[], const(char)[])
• pure immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)*).to(const(char)*)
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

Uses:

• _d_dynamic_cast
• gc_qalloc
• memcpy@plt

_adEq2

Used by:

• _d_eh_personality
• bool object.TypeInfo_Delegate.opEquals(Object)
• bool std.array.Appender!(immutable(char)[][]).Appender.Data.__xopEquals(ref const(std.array.Appender!(immutable(char)[][]).Appender.Data), ref const(std.array.Appender!(immutable(char)[][]).Appender.Data))
• bool std.array.Appender!(immutable(char)[]).Appender.Data.__xopEquals(ref const(std.array.Appender!(immutable(char)[]).Appender.Data), ref const(std.array.Appender!(immutable(char)[]).Appender.Data))
• bool object.TypeInfo_Typedef.opEquals(Object)
• bool object.TypeInfo_Function.opEquals(Object)
• bool object.TypeInfo_Interface.opEquals(Object)
• bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__xopEquals(ref const(std.stdio.File.ByLineImpl!(char, char).ByLineImpl), ref const(std.stdio.File.ByLineImpl!(char, char).ByLineImpl))
• bool object.TypeInfo_Class.opEquals(Object)
• bool object.TypeInfo.opEquals(Object)
• bool object.TypeInfo_Struct.opEquals(Object)

_adSort

Used by:

• _Dmain

Uses:

• qsort_r@plt

_d_allocmemoryT

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)
• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• _d_throw_exception
• pure nothrow ref @safe std.array.Appender!(immutable(char)[][]).Appender std.array.Appender!(immutable(char)[][]).Appender.__ctor(immutable(char)[][])
• void std.concurrency.MessageBox.put(ref std.concurrency.Message)
• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

Uses:

• gc_malloc

_d_array_bounds

Used by:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)
• const(nothrow long function(long)) std.datetime.PosixTimeZone.utcToTZ
• pure nothrow @safe void std.array.popFront!(immutable(char)[]).popFront(ref immutable(char)[][])
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)
• pure nothrow @safe void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[]).put(ref std.array.Appender!(immutable(char)[]).Appender, immutable(char)[])
• pure nothrow ref @property @safe immutable(char)[] std.array.front!(immutable(char)[]).front(immutable(char)[][])
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)
• const(nothrow int function(long)) std.datetime.PosixTimeZone.calculateLeapSeconds
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])
• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int)
• pure nothrow @safe void std.format.formatUnsigned!(std.array.Appender!(immutable(char)[]).Appender, char).formatUnsigned(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec, uint, bool)
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException invalidUTF()
• const(nothrow long function(long)) std.datetime.PosixTimeZone.tzToUTC
• std.array.Appender.TAAyaZ.Appender.__ctor.MFNaNbNcNfAAyaZS3std5array18__T8AppenderTAAyaZ8Appender9__lambda3MFNbNeZAAya
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[]).pure nothrow @trusted immutable(char)[][] bigDataFun()
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted immutable(char)[][] __lambda6()
• void object.destroy!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl).destroy(ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException outOfBounds()
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)
• const(nothrow bool function(long)) std.datetime.PosixTimeZone.dstInEffect
• pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)
• void std.stdio.File.LockingTextWriter.put!(dchar).put(dchar)

Uses:

• onRangeError
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()

_d_array_slice_copy

Used by:

• void object.destroy!(std.stdio.File.ByLineImpl!(char, char).ByLineImpl).destroy(ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl)
• pure nothrow @safe void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[]).put(ref std.array.Appender!(immutable(char)[]).Appender, immutable(char)[])
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)

Uses:

• _d_throw_exception
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• memcpy@plt
• Exception.__init

_d_arrayappendT

Used by:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMxFZAya14__foreachbody1MFNfKmKxAaZi
• pure @safe immutable(char)[] std.conv.text!(immutable(char)[], const(char)[]).text(immutable(char)[], const(char)[])
• immutable(char)[] object.Throwable.toString().nothrow @safe void __lambda1!(const(char[])).__lambda1(const(char[]))
• immutable(char)[] std.utf.UTFException.toString()
• pure @safe void std.utf.encode(ref char[], dchar)
• const(immutable(char)[] function()) object.TypeInfo_Tuple.toString
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)

Uses:

• _d_dynamic_cast
• _d_arrayappendcTX
• memcpy@plt

_d_arrayappendcTX

Used by:

• pure @safe void std.utf.encode(ref char[], dchar)
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• const(immutable(char)[] function()) object.TypeInfo_Tuple.toString
• _d_arrayappendT

Uses:

• malloc@plt
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• pure nothrow @safe int core.bitop.bsr(ulong)
• gc_query
• _d_dynamic_cast
• gc_extend
• gc_qalloc
• memcpy@plt

_d_arraycatT

Used by:

• const(immutable(char)[] function()) object.TypeInfo_StaticArray.toString
• const(immutable(char)[] function()) object.TypeInfo_Delegate.toString
• core.runtime.defaultTraceHandler.FPvZC6object9Throwable9TraceInfo16DefaultTraceInfo8toStringMxFZAya14__foreachbody1MFNfKmKxAaZi
• const(immutable(char)[] function()) object.TypeInfo_Pointer.toString
• const(@safe immutable(char)[] function()) core.exception.FinalizeError.toString
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• int object.Object.opCmp(Object)
• const(immutable(char)[] function()) object.TypeInfo_Array.toString
• const(immutable(char)[] function()) object.TypeInfo_Function.toString

Uses:

• _d_dynamic_cast
• gc_qalloc
• memcpy@plt

_d_arraycatnT

Used by:

• std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)
• @trusted std.variant.VariantException std.variant.VariantException.__ctor(TypeInfo, TypeInfo)
• const(immutable(char)[] function()) object.TypeInfo_StaticArray.toString
• const(immutable(char)[] function()) object.TypeInfo_Vector.toString
• const(immutable(char)[] function()) object.TypeInfo_Const.toString
• const(immutable(char)[] function()) object.TypeInfo_AssociativeArray.toString
• const(immutable(char)[] function()) object.TypeInfo_Invariant.toString
• const(immutable(char)[] function()) object.TypeInfo_Shared.toString
• void std.stdio.File.close()
• @trusted int std.variant.VariantN!(32uL).VariantN.opCmp!(std.variant.VariantN!(32uL).VariantN).opCmp(std.variant.VariantN!(32uL).VariantN)
• const(immutable(char)[] function()) object.TypeInfo_Inout.toString

Uses:

• _d_dynamic_cast
• gc_qalloc
• memcpy@plt

_d_arraysetcapacity

Used by:

• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• pure nothrow @property ulong object.capacity!(immutable(char)[]).capacity(immutable(char)[][])
• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)

Uses:

• malloc@plt
• gc_query
• gc_extend
• _d_dynamic_cast
• memset@plt
• onOutOfMemoryError
• gc_qalloc
• memcpy@plt

_d_arraysetlengthT

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)

Uses:

• malloc@plt
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• gc_query
• memset@plt
• _d_dynamic_cast
• gc_extend
• onOutOfMemoryError
• gc_qalloc
• memcpy@plt

_d_arraysetlengthiT

Used by:

• char[] core.demangle.Demangle.doDemangle!(_D4core8demangle8Demangle16parseMangledNameMFZv).doDemangle()
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• char[] core.demangle.Demangle.put(const(char)[])
• char[] core.demangle.Demangle.parseType(char[])

Uses:

• malloc@plt
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• gc_query
• _d_dynamic_cast
• gc_extend
• memset@plt
• onOutOfMemoryError
• gc_qalloc
• memcpy@plt

_d_arrayshrinkfit

Used by:

• ref inout(char[]) object.assumeSafeAppend!(char).assumeSafeAppend(ref inout(char[]))

Uses:

• malloc@plt
• gc_query

_d_assert

Used by:

• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()
• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• pure nothrow ref @safe std.array.Appender!(immutable(char)[][]).Appender std.array.Appender!(immutable(char)[][]).Appender.__ctor(immutable(char)[][])
• pure nothrow @safe void std.stdio.File.ByLine!(char, char).ByLine.__fieldPostBlit()
• pure nothrow @safe void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__fieldPostBlit()
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__fieldPostBlit()
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit.MFNaNbNfZv
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv

Uses:

• pure nothrow @safe object.Error object.Error.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_newclass
• core.exception.AssertError.__init
• nothrow void function(immutable(char)[], ulong, immutable(char)[])* core.exception._assertHandler

_d_assert_msg

Used by:

• pure nothrow @safe void std.array.popFront!(immutable(char)[]).popFront(ref immutable(char)[][])
• pure @property @safe dchar std.array.back!(char).back(char[])
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.isInitialized.MxFNaNbNdNfZb
• pure nothrow ref @property @safe immutable(char)[] std.array.front!(immutable(char)[]).front(immutable(char)[][])
• std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.byLine!(char, char).byLine(std.string.KeepTerminator, char)
• void std.stdio.File.LockingTextWriter.put!(immutable(char)[]).put(immutable(char)[])
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])
• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• @property char[] std.stdio.File.ByLineImpl!(char, char).ByLineImpl.front()
• ulong std.stdio.File.readln!(char).readln(ref char[], dchar)
• std.typecons.RefCounted.TS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayload.MNgFNaNbNcNdNfZNgS3std5stdio4File20__T10ByLineImplTaTaZ10ByLineImpl
• @property char[] std.stdio.File.ByLine!(char, char).ByLine.front()
• void std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.popFront()
• @property bool std.stdio.File.ByLine!(char, char).ByLine.empty()
• void std.stdio.File.ByLineImpl!(char, char).ByLineImpl.popFront()
• @property immutable(char)[] std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.front()
• @property bool std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.empty()
• std.array.Appender!(immutable(char)[][]).Appender.datainout(pure nothrow @property @trusted inout(immutable(char)[])[] function())
• @property bool std.stdio.File.ByLineImpl!(char, char).ByLineImpl.empty()
• void std.stdio.File.ByLine!(char, char).ByLine.popFront()
• void std.stdio.File.LockingTextWriter.put!(dchar).put(dchar)

Uses:

• pure nothrow @safe object.Error object.Error.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw_exception
• _d_newclass
• core.exception.AssertError.__init
• nothrow void function(immutable(char)[], ulong, immutable(char)[])* core.exception._assertHandler

_d_dso_registry

Used by:

• ldc.dso_ctor.3std8bitmanip
• ldc.dso_ctor.2rt5minfo
• ldc.dso_ctor.2rt8typeinfo7ti_real
• ldc.dso_ctor.2rt8typeinfo8ti_float
• ldc.dso_ctor.4core4sync9condition
• ldc.dso_ctor.2rt4util4hash
• ldc.dso_ctor.3std4file
• ldc.dso_ctor.2rt8typeinfo8ti_short
• ldc.dso_ctor.2gc5proxy
• ldc.dso_ctor.2rt8typeinfo5ti_Ag
• ldc.dso_ctor.3std4path
• ldc.dso_ctor.3std5range
• ldc.dso_ctor.2rt8typeinfo8ti_wchar
• ldc.dso_ctor.2gc2os
• ldc.dso_ctor.3std11concurrency
• ldc.dso_ctor.3std7process
• ldc.dso_ctor.3std8internal12unicode_comp
• ldc.dso_ctor.3std6format
• ldc.dso_ctor.3std5stdio
• ldc.dso_ctor.4core4stdc5errno
• ldc.dso_ctor.3ldc9arrayinit
• ldc.dso_ctor.2rt4util3utf
• ldc.dso_ctor.2rt8typeinfo8ti_ireal
• ldc.dso_ctor.2rt8monitor_
• ldc.dso_ctor.3std5array
• ldc.dso_ctor.2rt8typeinfo9ti_Ashort
• ldc.dso_ctor.4core7runtime
• ldc.dso_ctor.3std9exception
• ldc.dso_ctor.2rt8lifetime
• ldc.dso_ctor.2rt8typeinfo9ti_ushort
• ldc.dso_ctor.2rt8typeinfo8ti_ubyte
• ldc.dso_ctor.2rt8typeinfo7ti_uint
• ldc.dso_ctor.8pipeline
• ldc.dso_ctor.2rt5tlsgc
• ldc.dso_ctor.2rt14sections_linux
• ldc.dso_ctor.4core3sys5posix3sys4wait
• ldc.dso_ctor.2rt8typeinfo7ti_void
• ldc.dso_ctor.2rt9critical_
• ldc.dso_ctor.4core6memory
• ldc.dso_ctor.2rt6aApply
• ldc.dso_ctor.2rt3aaA
• ldc.dso_ctor.3std3uni
• ldc.dso_ctor.4core9exception
• ldc.dso_ctor.4core8demangle
• ldc.dso_ctor.3std3utf
• ldc.dso_ctor.4core4time
• ldc.dso_ctor.2rt8typeinfo8ti_creal
• ldc.dso_ctor.2rt8typeinfo8ti_Along
• ldc.dso_ctor.4core4sync5mutex
• ldc.dso_ctor.2rt7switch_
• ldc.dso_ctor.6object
• ldc.dso_ctor.4core6thread
• ldc.dso_ctor.2rt8typeinfo8ti_ulong
• ldc.dso_ctor.4core4sync6config
• ldc.dso_ctor.2rt6memory
• ldc.dso_ctor.2rt5cast_
• ldc.dso_dtor
• ldc.dso_ctor.2rt8typeinfo8ti_dchar
• ldc.dso_ctor.2rt8typeinfo7ti_byte
• ldc.dso_ctor.4core3sys5posix5netdb
• ldc.dso_ctor.2rt4util6string
• ldc.dso_ctor.2rt8typeinfo9ti_double
• ldc.dso_ctor.2rt8typeinfo7ti_Aint
• ldc.dso_ctor.2rt8typeinfo10ti_idouble
• ldc.dso_ctor.3std6string
• ldc.dso_ctor.3std8internal14unicode_tables
• ldc.dso_ctor.2rt7aApplyR
• ldc.dso_ctor.2rt8typeinfo9ti_cfloat
• ldc.dso_ctor.2rt3adi
• ldc.dso_ctor.2rt4util9container
• ldc.dso_ctor.3std7variant
• ldc.dso_ctor.2gc2gc
• ldc.dso_ctor.3std8datetime
• ldc.dso_ctor.2rt6dmain2
• ldc.dso_ctor.2gc4bits
• ldc.dso_ctor.3std9stdiobase
• ldc.dso_ctor.4core5bitop
• ldc.dso_ctor.3ldc2eh
• ldc.dso_ctor.2rt5qsort
• ldc.dso_ctor.4core4sync9exception
• ldc.dso_ctor.2rt8typeinfo7ti_char
• ldc.dso_ctor.2rt8typeinfo7ti_long
• ldc.dso_ctor.2rt8typeinfo9ti_ifloat
• ldc.dso_ctor.3std9algorithm
• ldc.dso_ctor.3std5ascii
• ldc.dso_ctor.3std4conv
• ldc.dso_ctor.2rt8typeinfo10ti_cdouble
• ldc.dso_ctor.2rt8typeinfo6ti_int

Uses:

• void rt.minfo.ModuleGroup.runDtors()
• ref rt.minfo.ModuleGroup rt.minfo.ModuleGroup.__ctor(object.ModuleInfo*[])
• nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))
• rt.util.container.Array!(rt.sections_linux.DSO*).Array rt.sections_linux._loadedDSOs
• dl_iterate_phdr@plt
• void rt.minfo.ModuleGroup.runCtors()
• calloc@plt
• free@plt
• void rt.minfo.ModuleGroup.sortCtors()
• void rt.minfo.ModuleGroup.runTlsDtors()
• memset@plt
• bool rt.sections_linux._isRuntimeInitialized
• void* rt.util.container.xrealloc(void*, ulong)
• rt.minfo.ModuleGroup.modulesinout(@property inout(object.ModuleInfo*)[] function())
• nothrow void core.memory.GC.removeRange(const(void*))
• __tls_get_addr@plt
• nothrow void core.memory.GC.addRange(const(void*), ulong)
• void rt.minfo.ModuleGroup.runTlsCtors()

_d_dynamic_cast

Used by:

• void rt.dmain2.printThrowable(object.Throwable)
• bool object.TypeInfo_Function.opEquals(Object)
• _d_arraysetlengthT
• _d_arraycatT
• _aaGetHash
• bool object.TypeInfo_Const.opEquals(Object)
• _d_arrayappendcTX
• bool object.TypeInfo_Array.opEquals(Object)
• bool object.TypeInfo_Pointer.opEquals(Object)
• int object.TypeInfo.opCmp(Object)
• _d_arraycatnT
• bool object.TypeInfo_Struct.opEquals(Object)
• _d_arraysetcapacity
• _d_eh_handle_collision
• _aaEqual
• bool object.TypeInfo_Class.opEquals(Object)
• bool object.TypeInfo_Vector.opEquals(Object)
• bool object.TypeInfo_Tuple.opEquals(Object)
• bool object.TypeInfo_Typedef.opEquals(Object)
• bool object.TypeInfo.opEquals(Object)
• bool object.TypeInfo_Interface.opEquals(Object)
• _d_arrayappendT
• bool object.TypeInfo_AssociativeArray.opEquals(Object)
• bool object.TypeInfo_StaticArray.opEquals(Object)
• bool object.TypeInfo_Delegate.opEquals(Object)
• _adDupT
• _d_arraysetlengthiT

Uses:

• _d_isbaseof2

_d_eh_handle_collision

Used by:

• uint gc.gc.GC.setAttr(void*, uint)
• @property int delegate(int delegate(ref gc.gc.Range)) gc.gc.GC.rangeIter()
• extern (C) void core.thread.thread_joinAll().int __foreachbody1(ref core.thread.Thread)
• void gc.gc.GC.free(void*)
• @property int delegate(int delegate(ref void*)) gc.gc.GC.rootIter()
• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• void std.concurrency.MessageBox.put(ref std.concurrency.Message)
• uint gc.gc.GC.clrAttr(void*, uint)
• thread_attachThis
• ref std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__ctor(std.stdio.File.ByLine!(char, char).ByLine)
• ulong gc.gc.GC.fullCollect()
• void* gc.gc.GC.addrOf(void*)
• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• ulong gc.gc.GC.extend(void*, ulong, ulong)
• void gc.gc.GC.minimize()
• void core.thread.Thread.remove(core.thread.Thread)
• void gc.gc.GC.addRoot(void*)
• void gc.gc.GC.addRange(void*, ulong)
• rt_term
• void* gc.gc.GC.malloc(ulong, uint, ulong*)
• ulong gc.gc.GC.reserve(ulong)
• void* gc.gc.GC.realloc(void*, ulong, uint, ulong*)
• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)
• thread_resumeAll
• void core.thread.Thread.add(core.thread.Thread.Context*)
• std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.map!(main9__lambda1).map!(std.stdio.File.ByLine!(char, char).ByLine).map(std.stdio.File.ByLine!(char, char).ByLine)
• ulong gc.gc.GC.sizeOf(void*)
• gc.gc.BlkInfo gc.gc.GC.query(void*)
• void gc.gc.GC.fullCollectNoStack()
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• runModuleUnitTests
• std.algorithm.copy.TAAyaTS3std5stdio4File17LockingTextWriterZ.copy.FAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter11genericImplFAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter
• uint gc.gc.GC.getAttr(void*)
• ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• ref std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.ByLine!(char, char).ByLine.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• void core.thread.Thread.add(core.thread.Thread)
• std.stdio.File.LockingTextWriter std.algorithm.copy!(immutable(char)[][], std.stdio.File.LockingTextWriter).copy(immutable(char)[][], std.stdio.File.LockingTextWriter)
• void* gc.gc.GC.calloc(ulong, uint, ulong*)

Uses:

• _Unwind_Resume@plt
• _d_dynamic_cast
• bool object.opEquals(Object, Object)

_d_eh_personality

Uses:

• _adEq2
• fatalerror
• _d_isbaseof
• void ldc.eh._d_getLanguageSpecificTables(void*, ref ubyte*, ref ubyte*, ref ubyte*, ref ubyte)
• _Unwind_GetIP@plt
• _Unwind_SetGR@plt
• _Unwind_SetIP@plt
• _Unwind_GetRegionStart@plt
• ubyte* ldc.eh.get_sleb128(ubyte*, ref long)
• ubyte* ldc.eh.get_encoded_value(ubyte*, ref ulong, ubyte, void*)

_d_eh_resume_unwind

Used by:

• uint gc.gc.GC.setAttr(void*, uint)
• @property int delegate(int delegate(ref gc.gc.Range)) gc.gc.GC.rangeIter()
• extern (C) bool core.runtime.runModuleUnitTests().int __foreachbody3(ref object.ModuleInfo*)
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName
• extern (C) void core.thread.thread_joinAll().int __foreachbody1(ref core.thread.Thread)
• void gc.gc.GC.free(void*)
• @property int delegate(int delegate(ref void*)) gc.gc.GC.rootIter()
• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• void std.concurrency.MessageBox.put(ref std.concurrency.Message)
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.stdName
• rt_finalize2
• uint gc.gc.GC.clrAttr(void*, uint)
• void core.demangle.Demangle.parseTemplateInstanceName()
• thread_attachThis
• const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec
• ref std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult.__ctor(std.stdio.File.ByLine!(char, char).ByLine)
• ulong gc.gc.GC.fullCollect()
• rt_init
• void* gc.gc.GC.addrOf(void*)
• void core.thread.scanAllTypeImpl(scope void delegate(core.thread.ScanType, void*, void*), void*)
• const(nothrow @trusted ulong function()) object.TypeInfo.toHash
• void core.demangle.Demangle.parseSymbolName()
• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• ulong gc.gc.GC.extend(void*, ulong, ulong)
• void gc.gc.GC.minimize()
• void core.thread.Thread.remove(core.thread.Thread)
• void gc.gc.GC.addRoot(void*)
• void gc.gc.GC.addRange(void*, ulong)
• rt_term
• void* gc.gc.GC.malloc(ulong, uint, ulong*)
• void rt.minfo.ModuleGroup.sortCtors()
• ulong gc.gc.GC.reserve(ulong)
• void* gc.gc.GC.realloc(void*, ulong, uint, ulong*)
• void std.stdio.File.close()
• immutable(char)[][] std.array.array!(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult).array(std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult)
• void core.thread.Thread.add(core.thread.Thread.Context*)
• thread_resumeAll
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• std.algorithm.MapResult!(main9__lambda1, std.stdio.File.ByLine!(char, char).ByLine).MapResult std.algorithm.map!(main9__lambda1).map!(std.stdio.File.ByLine!(char, char).ByLine).map(std.stdio.File.ByLine!(char, char).ByLine)
• ulong gc.gc.GC.sizeOf(void*)
• const(void function(scope void delegate(const(char[])))) object.Throwable.toString
• gc.gc.BlkInfo gc.gc.GC.query(void*)
• void gc.gc.GC.fullCollectNoStack()
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• runModuleUnitTests
• bool core.demangle.Demangle.mayBeTemplateInstanceName()
• std.algorithm.copy.TAAyaTS3std5stdio4File17LockingTextWriterZ.copy.FAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter11genericImplFAAyaS3std5stdio4File17LockingTextWriterZS3std5stdio4File17LockingTextWriter
• uint gc.gc.GC.getAttr(void*)
• ref std.stdio.File.ByLineImpl!(char, char).ByLineImpl std.stdio.File.ByLineImpl!(char, char).ByLineImpl.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• char[] core.demangle.Demangle.doDemangle!(_D4core8demangle8Demangle16parseMangledNameMFZv).doDemangle()
• ref std.stdio.File.ByLine!(char, char).ByLine std.stdio.File.ByLine!(char, char).ByLine.__ctor(std.stdio.File, std.string.KeepTerminator, char)
• _d_run_main
• void core.thread.Thread.add(core.thread.Thread)
• std.stdio.File.LockingTextWriter std.algorithm.copy!(immutable(char)[][], std.stdio.File.LockingTextWriter).copy(immutable(char)[][], std.stdio.File.LockingTextWriter)
• void* gc.gc.GC.calloc(ulong, uint, ulong*)

Uses:

• _Unwind_Resume@plt

_d_execBssBegAddr

Used by:

• nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))

_d_execBssEndAddr

Used by:

• nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))

_d_isbaseof

Used by:

• _d_eh_personality

_d_isbaseof2

Used by:

• _d_dynamic_cast

_d_monitor_create

Used by:

• _d_monitorenter
• _d_monitor_devt

Uses:

• pthread_mutex_lock@plt
• pthread_mutex_init@plt
• pthread_mutex_unlock@plt
• calloc@plt

_d_monitor_destroy

Used by:

• _d_monitordelete

Uses:

• free@plt
• pthread_mutex_destroy@plt

_d_monitor_devt

Used by:

• _d_monitordelete

Uses:

• _d_toObject
• free@plt
• _d_monitor_lock
• _d_monitor_create
• _d_monitor_unlock

_d_monitor_lock

Used by:

• _d_monitorenter
• _d_monitor_devt

Uses:

• pthread_mutex_lock@plt

_d_monitor_unlock

Used by:

• _d_monitor_devt
• _d_monitorexit

Uses:

• pthread_mutex_unlock@plt

_d_monitordelete

Used by:

• rt_finalize2

Uses:

• _d_monitor_devt
• _d_monitor_destroy

_d_monitorenter

Used by:

• void std.concurrency._staticDtor3()
• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• void std.concurrency.MessageBox.close()
• void std.concurrency.MessageBox.put(ref std.concurrency.Message)
• void core.thread.Fiber.__dtor()
• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.remove(core.thread.Thread)
• void core.thread.Thread.add(core.thread.Thread)
• extern (C) void core.thread.thread_joinAll().int __foreachbody1(ref core.thread.Thread)

Uses:

• _d_toObject
• _d_monitor_lock
• _d_monitor_create

_d_monitorexit

Used by:

• void std.concurrency._staticDtor3()
• int core.thread.Thread.opApply(scope int delegate(ref core.thread.Thread))
• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• void std.concurrency.MessageBox.close()
• void std.concurrency.MessageBox.put(ref std.concurrency.Message)
• void core.thread.Fiber.__dtor()
• void core.thread.Thread.add(core.thread.Thread.Context*)
• void core.thread.Thread.remove(core.thread.Thread)
• void core.thread.Thread.add(core.thread.Thread)
• extern (C) void core.thread.thread_joinAll().int __foreachbody1(ref core.thread.Thread)

Uses:

• _d_toObject
• _d_monitor_unlock

_d_newarrayT

Used by:

• const(void function(void*, void*)) object.TypeInfo_StaticArray.swap

Uses:

• memset@plt
• onOutOfMemoryError
• gc_qalloc

_d_newarrayvT

Used by:

• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)

Uses:

• onOutOfMemoryError
• gc_qalloc

_d_newclass

Used by:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)
• onFinalizeError
• @property std.concurrency.Tid std.concurrency.thisTid()
• int std.exception.errnoEnforce!(int, "/opt/ldc2-0.14/include/d/std/stdio.d", 2026uL).errnoEnforce(int, lazy immutable(char)[])
• void core.sync.condition.Condition.notifyAll()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)
• pure @safe immutable(char)[] std.string.format!(char, int).format(const(char[]), int).pure @safe object.Throwable __dgliteral4()
• const(Object function()) object.TypeInfo_Class.create
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• @trusted void core.sync.mutex.Mutex.lock()
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(void).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• int object.Object.opCmp(Object)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])
• std.concurrency.MessageBox std.concurrency.MessageBox.__ctor()
• void core.thread.suspend(core.thread.Thread)
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• thread_attachThis
• const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec
• pure @safe bool std.exception.enforceEx!(std.format.FormatException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)
• void core.thread.resume(core.thread.Thread)
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• @trusted void core.sync.mutex.Mutex.unlock()
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• @trusted void core.time.TickDuration._sharedStaticCtor1()
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• pure @safe void std.utf.encode(ref char[], dchar)
• bool core.sync.condition.Condition.wait(core.time.Duration)
• void core.sync.condition.Condition.notify()
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe int std.format.getNthInt!().getNthInt(uint)
• void std.stdio.File.close()
• _d_assert
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)
• onRangeError
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• _d_assert_msg
• _d_array_slice_copy
• void core.sync.condition.Condition.wait()
• void std.concurrency._sharedStaticCtor2()
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• onUnicodeError
• core.sync.condition.Condition core.sync.condition.Condition.__ctor(core.sync.mutex.Mutex)
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)
• @trusted int std.variant.VariantN!(32uL).VariantN.opCmp!(std.variant.VariantN!(32uL).VariantN).opCmp(std.variant.VariantN!(32uL).VariantN)
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• void core.thread.Thread.sleep(core.time.Duration)
• thread_joinAll

Uses:

• malloc@plt
• onOutOfMemoryError
• gc_malloc
• memcpy@plt

_d_run_main

Used by:

• main

Uses:

• strlen@plt
• immutable(char)[][] rt.dmain2._d_args
• stdout@@GLIBC_2.2.5
• rt_init
• rt_term
• stderr@@GLIBC_2.2.5
• _d_eh_resume_unwind
• void rt.dmain2.printThrowable(object.Throwable)
• rt.dmain2.CArgs rt.dmain2._cArgs
• rt_trapExceptions
• runModuleUnitTests
• fflush@plt
• nothrow @property @trusted int core.stdc.errno.errno()
• memcpy@plt
• strerror@plt
• fprintf@plt

_d_throw_exception

Used by:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, int, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, int, ref std.format.FormatSpec!(char).FormatSpec)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• onFinalizeError
• int std.exception.errnoEnforce!(int, "/opt/ldc2-0.14/include/d/std/stdio.d", 2026uL).errnoEnforce(int, lazy immutable(char)[])
• void core.sync.condition.Condition.notifyAll()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong)
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(std.concurrency.Tid).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• @trusted void core.sync.mutex.Mutex.lock()
• @trusted long std.variant.VariantN!(32uL).VariantN.handler!(void).handler(std.variant.VariantN!(32uL).VariantN.OpID, ubyte[32]*, void*)
• char[] core.demangle.Demangle.parseTypeFunction(char[], core.demangle.Demangle.IsDelegate)
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint)
• int object.Object.opCmp(Object)
• void core.thread.suspend(core.thread.Thread)
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)
• void core.demangle.Demangle.parseTemplateInstanceName()
• const(pure nothrow @property @safe core.time.FracSec function()) core.time.Duration.fracSec
• pure @safe bool std.exception.enforceEx!(std.format.FormatException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)
• void core.thread.resume(core.thread.Thread)
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• onOutOfMemoryError
• void core.demangle.Demangle.error(immutable(char)[])
• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• @trusted void core.sync.mutex.Mutex.unlock()
• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))
• void rt.minfo.ModuleGroup.sortCtors().void sort(ref object.ModuleInfo*[], uint)
• @trusted void core.time.TickDuration._sharedStaticCtor1()
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• pure @safe void std.utf.encode(ref char[], dchar)
• bool core.sync.condition.Condition.wait(core.time.Duration)
• void core.sync.condition.Condition.notify()
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, uint, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, uint, ref std.format.FormatSpec!(char).FormatSpec)
• pure @safe int std.format.getNthInt!().getNthInt(uint)
• void std.stdio.File.close()
• _d_assert
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ulong, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ulong, ref std.format.FormatSpec!(char).FormatSpec)
• onRangeError
• void core.demangle.Demangle.overflow(immutable(char)[])
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• _d_assert_msg
• _d_array_slice_copy
• onInvalidMemoryOperationError
• void core.sync.condition.Condition.wait()
• core.sync.mutex.Mutex core.sync.mutex.Mutex.__ctor()
• onUnicodeError
• core.sync.condition.Condition core.sync.condition.Condition.__ctor(core.sync.mutex.Mutex)
• pure @safe bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• pure @safe immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• void std.concurrency.MessageBox.close().void onLinkDeadMsg(ref std.concurrency.Message)
• @trusted int std.variant.VariantN!(32uL).VariantN.opCmp!(std.variant.VariantN!(32uL).VariantN).opCmp(std.variant.VariantN!(32uL).VariantN)
• pure @safe int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• void core.thread.Thread.sleep(core.time.Duration)
• thread_joinAll