GraphViz .dot file

Jump to D main()

TypeInfo_Aa.__init

Used by:

• void std.array.Appender!(char[]).Appender.ensureAddable(ulong)
• nothrow void std.array.Appender!(char[]).Appender.reserve(ulong)

TypeInfo_Ah.__init

Used by:

• nothrow void std.array.Appender!(ubyte[]).Appender.reserve(ulong)
• void std.array.Appender!(ubyte[]).Appender.ensureAddable(ulong)

TypeInfo_Axa.__init

Used by:

• nothrow void std.array.Appender!(const(char)[]).Appender.reserve(ulong)
• void std.array.Appender!(const(char)[]).Appender.ensureAddable(ulong)

TypeInfo_Aya.__init

Used by:

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

TypeInfo_OAa.__init

Used by:

• _d_arrayappendcd

int timeduration.getMCentury.getMC()

Used by:

• ref timeduration.returndtfromtext timeduration.returndtfromtext.__ctor(immutable(char)[], immutable(char)[])

ref timeduration.getMCentury timeduration.getMCentury.__ctor(int)

Used by:

• ref timeduration.returndtfromtext timeduration.returndtfromtext.__ctor(immutable(char)[], immutable(char)[])

long timeduration.calcTimeIntS(std.datetime.DateTime, std.datetime.DateTime)

Used by:

• _Dmain

Uses:

• const(pure nothrow @property core.time.Duration function()) std.datetime.Interval!(std.datetime.DateTime).Interval.length
• pure ref std.datetime.Interval!(std.datetime.DateTime).Interval std.datetime.Interval!(std.datetime.DateTime).Interval.__ctor!(std.datetime.DateTime).__ctor(const(std.datetime.DateTime), const(std.datetime.DateTime))
• const(pure nothrow int function(const(std.datetime.DateTime))) std.datetime.DateTime.opCmp

void timeduration.__unittest_fail(int)

Uses:

• _deh_end
• _d_unittestm
• _deh_beg
• TypeInfo_S12timeduration16returndtfromtext.__init
• _d_dso_registry

bool timeduration.returndtfromtext.__xopEquals(ref const(timeduration.returndtfromtext), ref const(timeduration.returndtfromtext))

immutable(char)[] timeduration.returndtfromtext.getmonthname(ref immutable(char)[])

Used by:

• timeduration.returndtfromtext.__ctor.MFNcAyaAyaZS12timeduration16returndtfromtext17__foreachbody2750MFKwZi

Uses:

• pure @trusted immutable(char)[] std.string.toLower!(immutable(char)[]).toLower(immutable(char)[])
• _d_arrayappendcTX

ref timeduration.returndtfromtext timeduration.returndtfromtext.__ctor(immutable(char)[], immutable(char)[])

Used by:

• _Dmain

Uses:

• const(nothrow @property int function()) std.datetime.SysTime.dayOfGregorianCal
• _aApplycd1
• const(nothrow std.datetime.DateTime function()) std.datetime.SysTime.opCast!(std.datetime.DateTime).opCast
• immutable(std.datetime.LocalTime) std.datetime.LocalTime.singleton()
• int timeduration.getMCentury.getMC()
• @property @trusted long std.datetime.Clock.currStdTime()
• pure nothrow ref std.datetime.Date std.datetime.Date.__ctor(int)
• ref timeduration.getMCentury timeduration.getMCentury.__ctor(int)

timeduration.returndtfromtext.__ctor.MFNcAyaAyaZS12timeduration16returndtfromtext17__foreachbody2750MFKwZi

Uses:

• pure @property void std.datetime.DateTime.hour(int)
• std.datetime.Month std.conv.to!(std.datetime.Month).to!(immutable(char)[]).to(immutable(char)[])
• immutable(char)[] timeduration.getTwoEleOut!(immutable(char)[], immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• pure @property void std.datetime.DateTime.day(int)
• int std.conv.to!(int).to!(immutable(char)[]).to(immutable(char)[])
• int timeduration.getTwoEleOut!(int, immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• pure @property void std.datetime.DateTime.minute(int)
• pure @property void std.datetime.DateTime.second(int)
• pure nothrow @trusted void std.array.popFront!(immutable(char)).popFront(ref immutable(char)[])
• pure @property void std.datetime.DateTime.year(int)
• pure nothrow void std.datetime.DateTime.add!("months").add(long, std.datetime.AllowDayOverflow)
• immutable(char)[] timeduration.returndtfromtext.getmonthname(ref immutable(char)[])
• pure @property void std.datetime.DateTime.month(std.datetime.Month)
• _d_arrayappendT

std.datetime.DateTime timeduration.returndtfromtext.printdt()

Used by:

• _Dmain

int timeduration.getTwoEleOut!(int, immutable(char)[]).getTwoEleOut(ref immutable(char)[])

Used by:

• timeduration.returndtfromtext.__ctor.MFNcAyaAyaZS12timeduration16returndtfromtext17__foreachbody2750MFKwZi

Uses:

• pure @trusted dchar std.utf.decode!(immutable(char)[]).decode(ref immutable(char)[], ref ulong)
• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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)
• int std.conv.toImpl!(int, immutable(char)[]).toImpl(immutable(char)[])
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt
• _d_arrayappendT

immutable(char)[] timeduration.getTwoEleOut!(immutable(char)[], immutable(char)[]).getTwoEleOut(ref immutable(char)[])

Used by:

• timeduration.returndtfromtext.__ctor.MFNcAyaAyaZS12timeduration16returndtfromtext17__foreachbody2750MFKwZi

Uses:

• pure @trusted dchar std.utf.decode!(immutable(char)[]).decode(ref immutable(char)[], ref ulong)
• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt
• _d_arrayappendT

timeduration.__array

Uses:

• _d_array_bounds

void timeduration.__assert(int)

Uses:

• _d_assertm

TypeInfo_AAya.__init

Used by:

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

std.file.d.1582.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.file.d.1582.__array

Uses:

• _d_array_bounds

std.file.d.1582.__assert.FiZv

Uses:

• _d_assertm

std.file.d.1583.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.file.d.1583.__array

Uses:

• _d_array_bounds

std.file.d.1583.__assert.FiZv

Uses:

• _d_assertm

std.file.d.1585.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.file.d.1585.__array

Uses:

• _d_array_bounds

std.file.d.1585.__assert.FiZv

Uses:

• _d_assertm

std.file.d.1586.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.file.d.1586.__array

Uses:

• _d_array_bounds

std.file.d.1586.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.84.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.84.__array

Uses:

• _d_array_bounds

src.object_.d.84.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.87.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.87.__array

Uses:

• _d_array_bounds

src.object_.d.87.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.90.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.90.__array

Uses:

• _d_array_bounds

src.object_.d.90.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.94.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.94.__array

Uses:

• _d_array_bounds

src.object_.d.94.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.96.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.96.__array

Uses:

• _d_array_bounds

src.object_.d.96.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.98.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.98.__array

Uses:

• _d_array_bounds

src.object_.d.98.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.99.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.99.__array

Uses:

• _d_array_bounds

src.object_.d.99.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.831.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.831.__array

Uses:

• _d_array_bounds

src.object_.d.831.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.832.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.832.__array

Uses:

• _d_array_bounds

src.object_.d.832.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.833.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.833.__array

Uses:

• _d_array_bounds

src.object_.d.833.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.835.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.835.__array

Uses:

• _d_array_bounds

src.object_.d.835.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.836.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.836.__array

Uses:

• _d_array_bounds

src.object_.d.836.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.837.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.837.__array

Uses:

• _d_array_bounds

src.object_.d.837.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.1076.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.1076.__array

Uses:

• _d_array_bounds

src.object_.d.1076.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.1158.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.1158.__array

Uses:

• _d_array_bounds

src.object_.d.1158.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.1164.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.1164.__array

Uses:

• _d_array_bounds

src.object_.d.1164.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.1166.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.1166.__array

Uses:

• _d_array_bounds

src.object_.d.1166.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.1243.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.1243.__array

Uses:

• _d_array_bounds

src.object_.d.1243.__assert.FiZv

Uses:

• _d_assertm

src.object_.d.1361.__unittest_fail.FiZv

Uses:

• _d_unittestm

src.object_.d.1361.__array

Uses:

• _d_array_bounds

src.object_.d.1361.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1269.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1269.__array

Uses:

• _d_array_bounds

std.datetime.d.1269.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1270.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1270.__array

Uses:

• _d_array_bounds

std.datetime.d.1270.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1271.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1271.__array

Uses:

• _d_array_bounds

std.datetime.d.1271.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1272.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1272.__array

Uses:

• _d_array_bounds

std.datetime.d.1272.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1273.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1273.__array

Uses:

• _d_array_bounds

std.datetime.d.1273.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1277.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1277.__array

Uses:

• _d_array_bounds

std.datetime.d.1277.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1278.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1278.__array

Uses:

• _d_array_bounds

std.datetime.d.1278.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1280.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1280.__array

Uses:

• _d_array_bounds

std.datetime.d.1280.__assert.FiZv

Uses:

• _d_assertm

std.datetime.d.1284.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.datetime.d.1284.__array

Uses:

• _d_array_bounds

std.datetime.d.1284.__assert.FiZv

Uses:

• _d_assertm

std.internal.uni.d.5174.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.internal.uni.d.5174.__array

Uses:

• _d_array_bounds

std.internal.uni.d.5174.__assert.FiZv

Uses:

• _d_assertm

std.internal.uni.d.5175.__unittest_fail.FiZv

Uses:

• _d_unittestm

std.internal.uni.d.5175.__array

Uses:

• _d_array_bounds

std.internal.uni.d.5175.__assert.FiZv

Uses:

• _d_assertm

TypeInfo_S3std5stdio4File.__init

Used by:

• void object.destroy!(std.stdio.File).destroy(ref std.stdio.File)

TypeInfo_AS3std4file8DirEntry.__init

Used by:

• nothrow void std.array.Appender!(std.file.DirEntry[]).Appender.reserve(ulong)
• void std.array.Appender!(std.file.DirEntry[]).Appender.ensureAddable(ulong)

void gc.gc.__unittest_fail(int)

Uses:

• _d_unittestm

gc.gcx.GC gc.gc._gc

Used by:

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

gc.gc.Proxy* gc.gc.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_realloc
• gc_free
• gc_addrOf
• gc_removeRange
• gc_collect
• gc_minimize
• gc_getAttr
• gc_removeRoot
• gc_addRange
• gc_addRoot

gc.gc.Proxy gc.gc.pthis

Used by:

• gc_init

gc.gc.__array

Uses:

• _d_array_bounds

void gc.gc.__assert(int)

Uses:

• _d_assertm

void gc.gcx.__unittest_fail(int)

Uses:

• _d_unittestm

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

Used by:

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

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• onInvalidMemoryOperationError
• void gc.gcx.Pool.freePages(ulong, ulong)

void gc.gcx.GC.initialize()

Uses:

• gc.gcx.GCMutex gc.gcx.GC.gcLock
• gc.gcx.GCMutex gc.gcx.GCMutex.__ctor()
• onOutOfMemoryError
• calloc@plt
• gc.gcx.GCMutex.__Class
• memcpy@plt

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

Uses:

• gc.gcx.GCMutex gc.gcx.GC.gcLock
• void gc.gcx.Gcx.removeRoot(void*)

void gc.gcx.GC.checkNoSync(void*)

ulong gc.gcx.GC.fullCollect()

Uses:

• ulong gc.gcx.Gcx.fullcollect()
• gc.gcx.GCMutex gc.gcx.GC.gcLock

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

Uses:

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

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

Uses:

• gc.gcx.GCMutex gc.gcx.GC.gcLock
• void gc.gcx.Gcx.removeRange(void*)

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

Uses:

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

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

Used by:

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

Uses:

• ulong gc.gcx.Gcx.findSize(void*)
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• ulong gc.gcx.Pool.extendPagesUpTo(ulong)
• memset@plt
• void gc.gcx.Pool.updateOffsets(ulong)
• onInvalidMemoryOperationError

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

Used by:

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

Uses:

• int gc.gcx.Gcx.allocPage(ubyte)
• ulong gc.gcx.Gcx.fullcollect()
• gc.gcx.Pool* gc.gcx.Gcx.newPool(ulong, bool)
• onOutOfMemoryError
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• onInvalidMemoryOperationError
• calloc@plt
• ubyte gc.gcx.Gcx.findBin(ulong)

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

Used by:

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

Uses:

• ulong gc.gcx.Gcx.findSize(void*)

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

Used by:

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

Uses:

• ulong gc.gcx.Gcx.findSize(void*)
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• gc.gcx.GCMutex gc.gcx.GC.gcLock
• void gc.gcx.Pool.updateOffsets(ulong)
• memset@plt
• onOutOfMemoryError
• onInvalidMemoryOperationError
• void gc.gcx.GC.freeNoSync(void*)
• void gc.gcx.Pool.freePages(ulong, ulong)
• calloc@plt
• void* gc.gcx.GC.mallocNoSync(ulong, uint, ulong*)
• ulong gc.gcx.Pool.extendPages(ulong)
• memcpy@plt

ulong gc.gcx.GC.reserveNoSync(ulong)

Uses:

• onInvalidMemoryOperationError
• ulong gc.gcx.Gcx.reserve(ulong)

void gc.gcx.GC.getStatsNoSync(out gc.gcstats.GCStats)

Used by:

• void gc.gcx.GC.getStats(out gc.gcstats.GCStats)

Uses:

• memset@plt

void gc.gcx.GC.fullCollectNoStack()

Uses:

• ulong gc.gcx.Gcx.fullcollect()
• gc.gcx.GCMutex gc.gcx.GC.gcLock

void gc.gcx.GC.Dtor()

Uses:

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

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

Uses:

• gc.gcx.GCMutex gc.gcx.GC.gcLock
• void gc.gcx.GC.freeNoSync(void*)

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

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

void gc.gcx.GC.enable()

Uses:

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

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

Uses:

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

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

Used by:

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

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

Uses:

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

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

Uses:

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

gc.gcx.GC.__Class

Used by:

• gc_init

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

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

• @property uint gc.gcx.Pool.shiftBy()
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)
• void gc.gcx.Gcx.clrBits(gc.gcx.Pool*, ulong, uint)

void gc.gcx.GC.disable()

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

• @property uint gc.gcx.Pool.shiftBy()
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)

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

Uses:

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

ulong gc.gcx.GC.reserve(ulong)

Uses:

• gc.gcx.GCMutex gc.gcx.GC.gcLock
• onInvalidMemoryOperationError
• ulong gc.gcx.Gcx.reserve(ulong)

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

Uses:

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

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

Used by:

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

Uses:

• @property uint gc.gcx.Pool.shiftBy()
• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)
• uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)
• void gc.gcx.Gcx.setBits(gc.gcx.Pool*, ulong, uint)

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

Uses:

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

void gc.gcx.GC.getStats(out gc.gcstats.GCStats)

Uses:

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

void gc.gcx.GC.minimize()

Uses:

• void gc.gcx.Gcx.minimize()
• gc.gcx.GCMutex gc.gcx.GC.gcLock

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

Uses:

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

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

Uses:

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

void gc.gcx.Gcx.initialize()

void gc.gcx.Gcx.log_malloc(void*, ulong)

void gc.gcx.Gcx.log_parent(void*, void*)

void gc.gcx.Gcx.removeRoot(void*)

Used by:

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

Uses:

• memmove@plt

const(void function()) gc.gcx.Gcx.__invariant

Uses:

• const(void function()) gc.gcx.Gcx.__invariant14

ubyte gc.gcx.Gcx.findBinImpl(ulong)

ulong gc.gcx.Gcx.fullcollect()

Used by:

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

Uses:

• thread_processGCMarks
• memset@plt
• onInvalidMemoryOperationError
• thread_suspendAll
• void gc.gcx.Gcx.mark(void*, void*, int)
• memcpy@plt
• thread_scanAll
• thread_resumeAll
• rt_finalize2

void gc.gcx.Gcx.log_collect()

void gc.gcx.Gcx.removeRange(void*)

Used by:

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

Uses:

• memmove@plt

const(void function()) gc.gcx.Gcx.__invariant14

Used by:

• const(void function()) gc.gcx.Gcx.__invariant

void gc.gcx.Gcx.clrBitsSmallSweep(gc.gcx.Pool*, ulong, ulong)

void gc.gcx.Gcx.Dtor()

Used by:

• void gc.gcx.GC.Dtor()

Uses:

• free@plt
• munmap@plt

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

Uses:

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

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

Used by:

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

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

void gc.gcx.Gcx.addRoot(void*)

Uses:

• malloc@plt
• free@plt
• onOutOfMemoryError
• memcpy@plt

void gc.gcx.Gcx.clrBits(gc.gcx.Pool*, ulong, uint)

Used by:

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

ubyte gc.gcx.Gcx.findBin(ulong)

Used by:

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

uint gc.gcx.Gcx.getBits(gc.gcx.Pool*, ulong)

Used by:

• uint gc.gcx.GC.getAttr(void*).uint go()
• uint gc.gcx.GC.clrAttr(void*, uint).uint go()
• uint gc.gcx.GC.setAttr(void*, uint).uint go()

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

Used by:

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

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

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

Used by:

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

Uses:

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

ulong gc.gcx.Gcx.reserve(ulong)

Used by:

• ulong gc.gcx.GC.reserveNoSync(ulong)
• ulong gc.gcx.GC.reserve(ulong)

Uses:

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

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

Used by:

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

Uses:

• onOutOfMemoryError
• calloc@plt

void gc.gcx.Gcx.addRange(void*, void*)

Uses:

• malloc@plt
• free@plt
• onOutOfMemoryError
• memcpy@plt

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

Used by:

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

Uses:

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

byte[2049] gc.gcx.Gcx.ctfeBins()

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

Used by:

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

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

Used by:

• uint gc.gcx.GC.getAttr(void*).uint go()
• gc.gcx.IsMarked gc.gcx.Gcx.isMarked(void*)
• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• ulong gc.gcx.Gcx.findSize(void*)
• uint gc.gcx.GC.clrAttr(void*, uint).uint go()
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• void gc.gcx.GC.freeNoSync(void*)
• void* gc.gcx.Gcx.findBase(void*)
• void gc.gcx.Gcx.mark(void*, void*, int)
• uint gc.gcx.GC.setAttr(void*, uint).uint go()
• gc.gcx.BlkInfo gc.gcx.Gcx.getInfo(void*)

ulong gc.gcx.Gcx.findSize(void*)

Used by:

• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• ulong gc.gcx.GC.sizeOfNoSync(void*)

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

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

Uses:

• gc.gcx.Pool* gc.gcx.Gcx.findPool(void*)

void gc.gcx.Gcx.log_free(void*)

void gc.gcx.Gcx.log_init()

void gc.gcx.Gcx.minimize()

Used by:

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

Uses:

• free@plt
• munmap@plt

void gc.gcx.Gcx.minimize().bool isUsed(gc.gcx.Pool*)

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

const(void function()) gc.gcx.Gcx.Invariant

int gc.gcx.Gcx.allocPage(ubyte)

Used by:

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

Uses:

• ulong gc.gcx.Pool.allocPages(ulong)

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

ulong gc.gcx.Pool.allocPages(ulong)

Used by:

• int gc.gcx.Gcx.allocPage(ubyte)
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)

Uses:

• ulong gc.gcx.Pool.extendPages(ulong)

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

Used by:

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

Uses:

• malloc@plt
• mmap64@plt
• onOutOfMemoryError
• memset@plt
• calloc@plt

const(void function()) gc.gcx.Pool.__invariant

Uses:

• const(void function()) gc.gcx.Pool.__invariant15

ulong gc.gcx.Pool.extendPages(ulong)

Used by:

• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)
• ulong gc.gcx.Gcx.reserve(ulong)
• ulong gc.gcx.Pool.allocPages(ulong)

Uses:

• memset@plt

const(void function()) gc.gcx.Pool.__invariant15

Used by:

• const(void function()) gc.gcx.Pool.__invariant

void gc.gcx.Pool.updateOffsets(ulong)

Used by:

• ulong gc.gcx.GC.extendNoSync(void*, ulong, ulong)
• void* gc.gcx.Gcx.bigAlloc(ulong, gc.gcx.Pool**, ulong*)
• void* gc.gcx.GC.reallocNoSync(void*, ulong, uint, ulong*)

ulong gc.gcx.Pool.extendPagesUpTo(ulong)

Used by:

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

Uses:

• memset@plt

void gc.gcx.Pool.Dtor()

Uses:

• free@plt
• munmap@plt

const(int function(const(gc.gcx.Pool*))) gc.gcx.Pool.opCmp

@property ulong gc.gcx.Pool.divisor()

@property uint gc.gcx.Pool.shiftBy()

Used by:

• uint gc.gcx.GC.getAttr(void*).uint go()
• uint gc.gcx.GC.clrAttr(void*, uint).uint go()
• uint gc.gcx.GC.setAttr(void*, uint).uint go()

const(void function()) gc.gcx.Pool.Invariant

void gc.gcx.Pool.freePages(ulong, ulong)

Used by:

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

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

Used by:

• void gc.gcx.GC.initialize()

Uses:

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

gc.gcx.GCMutex.__Class

Used by:

• void gc.gcx.GC.initialize()

gc.gcx.__array

Uses:

• _d_array_bounds

void gc.gcx.__assert(int)

Uses:

• _d_assertm

void* rt.sections_linux._dummy_ref

Used by:

• rt_init
• void rt.sections_linux.initSections()

void[] rt.sections_linux.getTLSRange(ulong, ulong)

Used by:

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

Uses:

• __tls_get_addr@plt

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

Used by:

• int rt.sections_linux.DSO.opApply(scope int delegate(ref rt.sections_linux.DSO))
• rt.util.container.Array!(void[]).Array* rt.sections_linux.initTLSRanges()
• int rt.sections_linux.DSO.opApplyReverse(scope int delegate(ref rt.sections_linux.DSO))
• _d_dso_registry

void rt.sections_linux.finiSections()

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void runAll()

void rt.sections_linux.initSections()

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void runAll()

Uses:

• void* rt.sections_linux._dummy_ref

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

Used by:

• thread_attachThis
• thread_entryPoint

Uses:

• _DYNAMIC
• void* rt.util.container.xrealloc(void*, ulong)
• void[] rt.sections_linux.getTLSRange(ulong, ulong)
• rt.util.container.Array!(rt.sections_linux.DSO*).Array rt.sections_linux._static_dsos

void rt.sections_linux.__unittest_fail(int)

Uses:

• _d_unittestm

nothrow bool rt.sections_linux.findDSOInfoForAddr(const(void*), core.sys.linux.link.dl_phdr_info*)

Used by:

• _d_dso_registry

Uses:

• dl_iterate_phdr@plt

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*)

Uses:

• nothrow bool rt.sections_linux.findSegmentForAddr(ref const(core.sys.linux.link.dl_phdr_info), const(void*), core.sys.linux.elf.Elf64_Phdr*)

nothrow bool rt.sections_linux.findSegmentForAddr(ref const(core.sys.linux.link.dl_phdr_info), const(void*), core.sys.linux.elf.Elf64_Phdr*)

Used by:

• 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*)

void rt.sections_linux.DSO.__fieldDtor()

Uses:

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

const(void function()) rt.sections_linux.DSO.__invariant

bool rt.sections_linux.DSO.__xopEquals(ref const(rt.sections_linux.DSO), ref const(rt.sections_linux.DSO))

Uses:

• _adEq2

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

Used by:

• extern (C) void rt.minfo.rt_moduleCtor().int __foreachbody544(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody547(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleTlsCtor().int __foreachbody545(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleTlsDtor().int __foreachbody546(ref rt.sections_linux.DSO)

const(void function()) rt.sections_linux.DSO.__invariant18

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._static_dsos

void rt.sections_linux.DSO.__fieldPostBlit()

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

Used by:

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

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*))
• void rt.memory.initStaticDataGC()
• rt_moduleCtor
• rt_moduleTlsCtor
• immutable(rt.deh2.FuncTable)* rt.deh2.__eh_finddata(void*)

Uses:

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

const(@property immutable(rt.deh2.FuncTable)[] function()) rt.sections_linux.DSO.ehTables

Used by:

• rt.deh2.__eh_finddata.FPvZPyS2rt4deh29FuncTable16__foreachbody510MFKS2rt14sections_linux3DSOZi

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

Used by:

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

ref rt.sections_linux.DSO rt.sections_linux.DSO.opAssign(rt.sections_linux.DSO)

Uses:

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

rt.sections_linux.__array

Uses:

• _d_array_bounds

void rt.sections_linux.__assert(int)

Uses:

• _d_assertm

immutable(ulong[]) rt.aaA.prime_list

Used by:

• _aaRehash

void rt.aaA.__unittest_fail(int)

Uses:

• _d_unittestm

bool rt.aaA.BB.__xopEquals(ref const(rt.aaA.BB), ref const(rt.aaA.BB))

Uses:

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

rt.aaA.__array

Uses:

• _d_array_bounds

void rt.aaA.__assert(int)

Uses:

• _d_assertm

immutable(rt.deh2.FuncTable)* rt.deh2.__eh_finddata(void*, immutable(rt.deh2.FuncTable)*, immutable(rt.deh2.FuncTable)*)

Used by:

• rt.deh2.__eh_finddata.FPvZPyS2rt4deh29FuncTable16__foreachbody510MFKS2rt14sections_linux3DSOZi

immutable(rt.deh2.FuncTable)* rt.deh2.__eh_finddata(void*)

Used by:

• _d_throwc

Uses:

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

rt.deh2.__eh_finddata.FPvZPyS2rt4deh29FuncTable16__foreachbody510MFKS2rt14sections_linux3DSOZi

Uses:

• const(@property immutable(rt.deh2.FuncTable)[] function()) rt.sections_linux.DSO.ehTables
• immutable(rt.deh2.FuncTable)* rt.deh2.__eh_finddata(void*, immutable(rt.deh2.FuncTable)*, immutable(rt.deh2.FuncTable)*)

void rt.deh2.__unittest_fail(int)

Uses:

• _d_unittestm

rt.deh2.__array

Uses:

• _d_array_bounds

void rt.deh2.__assert(int)

Uses:

• _d_assertm

void rt.deh2.terminate()

Used by:

• _d_throwc

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

Used by:

• _aApplycd1
• _aApplycd2

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(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_long.TypeInfo_l.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ag.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Aint.TypeInfo_Ai.getHash
• const(nothrow @trusted ulong function()) object.TypeInfo.toHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Afloat.TypeInfo_Af.getHash

Uses:

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

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

Used by:

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

pure nothrow @trusted char[] rt.util.string.uintToString(char[], ulong)

Used by:

• const(immutable(char)[] function()) object.TypeInfo_StaticArray.toString
• _d_arraycopy
• immutable(char)[] object.Throwable.toString()
• rt.util.console.Console rt.util.console.Console.opCall(ulong)

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.console.__unittest_fail(int)

Uses:

• _d_unittestm

rt.util.console.Console rt.util.console.Console.opCall(ulong)

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printLocLine(object.Throwable)

Uses:

• pure nothrow @trusted char[] rt.util.string.uintToString(char[], ulong)
• write@plt

rt.util.console.Console rt.util.console.Console.opCall(const(char[]))

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable)
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printLocLine(object.Throwable)
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable).int __foreachbody515(ref const(char[]))
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void print(object.Throwable)

Uses:

• write@plt

rt.util.console.__array

Uses:

• _d_array_bounds

void rt.util.console.__assert(int)

Uses:

• _d_assertm

rt.util.container.Array!(void[]).Array.backinout(pure nothrow ref @property inout(void[]) function())

const(pure nothrow @property @safe bool function()) rt.util.container.Array!(void[]).Array.empty

rt.util.container.Array!(void[]).Array.frontinout(pure nothrow ref @property @safe inout(void[]) function())

void rt.util.container.Array!(void[]).Array.reset()

Uses:

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

void rt.util.container.Array!(void[]).Array.__dtor()

Uses:

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

@property void rt.util.container.Array!(void[]).Array.length(ulong)

Uses:

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

const(pure nothrow @property @safe ulong function()) rt.util.container.Array!(void[]).Array.length

rt.util.container.Array!(void[]).Array.opIndexinout(pure nothrow ref @property inout(void[]) function(ulong))

rt.util.container.Array!(void[]).Array.opSliceinout(pure nothrow @property @safe inout(void[])[] function())

rt.util.container.Array!(void[]).Array.opSliceinout(pure nothrow @property @safe inout(void[])[] function(ulong, ulong))

Uses:

• rt.util.container.__array

void rt.util.container.Array!(void[]).Array.popBack()

Uses:

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

ref rt.util.container.Array!(void[]).Array rt.util.container.Array!(void[]).Array.opAssign(rt.util.container.Array!(void[]).Array)

Uses:

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

void rt.util.container.__unittest_fail(int)

Uses:

• _d_unittestm

rt.util.container.__array

Used by:

• rt.util.container.Array!(void[]).Array.opSliceinout(pure nothrow @property @safe inout(void[])[] function(ulong, ulong))

Uses:

• _d_array_bounds

void rt.util.container.__assert(int)

Uses:

• _d_assertm

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

Used by:

• void core.thread.Thread.__dtor()
• ref rt.util.container.Array!(void[]).Array rt.util.container.Array!(void[]).Array.opAssign(rt.util.container.Array!(void[]).Array)
• void rt.sections_linux.DSO.__fieldDtor()
• rt.util.container.Array!(void[]).Array* rt.sections_linux.initTLSRanges()
• void rt.util.container.Array!(void[]).Array.__dtor()
• @property void rt.util.container.Array!(void[]).Array.length(ulong)
• void rt.util.container.Array!(void[]).Array.popBack()
• ref rt.sections_linux.DSO rt.sections_linux.DSO.opAssign(rt.sections_linux.DSO)
• _d_dso_registry
• void rt.util.container.Array!(void[]).Array.reset()

Uses:

• free@plt
• onOutOfMemoryError
• realloc@plt

bool rt.minfo.ModuleGroup.__xopEquals(ref const(rt.minfo.ModuleGroup), ref const(rt.minfo.ModuleGroup))

Uses:

• _adEq2

void rt.minfo.ModuleGroup.runTlsCtors()

Used by:

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

Uses:

• void rt.minfo.ModuleGroup.runTlsCtors().pure void __T14runModuleFuncsS522rt5minfo11ModuleGroup11runTlsCtorsMFZv11__lambda279Z.runModuleFuncs(object.ModuleInfo*[])

void rt.minfo.ModuleGroup.runTlsCtors().pure void __T14runModuleFuncsS522rt5minfo11ModuleGroup11runTlsCtorsMFZv11__lambda279Z.runModuleFuncs(object.ModuleInfo*[])

Used by:

• void rt.minfo.ModuleGroup.runTlsCtors()

Uses:

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

void rt.minfo.ModuleGroup.runTlsDtors()

Used by:

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

Uses:

• void rt.minfo.ModuleGroup.runTlsDtors().pure void __T17runModuleFuncsRevS522rt5minfo11ModuleGroup11runTlsDtorsMFZv11__lambda281Z.runModuleFuncsRev(object.ModuleInfo*[])

void rt.minfo.ModuleGroup.runTlsDtors().pure void __T17runModuleFuncsRevS522rt5minfo11ModuleGroup11runTlsDtorsMFZv11__lambda281Z.runModuleFuncsRev(object.ModuleInfo*[])

Used by:

• void rt.minfo.ModuleGroup.runTlsDtors()

Uses:

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

void rt.minfo.ModuleGroup.free()

Used by:

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

Uses:

• free@plt

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

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

void rt.minfo.ModuleGroup.runCtors()

Used by:

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

Uses:

• void rt.minfo.ModuleGroup.runCtors().pure void __T14runModuleFuncsS482rt5minfo11ModuleGroup8runCtorsMFZv11__lambda275Z.runModuleFuncs(object.ModuleInfo*[])
• void rt.minfo.ModuleGroup.runCtors().pure void __T14runModuleFuncsS482rt5minfo11ModuleGroup8runCtorsMFZv11__lambda277Z.runModuleFuncs(object.ModuleInfo*[])

void rt.minfo.ModuleGroup.runCtors().pure void __T14runModuleFuncsS482rt5minfo11ModuleGroup8runCtorsMFZv11__lambda275Z.runModuleFuncs(object.ModuleInfo*[])

Used by:

• void rt.minfo.ModuleGroup.runCtors()

Uses:

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

void rt.minfo.ModuleGroup.runCtors().pure void __T14runModuleFuncsS482rt5minfo11ModuleGroup8runCtorsMFZv11__lambda277Z.runModuleFuncs(object.ModuleInfo*[])

Used by:

• void rt.minfo.ModuleGroup.runCtors()

Uses:

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

void rt.minfo.ModuleGroup.runDtors()

Used by:

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

Uses:

• void rt.minfo.ModuleGroup.runDtors().pure void __T17runModuleFuncsRevS482rt5minfo11ModuleGroup8runDtorsMFZv11__lambda283Z.runModuleFuncsRev(object.ModuleInfo*[])

void rt.minfo.ModuleGroup.runDtors().pure void __T17runModuleFuncsRevS482rt5minfo11ModuleGroup8runDtorsMFZv11__lambda283Z.runModuleFuncsRev(object.ModuleInfo*[])

Used by:

• void rt.minfo.ModuleGroup.runDtors()

Uses:

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

void rt.minfo.ModuleGroup.sortCtors()

Used by:

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

Uses:

• malloc@plt
• void rt.minfo.sortCtors(ref rt.minfo.ModuleGroup)

void rt.minfo.onCycleError(rt.minfo.StackRec[])

Used by:

• void rt.minfo.sortCtorsImpl(ref rt.minfo.ModuleGroup, rt.minfo.StackRec[])

Uses:

• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_newclass
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• _d_arrayappendT
• _d_throwc

extern (C) void rt.minfo.rt_moduleCtor().int __foreachbody544(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 __foreachbody547(ref rt.sections_linux.DSO)

Uses:

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

void rt.minfo.sortCtorsImpl(ref rt.minfo.ModuleGroup, rt.minfo.StackRec[])

Used by:

• void rt.minfo.sortCtors(ref rt.minfo.ModuleGroup)

Uses:

• pure nothrow @property object.ModuleInfo*[] object.ModuleInfo.importedModules()
• void rt.minfo.onCycleError(rt.minfo.StackRec[])

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

Uses:

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

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

Uses:

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

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

Used by:

• const(TypeInfo_Class) object.TypeInfo_Class.find(const(char[]))
• int object.ModuleInfo.opApply(scope int delegate(ref object.ModuleInfo*))
• runModuleUnitTests

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 __foreachbody541(ref rt.sections_linux.DSO)

Uses:

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

void rt.minfo.sortCtors(ref rt.minfo.ModuleGroup)

Used by:

• void rt.minfo.ModuleGroup.sortCtors()

Uses:

• __alloca
• malloc@plt
• free@plt
• void rt.minfo.sortCtorsImpl(ref rt.minfo.ModuleGroup, rt.minfo.StackRec[])

void rt.tlsgc.__unittest_fail(int)

Uses:

• _d_unittestm

rt.tlsgc.__array

Uses:

• _d_array_bounds

void rt.tlsgc.__assert(int)

Uses:

• _d_assertm

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void runAll()

Uses:

• rt_moduleDtor
• void rt.sections_linux.finiSections()
• void rt.memory.initStaticDataGC()
• rt_moduleCtor
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate())
• rt_moduleTlsDtor
• void rt.sections_linux.initSections()
• rt_moduleTlsCtor
• runModuleUnitTests
• thread_joinAll
• gc_init
• gc_term

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void runMain()

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate())

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void runAll()
• _d_run_main

Uses:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void print(object.Throwable)

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printLocLine(object.Throwable)

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void print(object.Throwable)

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• rt.util.console.Console rt.util.console.Console.opCall(ulong)

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void print(object.Throwable)

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• rt.util.console.Console rt.util.console.Console.opCall(ulong)

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable)

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void print(object.Throwable)

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable).int __foreachbody515(ref const(char[]))

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))

extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void print(object.Throwable)

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate())

Uses:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printMsgLine(object.Throwable)
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printInfoBlock(object.Throwable)
• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• _d_dynamic_cast
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate()).void printLocLine(object.Throwable)

void rt.dmain2.__unittest_fail(int)

Uses:

• _d_unittestm

rt.dmain2.CArgs rt.dmain2._cArgs

Used by:

• _d_run_main
• rt_cArgs

rt.dmain2.__array

Uses:

• _d_array_bounds

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

Used by:

• rt_args
• _d_run_main

void rt.dmain2.__assert(int)

Uses:

• _d_assertm

void rt.memory.initStaticDataGC()

Used by:

• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void runAll()
• rt_init

Uses:

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

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

Uses:

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

void rt.lifetime.__doPostblit(void*, ulong, const(TypeInfo))

Used by:

• _d_arraysetlengthiT
• _d_arraysetcapacity
• _d_arraycatT
• _d_arraycatnT
• _d_arrayappendcTX
• _d_arrayappendcd
• _d_arraysetlengthT
• _d_arrayappendT
• _adDupT

Uses:

• _d_dynamic_cast

rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)

Used by:

• _d_arraysetlengthiT
• _d_arrayshrinkfit
• _d_arraysetcapacity
• _d_delarray_t
• _d_arrayappendcTX
• _d_arraysetlengthT

Uses:

• _DYNAMIC
• malloc@plt
• memset@plt

void rt.lifetime._staticDtor17()

Used by:

• void rt.lifetime.__moddtor()

Uses:

• _DYNAMIC
• free@plt

bool function(Object)* rt.lifetime.collectHandler

Used by:

• rt_setCollectHandler
• rt_getCollectHandler
• rt_finalize2

void rt.lifetime.__unittest_fail(int)

Uses:

• _d_unittestm

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

Used by:

• _d_arraysetlengthiT
• _d_arrayliteralTX
• _d_arrayshrinkfit
• _d_arraysetcapacity
• _d_newarrayT
• _d_arraycatT
• _d_arraycatnT
• _d_newarrayiT
• _d_arrayappendcTX
• _d_arraysetlengthT
• _adDupT

Uses:

• _d_monitorenter
• _d_monitorexit

rt.lifetime.__array

Uses:

• _d_array_bounds

void rt.lifetime.__assert(int)

Uses:

• _d_assertm

void rt.lifetime.__moddtor()

Uses:

• void rt.lifetime._staticDtor17()

void rt.monitor_.__unittest_fail(int)

Uses:

• _d_unittestm

int rt.monitor_.inited

Used by:

• _STI_monitor_staticctor
• _STD_monitor_staticdtor

rt.monitor_.__array

Uses:

• _d_array_bounds

void rt.monitor_.__assert(int)

Uses:

• _d_assertm

const(pure nothrow @property @trusted uint function()) rt.typeinfo.ti_C.TypeInfo_C.flags

const(pure nothrow @property @trusted ulong function()) rt.typeinfo.ti_C.TypeInfo_C.tsize

const(@trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_C.TypeInfo_C.equals

Uses:

• bool object.opEquals(Object, Object)

const(@trusted int function(const(void*), const(void*))) rt.typeinfo.ti_C.TypeInfo_C.compare

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_C.TypeInfo_C.getHash

rt.typeinfo.ti_AC.TypeInfo_AC.nextinout(pure nothrow @property inout(TypeInfo) function())

const(bool function(const(void*), const(void*))) rt.typeinfo.ti_AC.TypeInfo_AC.equals

const(int function(const(void*), const(void*))) rt.typeinfo.ti_AC.TypeInfo_AC.compare

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_AC.TypeInfo_AC.getHash

bool rt.typeinfo.ti_AC.TypeInfo_AC.opEquals(Object)

Uses:

• bool object.TypeInfo.opEquals(Object)

const(immutable(char)[] function()) rt.typeinfo.ti_AC.TypeInfo_AC.toString

Uses:

• const(immutable(char)[] function()) object.TypeInfo.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_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 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_dchar.TypeInfo_w.init

Uses:

• _d_arraycast

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

Uses:

• _d_arraycast

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

pure nothrow @trusted bool rt.typeinfo.ti_float.TypeInfo_f._equals(float, float)

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

Uses:

• pure nothrow @trusted int rt.typeinfo.ti_float.TypeInfo_f._compare(float, float)

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

pure nothrow @trusted int rt.typeinfo.ti_float.TypeInfo_f._compare(float, float)

Used by:

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

const(pure nothrow @trusted immutable(char)[] function()) rt.typeinfo.ti_float.TypeInfo_f.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

Uses:

• _d_arraycast

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_Afloat.TypeInfo_Af.nextinout(pure nothrow @property inout(TypeInfo) function())

const(bool function(const(void*), const(void*))) rt.typeinfo.ti_Afloat.TypeInfo_Af.equals

const(int function(const(void*), const(void*))) rt.typeinfo.ti_Afloat.TypeInfo_Af.compare

Uses:

• pure nothrow @trusted int rt.typeinfo.ti_float.TypeInfo_f._compare(float, float)

const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Afloat.TypeInfo_Af.getHash

Uses:

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

bool rt.typeinfo.ti_Afloat.TypeInfo_Af.opEquals(Object)

Uses:

• bool object.TypeInfo.opEquals(Object)

const(immutable(char)[] function()) rt.typeinfo.ti_Afloat.TypeInfo_Af.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 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

void rt.critical_.__unittest_fail(int)

Uses:

• _d_unittestm

rt.critical_.__array

Uses:

• _d_array_bounds

void rt.critical_.__assert(int)

Uses:

• _d_assertm

rt.critical_.D_CRITICAL_SECTION* rt.critical_.dcs_list

Used by:

• _STD_critical_term
• _STI_critical_init
• _d_criticalenter

...druntime.import.object.di.2193.__unittest_fail.FiZv

Uses:

• _d_unittestm

...druntime.import.object.di.2193.__array

Uses:

• _d_array_bounds

...druntime.import.object.di.2193.__assert.FiZv

Uses:

• _d_assertm

...druntime.import.object.di.2319.__unittest_fail.FiZv

Uses:

• _d_unittestm

...druntime.import.object.di.2319.__array

Uses:

• _d_array_bounds

...druntime.import.object.di.2319.__assert.FiZv

Uses:

• _d_assertm

...druntime.import.object.di.2326.__unittest_fail.FiZv

Uses:

• _d_unittestm

...druntime.import.object.di.2326.__array

Uses:

• _d_array_bounds

...druntime.import.object.di.2326.__assert.FiZv

Uses:

• _d_assertm

TypeInfo_S3std4file15DirIteratorImpl.__init

Used by:

• void object.destroy!(std.file.DirIteratorImpl).destroy(ref std.file.DirIteratorImpl)
• std.conv.__T7emplaceTS3std4file15DirIteratorImplTAyaTE3std4file8SpanModeTbZ.emplace.FPS3std4file15DirIteratorImplKAyaKE3std4file8SpanModeKbZPS3std4file15DirIteratorImpl10initializeMFZv
• void std.algorithm.move!(std.file.DirIteratorImpl).move(ref std.file.DirIteratorImpl, ref std.file.DirIteratorImpl)

void std.functional.__unittest_fail(int)

Uses:

• _d_unittestm

pure nothrow @safe bool std.functional.binaryFun!("a < b").binaryFun!(uint, uint).binaryFun(uint, uint)

pure nothrow @safe bool std.functional.binaryFun!("a < b").binaryFun!(const(uint), const(uint)).binaryFun(const(uint), const(uint))

pure nothrow @safe bool std.functional.binaryFun!("a < b").binaryFun!(immutable(char)[], immutable(char)[]).binaryFun(immutable(char)[], immutable(char)[])

Uses:

• _adCmp2

pure nothrow @safe bool std.functional.binaryFun!("a <= b").binaryFun!(uint, const(uint)).binaryFun(uint, const(uint))

pure nothrow @safe bool std.functional.binaryFun!("a <= b").binaryFun!(const(uint), uint).binaryFun(const(uint), uint)

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

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

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

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

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

pure nothrow @safe bool std.functional.binaryFun!("b < a.timeT").binaryFun!(std.datetime.PosixTimeZone.Transition, long).binaryFun(std.datetime.PosixTimeZone.Transition, long)

pure nothrow @safe bool std.functional.binaryFun!("b < a.timeT").binaryFun!(std.datetime.PosixTimeZone.LeapSecond, immutable(long)).binaryFun(std.datetime.PosixTimeZone.LeapSecond, immutable(long))

pure nothrow @safe bool std.functional.binaryFun!("b < a.timeT").binaryFun!(std.datetime.PosixTimeZone.Transition, immutable(long)).binaryFun(std.datetime.PosixTimeZone.Transition, immutable(long))

pure nothrow @safe bool std.functional.binaryFun!("a.end <= b.end").binaryFun!(std.internal.uni_tab.CommonCaseEntry, immutable(std.internal.uni_tab.CommonCaseEntry)).binaryFun(std.internal.uni_tab.CommonCaseEntry, immutable(std.internal.uni_tab.CommonCaseEntry))

pure nothrow @safe bool std.functional.binaryFun!("a.end <= b.end").binaryFun!(immutable(std.internal.uni_tab.CommonCaseEntry), std.internal.uni_tab.CommonCaseEntry).binaryFun(immutable(std.internal.uni_tab.CommonCaseEntry), std.internal.uni_tab.CommonCaseEntry)

pure nothrow @safe bool std.functional.binaryFun!("a.timeT < b.timeT").binaryFun!(std.datetime.PosixTimeZone.TempTransition, std.datetime.PosixTimeZone.TempTransition).binaryFun(std.datetime.PosixTimeZone.TempTransition, std.datetime.PosixTimeZone.TempTransition)

pure nothrow @safe bool std.functional.binaryFun!("a.timeT < b.timeT").binaryFun!(std.datetime.PosixTimeZone.LeapSecond, std.datetime.PosixTimeZone.LeapSecond).binaryFun(std.datetime.PosixTimeZone.LeapSecond, std.datetime.PosixTimeZone.LeapSecond)

pure nothrow @safe bool std.functional.binaryFun!("a.start <= b.start").binaryFun!(std.internal.uni_tab.CommonCaseEntry, immutable(std.internal.uni_tab.CommonCaseEntry)).binaryFun(std.internal.uni_tab.CommonCaseEntry, immutable(std.internal.uni_tab.CommonCaseEntry))

pure nothrow @safe bool std.functional.binaryFun!("a.start <= b.start").binaryFun!(immutable(std.internal.uni_tab.CommonCaseEntry), std.internal.uni_tab.CommonCaseEntry).binaryFun(immutable(std.internal.uni_tab.CommonCaseEntry), std.internal.uni_tab.CommonCaseEntry)

std.functional.__array

Uses:

• _d_array_bounds

void std.functional.__assert(int)

Uses:

• _d_assertm

pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).binarySearch(dchar)

Uses:

• std.uni.__array

pure nothrow @safe bool std.uni.isPunctuation(dchar)

Used by:

• void std.format.formatChar!(std.array.Appender!(immutable(char)[]).Appender).formatChar(std.array.Appender!(immutable(char)[]).Appender, const(dchar), const(char))

Uses:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePc

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePd

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePe

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).checkTableEntry()
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePf

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePi

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).checkTableEntry()
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePo

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePs

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isNonCharacter(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isNonCharacter(dchar).immutable(dchar[2][]) table

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).checkTableEntry()

void std.uni.__unittest_fail(int)

Uses:

• _d_unittestm

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isAlpha(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isAlpha(dchar).immutable(dchar[2][]) table

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isAlpha(dchar).immutable(dchar[2][]) table
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isMark(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMc

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMc
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isMark(dchar)

Uses:

• pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMe
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMe
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isMark(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMn

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMn
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isFormat(dchar)

Uses:

• pure nothrow @safe bool std.uni.isFormat(dchar).immutable(dchar[2][]) tableCf
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isFormat(dchar).immutable(dchar[2][]) tableCf
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isNumber(dchar)

Uses:

• pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNd
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNd
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isNumber(dchar)

Uses:

• pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNl
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNl
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isNumber(dchar)

Uses:

• pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNo
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNo
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isSymbol(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSc

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSc
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isSymbol(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSk

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSk
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isSymbol(dchar)

Uses:

• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSm
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSm
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isSymbol(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSo

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSo
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isNonCharacter(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isNonCharacter(dchar).immutable(dchar[2][]) table

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni14isNonCharacterFNaNbNfwZb5tableyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isNonCharacter(dchar).immutable(dchar[2][]) table
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isPunctuation(dchar)

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePc
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePcyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePc
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isPunctuation(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePd

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePdyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePd
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isPunctuation(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePe

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePeyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePe
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isPunctuation(dchar)

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePf
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePfyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePf
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isPunctuation(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))
• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePi

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePiyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePi
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isPunctuation(dchar)

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePo
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePoyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePo
• memcpy@plt

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).binarySearch(dchar)

Used by:

• pure nothrow @safe bool std.uni.isPunctuation(dchar)

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePs
• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni13isPunctuationFNaNbNfwZb7tablePsyAG2w).checkTableEntry()

Uses:

• pure nothrow @safe bool std.uni.isPunctuation(dchar).immutable(dchar[2][]) tablePs
• memcpy@plt

pure nothrow @safe bool std.uni.isMark(dchar)

Used by:

• void std.format.formatChar!(std.array.Appender!(immutable(char)[]).Appender).formatChar(std.array.Appender!(immutable(char)[]).Appender, const(dchar), const(char))

Uses:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMc

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).checkTableEntry()
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMcyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMe

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni6isMarkFNaNbNfwZb7tableMeyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isMark(dchar).immutable(dchar[2][]) tableMn

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni6isMarkFNaNbNfwZb7tableMnyAG2w).checkTableEntry()

std.uni.__array

Used by:

• pure nothrow @safe bool std.uni.binarySearch2(dchar, immutable(dchar[2][]))

Uses:

• _d_array_bounds

pure nothrow @safe bool std.uni.isAlpha(dchar)

Used by:

• pure nothrow @safe bool std.uni.isLower(dchar)
• void std.format.formatChar!(std.array.Appender!(immutable(char)[]).Appender).formatChar(std.array.Appender!(immutable(char)[]).Appender, const(dchar), const(char))
• pure nothrow @safe bool std.uni.isUpper(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isAlpha(dchar).immutable(dchar[2][]) table

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).checkTableEntry()
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni7isAlphaFNaNbNfwZb5tableyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isLower(dchar)

Used by:

• pure @trusted immutable(char)[] std.string.toUpper!(immutable(char)[]).toUpper(immutable(char)[]).int __foreachbody3490(ref ulong, ref dchar)
• pure @trusted immutable(char)[] std.string.toUpper!(immutable(char)[]).toUpper(immutable(char)[]).int __foreachbody3490(ref ulong, ref dchar).@safe int __foreachbody3491(ref dchar)

Uses:

• pure nothrow @safe dchar std.uni.toLower(dchar)
• pure nothrow @safe bool std.uni.isAlpha(dchar)
• pure nothrow @safe bool std.ascii.isASCII(dchar)
• pure nothrow @safe bool std.ascii.isLower(dchar)

pure nothrow @safe bool std.uni.isUpper(dchar)

Used by:

• pure @trusted immutable(char)[] std.string.toLower!(immutable(char)[]).toLower(immutable(char)[]).int __foreachbody2747(ref ulong, ref dchar)
• pure @trusted const(char)[] std.string.toLower!(const(char)[]).toLower(const(char)[]).@safe int __foreachbody2817(ref ulong, ref dchar).@safe int __foreachbody2818(ref dchar)
• pure @trusted immutable(char)[] std.string.toLower!(immutable(char)[]).toLower(immutable(char)[]).int __foreachbody2747(ref ulong, ref dchar).@safe int __foreachbody2748(ref dchar)
• pure @trusted const(char)[] std.string.toLower!(const(char)[]).toLower(const(char)[]).@safe int __foreachbody2817(ref ulong, ref dchar)

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.uni.isAlpha(dchar)
• pure nothrow @safe dchar std.uni.toUpper(dchar)
• pure nothrow @safe bool std.ascii.isASCII(dchar)

pure nothrow @safe bool std.uni.isWhite(dchar)

Used by:

• pure @safe immutable(char)[] std.string.stripRight!(immutable(char)).stripRight(immutable(char)[]).@safe int __foreachbody4111(ref ulong, ref dchar)
• pure @safe immutable(char)[] std.string.stripLeft!(immutable(char)).stripLeft(immutable(char)[]).@safe int __foreachbody4110(ref ulong, ref dchar)

Uses:

• pure nothrow @safe bool std.ascii.isWhite(dchar)

pure nothrow @safe dchar std.uni.toLower(dchar)

Used by:

• pure @trusted const(char)[] std.string.toLower!(const(char)[]).toLower(const(char)[]).@safe int __foreachbody2817(ref ulong, ref dchar).@safe int __foreachbody2818(ref dchar)
• pure nothrow @safe bool std.uni.isLower(dchar)
• pure long std.string.indexOf!(char).indexOf(const(char[]), dchar, std.string.CaseSensitive).@safe int __foreachbody3458(ref long, ref dchar)
• pure @trusted immutable(char)[] std.string.toLower!(immutable(char)[]).toLower(immutable(char)[]).int __foreachbody2747(ref ulong, ref dchar).@safe int __foreachbody2748(ref dchar)
• pure long std.string.indexOf!(char, char).indexOf(const(char)[], const(char)[], std.string.CaseSensitive).pure nothrow @safe bool __lambda616(dchar, dchar)

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)

pure nothrow @safe dchar std.uni.toUpper(dchar)

Used by:

• pure nothrow @safe bool std.uni.isUpper(dchar)
• pure @trusted immutable(char)[] std.string.toUpper!(immutable(char)[]).toUpper(immutable(char)[]).int __foreachbody3490(ref ulong, ref dchar).@safe int __foreachbody3491(ref dchar)

Uses:

• pure nothrow @safe bool std.ascii.isLower(dchar)

void std.uni.__assert(int)

Uses:

• _d_assertm

pure nothrow @safe bool std.uni.isFormat(dchar)

Uses:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isFormat(dchar).immutable(dchar[2][]) tableCf

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).checkTableEntry()
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isFormatFNaNbNfwZb7tableCfyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isNumber(dchar)

Used by:

• void std.format.formatChar!(std.array.Appender!(immutable(char)[]).Appender).formatChar(std.array.Appender!(immutable(char)[]).Appender, const(dchar), const(char))

Uses:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNd

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isNumberFNaNbNfwZb7tableNdyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNl

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isNumberFNaNbNfwZb7tableNlyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isNumber(dchar).immutable(dchar[2][]) tableNo

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).checkTableEntry()
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isNumberFNaNbNfwZb7tableNoyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isSymbol(dchar)

Used by:

• void std.format.formatChar!(std.array.Appender!(immutable(char)[]).Appender).formatChar(std.array.Appender!(immutable(char)[]).Appender, const(dchar), const(char))

Uses:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSc

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableScyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSk

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableSkyAG2w).checkTableEntry()

pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSm

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).checkTableEntry()
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSmyAG2w).binarySearch(dchar)

pure nothrow @safe bool std.uni.isSymbol(dchar).immutable(dchar[2][]) tableSo

Used by:

• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).binarySearch(dchar)
• pure nothrow @safe bool std.uni.binarySearch!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).binarySearch(dchar).pure nothrow @property @safe bool checkTableEntry!(_D3std3uni8isSymbolFNaNbNfwZb7tableSoyAG2w).checkTableEntry()

pure @trusted uint std.utf.strideImpl(char, ulong)

Used by:

• pure @safe uint std.utf.stride!(immutable(char)[]).stride(ref immutable(char)[], ulong)
• pure @safe uint std.utf.stride!(const(char)[]).stride(ref const(char)[], ulong)
• pure @safe uint std.utf.stride!(const(char[])).stride(ref const(char[]), ulong)
• pure @safe ulong std.utf.toUCSindex!(char).toUCSindex(const(char)[], ulong)

Uses:

• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

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

Uses:

• pure nothrow @safe int std.algorithm.min!(ulong, int).min(ulong, int)
• _d_arraycopy
• std.utf.__array

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

Used by:

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

Uses:

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

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

Used by:

• pure @trusted uint std.utf.strideImpl(char, ulong)
• 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, immutable(char)[]).decodeImpl(ref immutable(char)[], ref ulong).pure @safe std.utf.UTFException exception!(immutable(char)[]).exception(immutable(char)[], immutable(char)[])
• pure @safe uint std.utf.strideBack!(char[]).strideBack(ref char[], ulong)
• pure @safe uint std.utf.strideBack!(const(char)[]).strideBack(ref const(char)[], ulong)
• pure @safe ulong std.utf.toUCSindex!(char).toUCSindex(const(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)[])
• pure @safe uint std.utf.strideBack!(immutable(char)[]).strideBack(ref immutable(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_arraycatT
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• immutable(char)[] std.string.format!(char, ulong).format(const(char[]), ulong)

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

• pure @safe const(char)[] std.algorithm.find!(_D3std4path14isDirSeparatorFNaNbNfwZb, const(char)[]).find(const(char)[])
• void std.format.FormatSpec!(char).FormatSpec.fillUp()
• int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure @safe bool std.algorithm.startsWith!("a == b", const(char)[], char).startsWith(const(char)[], char)
• pure @property @safe dchar std.array.back!(const(char)).back(const(char)[])
• pure @safe int std.internal.uni.comparePropertyName!(char).comparePropertyName(const(char)[], const(char)[])
• pure const(char)[] std.algorithm.simpleMindedFind!(_D3std6string16__T7indexOfTaTaZ7indexOfFAxaAxaE3std6string13CaseSensitiveZl11__lambda616FNaNbNfwwZb, const(char)[], const(char)[]).simpleMindedFind(const(char)[], const(char)[])
• const(char)[] std.format.FormatSpec!(char).FormatSpec.headUpToNextSpec()
• pure @property @safe dchar std.array.front!(const(char)).front(const(char)[])
• pure @safe bool std.algorithm.balancedParens!(const(char)[], char).balancedParens(const(char)[], char, char, ulong)
• immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])

Uses:

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

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

Used by:

• pure @property @safe dchar std.array.front!(const(wchar)).front(const(wchar)[])

Uses:

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

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

Used by:

• pure @safe immutable(char)[] std.algorithm.find!("a == b", immutable(char)[], char).find(immutable(char)[], char)
• immutable(char)[] timeduration.getTwoEleOut!(immutable(char)[], immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[], ref std.format.FormatSpec!(char).FormatSpec)
• std.range.__T5retroTAyaZ.retro.FNaNbNfAyaZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result6Result5frontMFNdZw
• std.algorithm.__T4findVAyaa6_61203d3d2062TS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultTaZ.find.FS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultaZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result
• pure @property @safe dchar std.array.front!(immutable(char)).front(immutable(char)[])
• pure @safe dchar std.range.moveFront!(immutable(char)[]).moveFront(immutable(char)[])
• pure @safe bool std.algorithm.skipOver!("a == b", immutable(char)[], char).skipOver(ref immutable(char)[], char)
• int timeduration.getTwoEleOut!(int, immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• void std.format.formatElement!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], char).formatElement(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], ref std.format.FormatSpec!(char).FormatSpec)
• pure @property @safe dchar std.array.back!(immutable(char)).back(immutable(char)[])
• int std.conv.parse!(int, immutable(char)[]).parse(ref immutable(char)[])
• immutable(char)[] std.conv.convError_unexpected!(immutable(char)[]).convError_unexpected(immutable(char)[])
• pure @safe dchar std.range.moveBack!(immutable(char)[]).moveBack(immutable(char)[])
• std.algorithm.__T16simpleMindedFindVAyaa6_61203d3d2062TS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultTS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultZ.simpleMindedFind.FS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result

Uses:

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

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

Used by:

• pure @safe void std.utf.validate!(const(char)[]).validate(const(char[]))

Uses:

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

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

Used by:

• pure @safe void std.utf.validate!(const(wchar)[]).validate(const(wchar[]))

Uses:

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

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

Used by:

• pure @safe void std.utf.validate!(const(dchar)[]).validate(const(dchar[]))

Uses:

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

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

Uses:

• pure @trusted uint std.utf.strideImpl(char, ulong)

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

Uses:

• pure @trusted uint std.utf.strideImpl(char, ulong)

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

Uses:

• pure @trusted uint std.utf.strideImpl(char, ulong)

void std.utf.__unittest_fail(int)

Uses:

• _d_unittestm

pure @safe void std.utf.validate!(const(char)[]).validate(const(char[]))

Uses:

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

pure @safe void std.utf.validate!(const(wchar)[]).validate(const(wchar[]))

Uses:

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

pure @safe void std.utf.validate!(const(dchar)[]).validate(const(dchar[]))

Uses:

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

pure @safe ulong std.utf.toUCSindex!(char).toUCSindex(const(char)[], ulong)

Uses:

• pure @trusted uint std.utf.strideImpl(char, ulong)
• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

pure nothrow @safe ubyte std.utf.codeLength!(immutable(char)).codeLength(dchar)

Used by:

• pure @safe immutable(char)[] std.string.stripRight!(immutable(char)).stripRight(immutable(char)[]).@safe int __foreachbody4111(ref ulong, ref dchar)

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

Used by:

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

Uses:

• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

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

Used by:

• pure @trusted void std.array.popBack!(const(char)).popBack(ref const(char)[])
• pure @property @safe dchar std.array.back!(const(char)).back(const(char)[])

Uses:

• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

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

Used by:

• std.range.__T5retroTAyaZ.retro.FNaNbNfAyaZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result6Result8popFrontMFZv
• std.range.__T5retroTAyaZ.retro.FNaNbNfAyaZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result6Result5frontMFNdZw
• std.algorithm.__T4findVAyaa6_61203d3d2062TS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultTaZ.find.FS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultaZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result
• pure @trusted void std.array.popBack!(immutable(char)).popBack(ref immutable(char)[])
• pure @property @safe dchar std.array.back!(immutable(char)).back(immutable(char)[])
• pure @safe dchar std.range.moveBack!(immutable(char)[]).moveBack(immutable(char)[])
• std.algorithm.__T16simpleMindedFindVAyaa6_61203d3d2062TS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultTS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultZ.simpleMindedFind.FS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultS3std5range14__T5retroTAyaZ5retroFAyaZ6ResultZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result

Uses:

• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _d_newclass
• _d_throwc

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:

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

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

Uses:

• 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()

Uses:

• 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)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException invalidUTF()

Uses:

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

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

Used by:

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

Uses:

• 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)[])
• _d_throwc

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

Uses:

• 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).std.utf.UTFException outOfBounds()

Uses:

• 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)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).std.utf.UTFException outOfBounds()
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).std.utf.UTFException invalidUTF()

Uses:

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

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

Used by:

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

Uses:

• _d_newclass
• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throwc

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

Uses:

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

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

Used by:

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

• 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)[])
• _d_throwc

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

Uses:

• 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).std.utf.UTFException outOfBounds()

Uses:

• 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)
• pure dchar std.utf.decodeImpl!(true, const(char[])).decodeImpl(ref const(char[]), ref ulong).std.utf.UTFException outOfBounds()
• pure dchar std.utf.decodeImpl!(true, const(char[])).decodeImpl(ref const(char[]), ref ulong).std.utf.UTFException invalidUTF()

Uses:

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

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

Used by:

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

Uses:

• _d_newclass
• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throwc

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

Uses:

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

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

Used by:

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

Uses:

• _d_newclass
• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throwc

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

Used by:

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

Uses:

• _d_arrayappendcTX
• _d_newclass
• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throwc
• std.utf.__array
• _d_arrayappendT

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

Used by:

• void std.array.Appender!(immutable(char)[]).Appender.put!(const(dchar)).put(const(dchar))
• immutable(char)[] std.conv.toImpl!(immutable(char)[], dchar).toImpl(dchar)
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatChar!(std.array.Appender!(immutable(char)[]).Appender).formatChar(std.array.Appender!(immutable(char)[]).Appender, const(dchar), const(char))
• immutable(char)[] std.conv.text!(immutable(char)[], dchar, immutable(char)[]).text(immutable(char)[], dchar, immutable(char)[])
• 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)
• immutable(char)[] timeduration.getTwoEleOut!(immutable(char)[], immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• immutable(char)[] std.conv.textImpl!(immutable(char)[], dchar, dchar).textImpl(dchar, dchar)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, dchar, uint, uint)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], dchar, immutable(char)[]).textImpl(immutable(char)[], dchar, immutable(char)[])
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, const(dchar)).put(ref std.array.Appender!(immutable(char)[]).Appender, const(dchar))
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, dchar, uint)
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, dchar).put(ref std.array.Appender!(immutable(char)[]).Appender, dchar)
• const(char)[] std.format.FormatSpec!(char).FormatSpec.headUpToNextSpec()
• void std.array.Appender!(const(char)[]).Appender.put!(dchar).put(dchar)
• immutable(char)[] std.conv.toStr!(immutable(char)[], dchar).toStr(dchar)
• void std.format.formatElement!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatElement(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)
• void std.array.Appender!(char[]).Appender.put!(dchar).put(dchar)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(dchar).to(dchar)
• int timeduration.getTwoEleOut!(int, immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.array.Appender!(immutable(char)[]).Appender.put!(dchar).put(dchar)

Uses:

• _d_newclass
• std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throwc

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

Used by:

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

std.utf.__array

Used by:

• pure @safe void std.utf.encode(ref char[], dchar)
• pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)

Uses:

• _d_array_bounds

void std.utf.__assert(int)

Uses:

• _d_assertm

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[]).textImpl(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[])

Used by:

• immutable(char)[] std.format.FormatSpec!(char).FormatSpec.toString()
• immutable(char)[] std.conv.text!(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[]).text(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[])

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, void*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, void*, ref std.format.FormatSpec!(char).FormatSpec)
• 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)
• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ubyte, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ubyte, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, bool, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, bool, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT
• _adDupT

immutable(char)[] std.conv.text!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong).text(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong)

Uses:

• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong)

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

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

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

Used by:

• std.file.FileException std.file.FileException.__ctor(const(char[]), uint, immutable(char)[], ulong)
• @trusted immutable(char)[] std.process.searchPathFor(const(char[]))

Uses:

• strlen@plt
• _adDupT

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

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, void*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, void*, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

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

Used by:

• pure @safe immutable(char)[] std.path.buildPath!(char).buildPath(const(char[])[]...).pure @trusted immutable(char)[] joinPaths(const(char)[], const(char)[])

Uses:

• _adDupT

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

Used by:

• pure @safe std.datetime.Month std.conv.parse!(std.datetime.Month, immutable(char)[]).parse(ref 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
• std.exception.ErrnoException std.exception.ErrnoException.__ctor(immutable(char)[], immutable(char)[], ulong)
• std.process.ProcessException std.process.ProcessException.newFromErrno(immutable(char)[], immutable(char)[], ulong)
• std.stdio.StdioException std.stdio.StdioException.__ctor(immutable(char)[], uint)
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName
• @trusted immutable(char)[][immutable(char)[]] std.process.environment.toAA()

Uses:

• strlen@plt
• _adDupT

immutable(char)[] std.conv.to!(immutable(char)[]).to!(immutable(char)[][]).to(immutable(char)[][])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[][], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[][], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.regex.IR).to(std.regex.IR)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.LeapSecond).to(std.datetime.PosixTimeZone.LeapSecond)

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond, ref std.format.FormatSpec!(char).FormatSpec)

immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.LeapSecond[]).to(std.datetime.PosixTimeZone.LeapSecond[])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond[], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.TempTransition).to(std.datetime.PosixTimeZone.TempTransition)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.TempTransition[]).to(std.datetime.PosixTimeZone.TempTransition[])

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition[], ref std.format.FormatSpec!(char).FormatSpec)

immutable(char)[] std.conv.to!(immutable(char)[]).to!(char).to(char)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(bool).to(bool)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, bool, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, bool, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(ubyte).to(ubyte)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ubyte, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ubyte, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(int).to(int)

Uses:

• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint).to(uint)

Uses:

• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

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

Uses:

• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(ushort).to(ushort)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ushort, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ushort, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.to!(immutable(char)[]).to!(dchar).to(dchar)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt

immutable(char)[] std.conv.text!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong).text(immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong)

Uses:

• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong)

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong)

Used by:

• immutable(char)[] std.conv.text!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong).text(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong)

Uses:

• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond, ref std.format.FormatSpec!(char).FormatSpec)
• _d_arrayappendT

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong)

Used by:

• immutable(char)[] std.conv.text!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong).text(immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition, ref std.format.FormatSpec!(char).FormatSpec)
• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

Used by:

• void std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(immutable(char)[], int).convError(immutable(char)[], immutable(char)[], ulong)
• pure @safe bool std.exception.enforceEx!(std.conv.ConvException).enforceEx!(bool).enforceEx(bool, lazy immutable(char)[], immutable(char)[], ulong)
• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• void std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(const(char)[], uint).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(immutable(char)[], std.datetime.Month).convError(immutable(char)[], immutable(char)[], ulong)
• pure @safe std.datetime.Month std.conv.parse!(std.datetime.Month, immutable(char)[]).parse(ref immutable(char)[])

Uses:

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

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

immutable(char)[] std.conv.text!(dchar, dchar).text(dchar, dchar)

Used by:

• void std.getopt.handleOption!(void delegate(immutable(char)[], immutable(char)[])).handleOption(immutable(char)[], void delegate(immutable(char)[], immutable(char)[]), ref immutable(char)[][], ref std.getopt.configuration, bool).int __foreachbody2469(ref dchar)
• void std.getopt.handleOption!(void delegate()).handleOption(immutable(char)[], void delegate(), ref immutable(char)[][], ref std.getopt.configuration, bool).int __foreachbody2443(ref dchar)

Uses:

• immutable(char)[] std.conv.textImpl!(immutable(char)[], dchar, dchar).textImpl(dchar, dchar)

immutable(char)[] std.conv.text!(immutable(char)[], char).text(immutable(char)[], char)

Used by:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[][], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[][], ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, const(ubyte)[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref const(ubyte)[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition[], ref std.format.FormatSpec!(char).FormatSpec)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

pure nothrow @safe int std.conv.toImpl!(int, int).toImpl(int)

pure @safe int std.conv.toImpl!(int, uint).toImpl(uint)

Used by:

• pure @safe int std.format.getNthInt!(uint).getNthInt(uint, uint)
• pure @safe int std.format.getNthInt!(uint, uint).getNthInt(uint, uint, uint)
• pure @safe int std.format.getNthInt!(uint, uint, uint).getNthInt(uint, uint, uint, uint)
• pure @safe int std.format.getNthInt!(uint, const(uint), const(uint), const(uint)).getNthInt(uint, uint, const(uint), const(uint), const(uint))
• pure @safe int std.conv.to!(int).to!(uint).to(uint)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)

pure @safe int std.conv.toImpl!(int, uint).toImpl(uint).pure @safe object.Throwable __dgliteral2306()

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass

pure @safe int std.conv.toImpl!(int, long).toImpl(long)

Used by:

• pure @safe int std.conv.to!(int).to!(long).to(long)
• pure @safe int std.format.getNthInt!(long, long).getNthInt(uint, long, long)
• pure @safe int std.format.getNthInt!(long).getNthInt(uint, long)

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass
• _d_throwc

pure @safe int std.conv.toImpl!(int, ulong).toImpl(ulong)

Used by:

• pure @safe int std.format.getNthInt!(ulong).getNthInt(uint, ulong)
• pure @safe int std.format.getNthInt!(ulong, immutable(char)[], ulong).getNthInt(uint, ulong, immutable(char)[], ulong)
• pure @safe int std.conv.to!(int).to!(ulong).to(ulong)
• pure @safe int std.format.getNthInt!(ulong, immutable(char)[]).getNthInt(uint, ulong, immutable(char)[])

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass
• _d_throwc

pure nothrow @safe ulong std.conv.toImpl!(ulong, ulong).toImpl(ulong)

void std.conv.__unittest_fail(int)

Uses:

• _d_unittestm

ubyte std.conv.parse!(ubyte, const(char)[]).parse(ref const(char)[])

Used by:

• void std.format.FormatSpec!(char).FormatSpec.fillUp()

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• void std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)
• _d_newclass
• _d_throwc

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

Used by:

• void std.format.FormatSpec!(char).FormatSpec.fillUp()

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• void std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)
• pure @trusted dchar std.utf.decode!(const(char)[]).decode(ref const(char)[], ref ulong)
• _d_newclass
• _d_throwc

int std.conv.parse!(int, immutable(char)[]).parse(ref immutable(char)[])

Used by:

• int std.conv.toImpl!(int, immutable(char)[]).toImpl(immutable(char)[])

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• void std.conv.convError!(immutable(char)[], int).convError(immutable(char)[], immutable(char)[], ulong)
• pure @trusted dchar std.utf.decode!(immutable(char)[]).decode(ref immutable(char)[], ref ulong)
• _d_newclass
• _d_throwc

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

Used by:

• void std.format.FormatSpec!(char).FormatSpec.fillUp()
• ubyte std.conv.parse!(ubyte, const(char)[]).parse(ref const(char)[])

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure @trusted dchar std.utf.decode!(const(char)[]).decode(ref const(char)[], ref ulong)
• _d_newclass
• void std.conv.convError!(const(char)[], uint).convError(const(char)[], immutable(char)[], ulong)
• _d_throwc

immutable(char)[] std.conv.toStr!(immutable(char)[], char).toStr(char)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], bool).toStr(bool)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, bool, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, bool, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], ubyte).toStr(ubyte)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ubyte, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ubyte, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], int).toStr(int)

Uses:

• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], uint).toStr(uint)

Uses:

• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], ulong).toStr(ulong)

Uses:

• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], ushort).toStr(ushort)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ushort, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ushort, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], dchar).toStr(dchar)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt

pure ubyte std.conv.toImpl!(ubyte, const(uint)).toImpl(const(uint))

Used by:

• void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure ubyte std.conv.to!(ubyte).to!(const(uint)).to(const(uint))

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass
• _d_throwc

pure nothrow @safe int std.conv.toImpl!(int, const(ubyte)).toImpl(const(ubyte))

pure @safe int std.conv.toImpl!(int, const(uint)).toImpl(const(uint))

Used by:

• pure @safe int std.format.getNthInt!(const(uint), const(uint), const(uint)).getNthInt(uint, const(uint), const(uint), const(uint))
• void std.format.FormatSpec!(char).FormatSpec.fillUp()
• pure @safe int std.format.getNthInt!(const(uint)).getNthInt(uint, const(uint))
• pure @safe int std.conv.to!(int).to!(const(uint)).to(const(uint))
• pure @safe int std.format.getNthInt!(const(uint), const(uint)).getNthInt(uint, const(uint), const(uint))

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)

pure @safe int std.conv.toImpl!(int, const(uint)).toImpl(const(uint)).pure @safe object.Throwable __dgliteral2142()

Uses:

• std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass

pure nothrow @safe int std.conv.toImpl!(int, const(short)).toImpl(const(short))

pure nothrow @safe uint* std.conv.emplace!(uint, uint).emplace(uint*, uint)

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

Used by:

• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], immutable(char)[], immutable(char)[]).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), immutable(char)[], immutable(char)[], immutable(char)[]).pure @safe immutable(char)[] __dgliteral3928()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).pure @safe immutable(char)[] __dgliteral2659()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong, immutable(char)[], ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong, immutable(char)[], ulong).pure @safe immutable(char)[] __dgliteral2787()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).pure @safe immutable(char)[] __dgliteral2633()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(uint)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(uint)).pure @safe immutable(char)[] __dgliteral2971()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], immutable(char)[]).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), immutable(char)[], immutable(char)[]).pure @safe immutable(char)[] __dgliteral4018()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.DateTime)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.DateTime)).pure @safe immutable(char)[] __dgliteral2591()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint, const(uint), const(uint), const(uint)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint, const(uint), const(uint), const(uint)).pure @safe immutable(char)[] __dgliteral2951()
• 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)[] __dgliteral3383()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(ubyte)[], char).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(ubyte)[], char).pure @safe immutable(char)[] __dgliteral2334()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), dchar, uint, uint).pure @safe immutable(char)[] __dgliteral2934()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(ubyte), const(ubyte), const(ubyte)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(ubyte), const(ubyte), const(ubyte)).pure @safe immutable(char)[] __dgliteral4001()
• void std.format.FormatSpec!(char).FormatSpec.fillUp()
• void std.format.FormatSpec!(char).FormatSpec.fillUp().pure @safe immutable(char)[] __dgliteral2132()
• uint std.format.formattedWrite!(void delegate(const(char)[]), char, const(real)).formattedWrite(void delegate(const(char)[]), const(char[]), const(real)).pure @safe immutable(char)[] __dgliteral2502()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), dchar, uint).pure @safe immutable(char)[] __dgliteral2928()
• void std.format.FormatSpec!(char).FormatSpec.fillUp().void check(bool).pure @safe const(char)[] __dgliteral2029()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, Exception).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), Exception).pure @safe immutable(char)[] __dgliteral4098()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).pure @safe immutable(char)[] __dgliteral2724()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), immutable(char)[], uint).pure @safe immutable(char)[] __dgliteral2959()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(short), const(std.datetime.Month), const(ubyte)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(short), const(std.datetime.Month), const(ubyte)).pure @safe immutable(char)[] __dgliteral3978()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, std.datetime.DateTime, const(std.datetime.DateTime)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), std.datetime.DateTime, const(std.datetime.DateTime)).pure @safe immutable(char)[] __dgliteral2572()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).pure @safe immutable(char)[] __dgliteral2704()
• @trusted std.process.Pid std.process.spawnProcessImpl(const(char[][]), std.stdio.File, std.stdio.File, std.stdio.File, const(immutable(char)[][immutable(char)[]]), std.process.Config)
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.DateTime), const(std.datetime.DateTime)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.DateTime), const(std.datetime.DateTime)).pure @safe immutable(char)[] __dgliteral2616()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).pure @safe immutable(char)[] __dgliteral2715()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, long, long).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), long, long).pure @safe immutable(char)[] __dgliteral4047()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint).pure @safe immutable(char)[] __dgliteral2302()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, void*, ulong, immutable(char)[]).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), void*, ulong, immutable(char)[]).pure @safe immutable(char)[] __dgliteral2798()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).pure @safe immutable(char)[] __dgliteral2686()
• 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)[] __dgliteral2863()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint, uint, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint, uint, uint).pure @safe immutable(char)[] __dgliteral2965()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[]).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), immutable(char)[]).pure @safe immutable(char)[] __dgliteral2537()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).pure @safe immutable(char)[] __dgliteral2677()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(uint), const(uint)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(uint), const(uint)).pure @safe immutable(char)[] __dgliteral3114()
• uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(short), immutable(char)[], const(ubyte)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(short), immutable(char)[], const(ubyte)).pure @safe immutable(char)[] __dgliteral3994()

Uses:

• _adDupT
• _d_arrayappendT

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

Uses:

• _d_arrayappendT

immutable(char)[] std.conv.toStr!(immutable(char)[], void*).toStr(void*)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, void*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, void*, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], char).toImpl(char)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], bool).toImpl(bool)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, bool, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, bool, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ubyte, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ubyte, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int)

Uses:

• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint)

Uses:

• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong)

Uses:

• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ushort, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ushort, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], dchar).toImpl(dchar)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt

int std.conv.toImpl!(int, immutable(char)[]).toImpl(immutable(char)[])

Used by:

• int std.conv.to!(int).to!(immutable(char)[]).to(immutable(char)[])
• int timeduration.getTwoEleOut!(int, immutable(char)[]).getTwoEleOut(ref immutable(char)[])

Uses:

• void std.conv.convError!(immutable(char)[], int).convError(immutable(char)[], immutable(char)[], ulong)
• int std.conv.parse!(int, immutable(char)[]).parse(ref immutable(char)[])
• _d_throwc

pure immutable(char)[] std.conv.toImpl!(immutable(char)[], char*).toImpl(char*)

Uses:

• strlen@plt
• _adDupT

immutable(char)[] std.conv.toImpl!(immutable(char)[], void*).toImpl(void*)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, void*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, void*, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.text!(immutable(char)[], dchar, immutable(char)[]).text(immutable(char)[], dchar, immutable(char)[])

Used by:

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

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt
• _d_arrayappendT

immutable(char)[] std.conv.toStr!(immutable(char)[], immutable(char)[][]).toStr(immutable(char)[][])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[][], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[][], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

pure nothrow @safe const(char)[] std.conv.toImpl!(const(char)[], const(char)[]).toImpl(const(char)[])

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

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

Uses:

• _adDupT

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

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

Uses:

• strlen@plt
• _adDupT

immutable(char)[] std.conv.toImpl!(immutable(char)[], immutable(char)[][]).toImpl(immutable(char)[][])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[][], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[][], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

void std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)

Used by:

• ubyte std.conv.parse!(ubyte, const(char)[]).parse(ref const(char)[])

Uses:

• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• _d_throwc

void std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)

Used by:

• int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])

Uses:

• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• _d_throwc

void std.conv.convError!(const(char)[], uint).convError(const(char)[], immutable(char)[], ulong)

Used by:

• uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])

Uses:

• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• _d_throwc

void std.conv.convError!(immutable(char)[], int).convError(immutable(char)[], immutable(char)[], ulong)

Used by:

• int std.conv.toImpl!(int, immutable(char)[]).toImpl(immutable(char)[])
• int std.conv.parse!(int, immutable(char)[]).parse(ref immutable(char)[])

Uses:

• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• immutable(char)[] std.conv.convError_unexpected!(immutable(char)[]).convError_unexpected(immutable(char)[])
• _d_throwc

std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)

Used by:

• pure @safe int std.conv.toImpl!(int, uint).toImpl(uint).pure @safe object.Throwable __dgliteral2306()
• pure @safe int std.conv.toImpl!(int, ulong).toImpl(ulong)
• int std.conv.parse!(int, const(char)[]).parse(ref const(char)[])
• uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure ubyte std.conv.toImpl!(ubyte, const(uint)).toImpl(const(uint))
• pure @safe int std.conv.toImpl!(int, const(uint)).toImpl(const(uint)).pure @safe object.Throwable __dgliteral2142()
• pure @safe int std.conv.toImpl!(int, long).toImpl(long)
• ubyte std.conv.parse!(ubyte, const(char)[]).parse(ref const(char)[])
• int std.conv.parse!(int, immutable(char)[]).parse(ref immutable(char)[])

Uses:

• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

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

Used by:

• std.file.FileException std.file.FileException.__ctor(const(char[]), const(char[]), immutable(char)[], ulong)

Uses:

• _adDupT
• _d_arrayappendT

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

Uses:

• _adDupT
• _d_arrayappendT

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

Used by:

• void std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(immutable(char)[], int).convError(immutable(char)[], immutable(char)[], ulong)
• void std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(const(char)[], uint).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(immutable(char)[], std.datetime.Month).convError(immutable(char)[], immutable(char)[], ulong)

Uses:

• _d_arrayappendT

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

immutable(char)[] std.conv.textImpl!(immutable(char)[], dchar, dchar).textImpl(dchar, dchar)

Used by:

• immutable(char)[] std.conv.text!(dchar, dchar).text(dchar, dchar)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt
• _d_arrayappendT

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], char).textImpl(immutable(char)[], char)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

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

Used by:

• immutable(char)[] std.string.format!(char, const(std.datetime.DateTime)).format(const(char[]), const(std.datetime.DateTime)).pure @safe object.Throwable __dgliteral2596()
• immutable(char)[] std.string.format!(char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).format(const(char[]), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).pure @safe object.Throwable __dgliteral2664()
• immutable(char)[] std.string.format!(char, const(short), immutable(char)[], const(ubyte)).format(const(char[]), const(short), immutable(char)[], const(ubyte)).pure @safe object.Throwable __dgliteral3999()
• immutable(char)[] std.string.format!(char, immutable(char)[], immutable(char)[]).format(const(char[]), immutable(char)[], immutable(char)[]).pure @safe object.Throwable __dgliteral4023()
• immutable(char)[] std.string.format!(char, ulong).format(const(char[]), ulong).pure @safe object.Throwable __dgliteral2868()
• immutable(char)[] std.string.format!(char, ulong, immutable(char)[], ulong).format(const(char[]), ulong, immutable(char)[], ulong).pure @safe object.Throwable __dgliteral2795()
• immutable(char)[] std.string.format!(char, void*, ulong, immutable(char)[]).format(const(char[]), void*, ulong, immutable(char)[]).pure @safe object.Throwable __dgliteral2803()
• immutable(char)[] std.string.format!(char, Exception).format(const(char[]), Exception).pure @safe object.Throwable __dgliteral4103()
• immutable(char)[] std.string.format!(char, immutable(char)[], immutable(char)[], immutable(char)[]).format(const(char[]), immutable(char)[], immutable(char)[], immutable(char)[]).pure @safe object.Throwable __dgliteral3933()
• immutable(char)[] std.string.format!(char, long, long).format(const(char[]), long, long).pure @safe object.Throwable __dgliteral4055()
• immutable(char)[] std.string.format!(char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).format(const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).pure @safe object.Throwable __dgliteral2729()
• immutable(char)[] std.string.format!(char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).format(const(char[]), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).pure @safe object.Throwable __dgliteral2691()
• immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint).pure @safe object.Throwable __dgliteral2871()
• immutable(char)[] std.string.format!(char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).format(const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).pure @safe object.Throwable __dgliteral2720()
• immutable(char)[] std.string.format!(char, const(short), const(std.datetime.Month), const(ubyte)).format(const(char[]), const(short), const(std.datetime.Month), const(ubyte)).pure @safe object.Throwable __dgliteral3992()
• immutable(char)[] std.string.format!(char, immutable(char)[]).format(const(char[]), immutable(char)[]).pure @safe object.Throwable __dgliteral2545()
• immutable(char)[] std.string.format!(char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).format(const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).pure @safe object.Throwable __dgliteral2709()
• immutable(char)[] std.string.format!(char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).format(const(char[]), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).pure @safe object.Throwable __dgliteral2638()
• immutable(char)[] std.string.format!(char, std.datetime.DateTime, const(std.datetime.DateTime)).format(const(char[]), std.datetime.DateTime, const(std.datetime.DateTime)).pure @safe object.Throwable __dgliteral2577()
• immutable(char)[] std.string.format!(char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).format(const(char[]), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).pure @safe object.Throwable __dgliteral2682()
• immutable(char)[] std.string.format!(char, const(std.datetime.DateTime), const(std.datetime.DateTime)).format(const(char[]), const(std.datetime.DateTime), const(std.datetime.DateTime)).pure @safe object.Throwable __dgliteral2621()
• immutable(char)[] std.string.format!(char, const(ubyte), const(ubyte), const(ubyte)).format(const(char[]), const(ubyte), const(ubyte), const(ubyte)).pure @safe object.Throwable __dgliteral4006()
• immutable(char)[] std.string.format!(char, int).format(const(char[]), int).pure @safe object.Throwable __dgliteral3388()

Uses:

• 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)
• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

pure nothrow @property @safe int std.conv.octal!(int, "666").octal()

pure nothrow @property @safe int std.conv.octal!(int, "777").octal()

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

Uses:

• _adDupT
• _d_arrayappendT

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

Uses:

• _d_arrayappendT

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], dchar, immutable(char)[]).textImpl(immutable(char)[], dchar, immutable(char)[])

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt
• _d_arrayappendT

std.datetime.Month std.conv.to!(std.datetime.Month).to!(immutable(char)[]).to(immutable(char)[])

Used by:

• timeduration.returndtfromtext.__ctor.MFNcAyaAyaZS12timeduration16returndtfromtext17__foreachbody2750MFKwZi

Uses:

• std.datetime.Month std.conv.toImpl!(std.datetime.Month, immutable(char)[]).toImpl(immutable(char)[])

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

Used by:

• std.stdio.File.__ctor.MFNcAyaxAaZS3std5stdio4File15__dgliteral4655MFNaNfZAya

Uses:

• _d_arrayappendT
• _adDupT

immutable(char)[] std.conv.toStr!(immutable(char)[], std.regex.IR).toStr(std.regex.IR)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

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

Uses:

• _adDupT
• _d_arrayappendT

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

Uses:

• _adDupT
• _d_arrayappendT

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

Uses:

• _d_arrayappendT

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

Used by:

• void std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)
• void std.conv.convError!(const(char)[], uint).convError(const(char)[], immutable(char)[], ulong)

Uses:

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

immutable(char)[] std.conv.convError_unexpected!(immutable(char)[]).convError_unexpected(immutable(char)[])

Used by:

• void std.conv.convError!(immutable(char)[], int).convError(immutable(char)[], immutable(char)[], ulong)
• void std.conv.convError!(immutable(char)[], std.datetime.Month).convError(immutable(char)[], immutable(char)[], ulong)

Uses:

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

immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[][], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[][], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

immutable(char)[] std.conv.toImpl!(immutable(char)[], std.regex.IR).toImpl(std.regex.IR)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

nothrow std.datetime.DateTime std.conv.to!(std.datetime.DateTime).to!(std.datetime.SysTime).to(std.datetime.SysTime)

Uses:

• const(nothrow std.datetime.DateTime function()) std.datetime.SysTime.opCast!(std.datetime.DateTime).opCast

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:

• 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)
• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

pure @safe std.datetime.Month std.conv.parse!(std.datetime.Month, immutable(char)[]).parse(ref immutable(char)[])

Used by:

• std.datetime.Month std.conv.toImpl!(std.datetime.Month, immutable(char)[]).toImpl(immutable(char)[])

Uses:

• pure nothrow @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(immutable(char)[]).to(immutable(char)[])
• _d_arraycatnT
• _d_newclass
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure nothrow @safe bool std.algorithm.startsWith!("a == b", immutable(char)[], immutable(char)[]).startsWith(immutable(char)[], immutable(char)[])
• _d_throwc

pure nothrow @safe int std.conv.toImpl!(int, const(std.datetime.Month)).toImpl(const(std.datetime.Month))

std.datetime.Month std.conv.toImpl!(std.datetime.Month, immutable(char)[]).toImpl(immutable(char)[])

Used by:

• std.datetime.Month std.conv.to!(std.datetime.Month).to!(immutable(char)[]).to(immutable(char)[])

Uses:

• void std.conv.convError!(immutable(char)[], std.datetime.Month).convError(immutable(char)[], immutable(char)[], ulong)
• pure @safe std.datetime.Month std.conv.parse!(std.datetime.Month, immutable(char)[]).parse(ref immutable(char)[])
• _d_throwc

immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong).text(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong)

Uses:

• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong)

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

Uses:

• _d_arrayappendT
• _adDupT

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[]).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[][], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[][], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

void std.conv.convError!(immutable(char)[], std.datetime.Month).convError(immutable(char)[], immutable(char)[], ulong)

Used by:

• std.datetime.Month std.conv.toImpl!(std.datetime.Month, immutable(char)[]).toImpl(immutable(char)[])

Uses:

• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)
• immutable(char)[] std.conv.convError_unexpected!(immutable(char)[]).convError_unexpected(immutable(char)[])
• _d_throwc

nothrow std.file.DirIteratorImpl* std.conv.emplace!(std.file.DirIteratorImpl).emplace(std.file.DirIteratorImpl*)

Used by:

• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize!().initialize()

Uses:

• _DYNAMIC
• memcpy@plt

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong)

Used by:

• immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong).text(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong)

Uses:

• 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 ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

void std.conv.toTextRange!(long, std.stdio.File.LockingTextWriter).toTextRange(long, std.stdio.File.LockingTextWriter)

Used by:

• void std.stdio.File.write!(long, char).write(long, char)

Uses:

• void std.stdio.File.LockingTextWriter.put!(char[]).put(char[])
• funlockfile@plt

immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond).toStr(std.datetime.PosixTimeZone.LeapSecond)

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond, ref std.format.FormatSpec!(char).FormatSpec)

immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[]).toStr(std.datetime.PosixTimeZone.LeapSecond[])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond[], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond).toImpl(std.datetime.PosixTimeZone.LeapSecond)

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond, ref std.format.FormatSpec!(char).FormatSpec)

immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[]).toImpl(std.datetime.PosixTimeZone.LeapSecond[])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond[], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

nothrow std.datetime.DateTime std.conv.toImpl!(std.datetime.DateTime, std.datetime.SysTime).toImpl(std.datetime.SysTime)

Uses:

• const(nothrow std.datetime.DateTime function()) std.datetime.SysTime.opCast!(std.datetime.DateTime).opCast

immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition).toStr(std.datetime.PosixTimeZone.TempTransition)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition[]).toStr(std.datetime.PosixTimeZone.TempTransition[])

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition[], ref std.format.FormatSpec!(char).FormatSpec)

immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition).toImpl(std.datetime.PosixTimeZone.TempTransition)

Uses:

• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])

immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition[]).toImpl(std.datetime.PosixTimeZone.TempTransition[])

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition[], ref std.format.FormatSpec!(char).FormatSpec)

std.file.DirIteratorImpl* std.conv.emplace!(std.file.DirIteratorImpl, immutable(char)[], std.file.SpanMode, bool).emplace(std.file.DirIteratorImpl*, ref immutable(char)[], ref std.file.SpanMode, ref bool)

Used by:

• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.initialize!(immutable(char)[], std.file.SpanMode, bool).initialize(ref immutable(char)[], ref std.file.SpanMode, ref bool)

Uses:

• ref std.file.DirIteratorImpl std.file.DirIteratorImpl.__ctor(immutable(char)[], std.file.SpanMode, bool)
• std.conv.__T7emplaceTS3std4file15DirIteratorImplTAyaTE3std4file8SpanModeTbZ.emplace.FPS3std4file15DirIteratorImplKAyaKE3std4file8SpanModeKbZPS3std4file15DirIteratorImpl10initializeMFZv

std.conv.__T7emplaceTS3std4file15DirIteratorImplTAyaTE3std4file8SpanModeTbZ.emplace.FPS3std4file15DirIteratorImplKAyaKE3std4file8SpanModeKbZPS3std4file15DirIteratorImpl10initializeMFZv

Used by:

• std.file.DirIteratorImpl* std.conv.emplace!(std.file.DirIteratorImpl, immutable(char)[], std.file.SpanMode, bool).emplace(std.file.DirIteratorImpl*, ref immutable(char)[], ref std.file.SpanMode, ref bool)

Uses:

• memset@plt
• TypeInfo_S3std4file15DirIteratorImpl.__init
• memcpy@plt

immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond[], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[])

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition[], ref std.format.FormatSpec!(char).FormatSpec)

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[]).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[])

Uses:

• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond[], ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT

std.conv.__array

Uses:

• _d_array_bounds

immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[]).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[])

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[]).Appender std.array.Appender!(immutable(char)[]).Appender.__ctor(immutable(char)[])
• _d_arrayappendT
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition[], ref std.format.FormatSpec!(char).FormatSpec)

void std.conv.__assert(int)

Uses:

• _d_assertm

immutable(char)[] std.conv.text!(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[]).text(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[])

Uses:

• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[]).textImpl(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[])

pure ubyte std.conv.to!(ubyte).to!(const(uint)).to(const(uint))

Uses:

• pure ubyte std.conv.toImpl!(ubyte, const(uint)).toImpl(const(uint))

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

pure @safe int std.conv.to!(int).to!(const(uint)).to(const(uint))

Uses:

• pure @safe int std.conv.toImpl!(int, const(uint)).toImpl(const(uint))

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

int std.conv.to!(int).to!(immutable(char)[]).to(immutable(char)[])

Used by:

• timeduration.returndtfromtext.__ctor.MFNcAyaAyaZS12timeduration16returndtfromtext17__foreachbody2750MFKwZi

Uses:

• int std.conv.toImpl!(int, immutable(char)[]).toImpl(immutable(char)[])

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

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

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

Uses:

• pure @safe int std.conv.toImpl!(int, uint).toImpl(uint)

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

Uses:

• pure @safe int std.conv.toImpl!(int, long).toImpl(long)

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

Uses:

• pure @safe int std.conv.toImpl!(int, ulong).toImpl(ulong)

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

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult62__T6filterS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbZ35__T6filterTS3std4file11DirIteratorZ6filterMFS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor()
• const(void function(ref const(std.file.DirIterator))) std.file.DirIterator.__cpctor
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult6__ctorMFNcS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult11__fieldDtorMFZv

Uses:

• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor()

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult15__fieldPostBlitMFZv

Uses:

• nothrow @safe void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit()

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult5emptyMFNdZb

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult5frontMFNdZS3std4file8DirEntry

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult6__ctorMFNcS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Used by:

• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult62__T6filterS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbZ35__T6filterTS3std4file11DirIteratorZ6filterMFS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• pure nothrow @trusted inout(char)[] std.path.baseName!(char).baseName(inout(char)[])
• void std.file.DirIteratorImpl.popFront()
• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor()
• pure nothrow @safe bool std.path.__T9globMatchVE3std4path13CaseSensitive1TaZ.globMatch(const(char)[], const(char)[])
• const(void function(ref const(std.file.DirIterator))) std.file.DirIterator.__cpctor

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult7opSliceMFZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8__cpctorMxFKxS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResultZv

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8__cpctorMxFKxS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResultZv

Used by:

• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult7opSliceMFZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• nothrow @safe void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit()

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8opAssignMFNcS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResultZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor()

std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8popFrontMFZv

Uses:

• void std.file.DirIteratorImpl.popFront()
• pure nothrow @trusted inout(char)[] std.path.baseName!(char).baseName(inout(char)[])
• pure nothrow @safe bool std.path.__T9globMatchVE3std4path13CaseSensitive1TaZ.globMatch(const(char)[], const(char)[])

std.file.DirIterator std.file.dirEntries(immutable(char)[], std.file.SpanMode, bool)

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• ref std.file.DirIterator std.file.DirIterator.__ctor(immutable(char)[], std.file.SpanMode, bool)

void std.file.DirIterator.__fieldDtor()

Used by:

• ref std.file.DirIterator std.file.DirIterator.opAssign(std.file.DirIterator)
• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor()

void std.file.DirIterator.__fieldPostBlit()

Used by:

• const(void function(ref const(std.file.DirIterator))) std.file.DirIterator.__cpctor

Uses:

• nothrow @safe void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__postblit()

@property bool std.file.DirIterator.empty()

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayloadinout(nothrow ref @property @safe inout(std.file.DirIteratorImpl) function())
• @property bool std.file.DirIteratorImpl.empty()

@property std.file.DirEntry std.file.DirIterator.front()

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• @property std.file.DirEntry std.file.DirIteratorImpl.front()
• std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayloadinout(nothrow ref @property @safe inout(std.file.DirIteratorImpl) function())

ref std.file.DirIterator std.file.DirIterator.__ctor(immutable(char)[], std.file.SpanMode, bool)

Used by:

• std.file.DirIterator std.file.dirEntries(immutable(char)[], std.file.SpanMode, bool)

Uses:

• ref std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__ctor!(immutable(char)[], std.file.SpanMode, bool).__ctor(ref immutable(char)[], ref std.file.SpanMode, ref bool)
• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.opAssign(std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted)

const(void function(ref const(std.file.DirIterator))) std.file.DirIterator.__cpctor

Used by:

• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult62__T6filterS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbZ35__T6filterTS3std4file11DirIteratorZ6filterMFS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult6__ctorMFNcS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• void std.file.DirIterator.__fieldPostBlit()

ref std.file.DirIterator std.file.DirIterator.opAssign(std.file.DirIterator)

Uses:

• void std.file.DirIterator.__fieldDtor()

void std.file.DirIterator.popFront()

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• void std.file.DirIteratorImpl.popFront()
• std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.refCountedPayloadinout(nothrow ref @property @safe inout(std.file.DirIteratorImpl) function())

std.file.FileException std.file.FileException.__ctor(const(char[]), uint, immutable(char)[], ulong)

Used by:

• @safe char* std.file.cenforce!(char*).cenforce(char*, lazy const(char)[], immutable(char)[], ulong)
• @safe core.sys.posix.dirent.DIR* std.file.cenforce!(core.sys.posix.dirent.DIR*).cenforce(core.sys.posix.dirent.DIR*, lazy const(char)[], immutable(char)[], ulong)
• @safe bool std.file.cenforce!(bool).cenforce(bool, lazy const(char)[], immutable(char)[], ulong)

Uses:

• pure immutable(char)[] std.conv.to!(immutable(char)[]).to!(char*).to(char*)
• strerror@plt
• std.file.FileException std.file.FileException.__ctor(const(char[]), const(char[]), immutable(char)[], ulong)

std.file.FileException std.file.FileException.__ctor(const(char[]), const(char[]), immutable(char)[], ulong)

Used by:

• std.file.FileException std.file.FileException.__ctor(const(char[]), uint, immutable(char)[], ulong)

Uses:

• pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))
• pure @safe immutable(char)[] std.conv.text!(const(char)[], immutable(char)[], const(char)[]).text(const(char)[], immutable(char)[], const(char)[])
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _adDupT

uint std.file.getAttributes(const(char[]))

Used by:

• @property bool std.file.isDir(const(char[]))
• @property bool std.file.isFile(const(char[]))

Uses:

• pure nothrow immutable(char)* std.string.toStringz(const(char)[])
• stat64
• @safe bool std.file.cenforce!(bool).cenforce(bool, lazy const(char)[], immutable(char)[], ulong)

uint std.file.getAttributes(const(char[])).nothrow @safe const(char)[] __dgliteral3741()

bool std.file.DirIteratorImpl.__xopEquals(ref const(std.file.DirIteratorImpl), ref const(std.file.DirIteratorImpl))

Uses:

• const(pure nothrow @property immutable(char)[] function()) std.file.DirEntry.name

void std.file.DirIteratorImpl.popDirStack()

Used by:

• bool std.file.DirIteratorImpl.next()

Uses:

• std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirIteratorImpl.DirHandle)[] function())
• closedir@plt
• pure @safe void std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.shrinkTo(ulong)

void std.file.DirIteratorImpl.releaseDirStack()

Used by:

• void std.file.DirIteratorImpl.__dtor()

Uses:

• std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirIteratorImpl.DirHandle)[] function())
• closedir@plt

bool std.file.DirIteratorImpl.next()

Used by:

• bool std.file.DirIteratorImpl.stepIn(immutable(char)[])
• void std.file.DirIteratorImpl.popFront()

Uses:

• std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirIteratorImpl.DirHandle)[] function())
• readdir64@plt
• strcmp@plt
• void std.file.DirEntry._init(const(char[]), core.sys.posix.dirent.dirent*)
• void std.file.DirIteratorImpl.popDirStack()
• pure nothrow @property @safe bool std.array.empty!(std.file.DirIteratorImpl.DirHandle).empty(const(std.file.DirIteratorImpl.DirHandle[]))

@property bool std.file.DirIteratorImpl.empty()

Used by:

• void std.file.DirIteratorImpl.popFront()
• @property bool std.file.DirIterator.empty()

Uses:

• std.array.Appender!(std.file.DirEntry[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirEntry)[] function())
• pure nothrow @property @safe bool std.array.empty!(std.file.DirEntry).empty(const(std.file.DirEntry[]))
• std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirIteratorImpl.DirHandle)[] function())
• pure nothrow @property @safe bool std.array.empty!(std.file.DirIteratorImpl.DirHandle).empty(const(std.file.DirIteratorImpl.DirHandle[]))

@property std.file.DirEntry std.file.DirIteratorImpl.front()

Used by:

• @property std.file.DirEntry std.file.DirIterator.front()

ref std.file.DirIteratorImpl std.file.DirIteratorImpl.__ctor(immutable(char)[], std.file.SpanMode, bool)

Used by:

• std.file.DirIteratorImpl* std.conv.emplace!(std.file.DirIteratorImpl, immutable(char)[], std.file.SpanMode, bool).emplace(std.file.DirIteratorImpl*, ref immutable(char)[], ref std.file.SpanMode, ref bool)

Uses:

• _d_arrayliteralTX
• pure nothrow std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender std.array.appender!(std.file.DirIteratorImpl.DirHandle[], std.file.DirIteratorImpl.DirHandle).appender(std.file.DirIteratorImpl.DirHandle[])
• pure nothrow std.array.Appender!(std.file.DirEntry[]).Appender std.array.appender!(std.file.DirEntry[], std.file.DirEntry).appender(std.file.DirEntry[])
• bool std.file.DirIteratorImpl.stepIn(immutable(char)[])
• bool std.file.DirIteratorImpl.mayStepIn()
• const(pure nothrow @property immutable(char)[] function()) std.file.DirEntry.name
• void std.file.DirIteratorImpl.pushExtra(std.file.DirEntry)

void std.file.DirIteratorImpl.__dtor()

Used by:

• ref std.file.DirIteratorImpl std.file.DirIteratorImpl.opAssign(std.file.DirIteratorImpl)
• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.Impl.__fieldDtor()
• void std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.opAssign(std.file.DirIteratorImpl)

Uses:

• void std.file.DirIteratorImpl.releaseDirStack()

bool std.file.DirIteratorImpl.stepIn(immutable(char)[])

Used by:

• ref std.file.DirIteratorImpl std.file.DirIteratorImpl.__ctor(immutable(char)[], std.file.SpanMode, bool)
• void std.file.DirIteratorImpl.popFront()

Uses:

• bool std.file.DirIteratorImpl.next()
• pure nothrow immutable(char)* std.string.toStringz(immutable(char)[])
• @safe core.sys.posix.dirent.DIR* std.file.cenforce!(core.sys.posix.dirent.DIR*).cenforce(core.sys.posix.dirent.DIR*, lazy const(char)[], immutable(char)[], ulong)
• void std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.put!(std.file.DirIteratorImpl.DirHandle).put(std.file.DirIteratorImpl.DirHandle)
• opendir@plt

bool std.file.DirIteratorImpl.stepIn(immutable(char)[]).pure nothrow @safe const(char)[] __dgliteral3786()

bool std.file.DirIteratorImpl.hasExtra()

Used by:

• void std.file.DirIteratorImpl.popFront()

Uses:

• std.array.Appender!(std.file.DirEntry[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirEntry)[] function())
• pure nothrow @property @safe bool std.array.empty!(std.file.DirEntry).empty(const(std.file.DirEntry[]))

ref std.file.DirIteratorImpl std.file.DirIteratorImpl.opAssign(std.file.DirIteratorImpl)

Uses:

• void std.file.DirIteratorImpl.__dtor()

std.file.DirEntry std.file.DirIteratorImpl.popExtra()

Used by:

• void std.file.DirIteratorImpl.popFront()

Uses:

• std.array.Appender!(std.file.DirEntry[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirEntry)[] function())
• pure @safe void std.array.Appender!(std.file.DirEntry[]).Appender.shrinkTo(ulong)

void std.file.DirIteratorImpl.popFront()

Used by:

• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8popFrontMFZv
• void std.file.DirIterator.popFront()
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult6__ctorMFNcS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• bool std.file.DirIteratorImpl.next()
• bool std.file.DirIteratorImpl.stepIn(immutable(char)[])
• bool std.file.DirIteratorImpl.mayStepIn()
• const(pure nothrow @property immutable(char)[] function()) std.file.DirEntry.name
• void std.file.DirIteratorImpl.pushExtra(std.file.DirEntry)
• std.file.DirEntry std.file.DirIteratorImpl.popExtra()
• bool std.file.DirIteratorImpl.hasExtra()
• @property bool std.file.DirIteratorImpl.empty()

bool std.file.DirIteratorImpl.DirHandle.__xopEquals(ref const(std.file.DirIteratorImpl.DirHandle), ref const(std.file.DirIteratorImpl.DirHandle))

bool std.file.DirIteratorImpl.mayStepIn()

Used by:

• ref std.file.DirIteratorImpl std.file.DirIteratorImpl.__ctor(immutable(char)[], std.file.SpanMode, bool)
• void std.file.DirIteratorImpl.popFront()

Uses:

• nothrow bool std.file.attrIsDir(uint)
• @property uint std.file.DirEntry.linkAttributes()
• @property bool std.file.DirEntry.isDir()

void std.file.DirIteratorImpl.pushExtra(std.file.DirEntry)

Used by:

• ref std.file.DirIteratorImpl std.file.DirIteratorImpl.__ctor(immutable(char)[], std.file.SpanMode, bool)
• void std.file.DirIteratorImpl.popFront()

Uses:

• void std.array.Appender!(std.file.DirEntry[]).Appender.put!(std.file.DirEntry).put(std.file.DirEntry)

@safe bool std.file.cenforce!(bool).cenforce(bool, lazy const(char)[], immutable(char)[], ulong)

Used by:

• uint std.file.getAttributes(const(char[]))

Uses:

• _d_newclass
• nothrow @property @trusted int core.stdc.errno.errno()
• std.file.FileException std.file.FileException.__ctor(const(char[]), uint, immutable(char)[], ulong)
• _d_throwc

void std.file.__unittest_fail(int)

Uses:

• _d_unittestm

@safe char* std.file.cenforce!(char*).cenforce(char*, lazy const(char)[], immutable(char)[], ulong)

Uses:

• _d_newclass
• nothrow @property @trusted int core.stdc.errno.errno()
• std.file.FileException std.file.FileException.__ctor(const(char[]), uint, immutable(char)[], ulong)
• _d_throwc

@safe core.sys.posix.dirent.DIR* std.file.cenforce!(core.sys.posix.dirent.DIR*).cenforce(core.sys.posix.dirent.DIR*, lazy const(char)[], immutable(char)[], ulong)

Used by:

• bool std.file.DirIteratorImpl.stepIn(immutable(char)[])

Uses:

• _d_newclass
• nothrow @property @trusted int core.stdc.errno.errno()
• std.file.FileException std.file.FileException.__ctor(const(char[]), uint, immutable(char)[], ulong)
• _d_throwc

@property bool std.file.isDir(const(char[]))

Used by:

• immutable(std.datetime.PosixTimeZone) std.datetime.PosixTimeZone.getTimeZone(immutable(char)[], immutable(char)[])
• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• uint std.file.getAttributes(const(char[]))

@property bool std.file.exists(const(char[]))

Used by:

• immutable(std.datetime.PosixTimeZone) std.datetime.PosixTimeZone.getTimeZone(immutable(char)[], immutable(char)[])
• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• pure nothrow immutable(char)* std.string.toStringz(const(char)[])
• stat64

@property bool std.file.isFile(const(char[]))

Used by:

• immutable(std.datetime.PosixTimeZone) std.datetime.PosixTimeZone.getTimeZone(immutable(char)[], immutable(char)[])

Uses:

• uint std.file.getAttributes(const(char[]))

std.file.__array

Uses:

• _d_array_bounds

immutable(char)[] std.file.tempDir().immutable(char)[] findExistingDir!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[]).findExistingDir(lazy immutable(char)[], lazy immutable(char)[], lazy immutable(char)[], lazy immutable(char)[], lazy immutable(char)[], lazy immutable(char)[])

Uses:

• _d_newarrayiT
• stat64
• memcpy@plt

@property uint std.file.DirEntry.attributes()

Uses:

• void std.file.DirEntry._ensureStatDone()

bool std.file.DirEntry.__xopEquals(ref const(std.file.DirEntry), ref const(std.file.DirEntry))

Uses:

• const(pure nothrow @property immutable(char)[] function()) std.file.DirEntry.name

@property uint std.file.DirEntry.linkAttributes()

Used by:

• bool std.file.DirIteratorImpl.mayStepIn()

Uses:

• void std.file.DirEntry._ensureLStatDone()

void std.file.DirEntry._ensureStatDone()

Used by:

• @property uint std.file.DirEntry.attributes()
• @property bool std.file.DirEntry.isFile()
• @property ulong std.file.DirEntry.size()
• @property std.datetime.SysTime std.file.DirEntry.timeStatusChanged()
• @property std.datetime.SysTime std.file.DirEntry.timeLastAccessed()
• @property core.sys.posix.sys.stat.stat_t std.file.DirEntry.statBuf()
• @property bool std.file.DirEntry.isDir()
• @property std.datetime.SysTime std.file.DirEntry.timeLastModified()

Uses:

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

void std.file.DirEntry._ensureStatDone().pure nothrow @safe const(char)[] __dgliteral3763()

Uses:

• _d_arraycatnT

void std.file.DirEntry._ensureLStatDone()

Used by:

• @property uint std.file.DirEntry.linkAttributes()
• @property bool std.file.DirEntry.isSymlink()

Uses:

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

void std.file.DirEntry._ensureLStatDone().pure nothrow @safe const(char)[] __dgliteral3764()

Uses:

• _d_arraycatnT

@property std.datetime.SysTime std.file.DirEntry.timeLastAccessed()

Uses:

• pure nothrow long std.datetime.unixTimeToStdTime(long)
• void std.file.DirEntry._ensureStatDone()
• pure nothrow ref std.datetime.SysTime std.datetime.SysTime.__ctor(long, immutable(std.datetime.TimeZone))

@property std.datetime.SysTime std.file.DirEntry.timeLastModified()

Uses:

• pure nothrow long std.datetime.unixTimeToStdTime(long)
• void std.file.DirEntry._ensureStatDone()
• pure nothrow ref std.datetime.SysTime std.datetime.SysTime.__ctor(long, immutable(std.datetime.TimeZone))

@property std.datetime.SysTime std.file.DirEntry.timeStatusChanged()

Uses:

• pure nothrow long std.datetime.unixTimeToStdTime(long)
• void std.file.DirEntry._ensureStatDone()
• pure nothrow ref std.datetime.SysTime std.datetime.SysTime.__ctor(long, immutable(std.datetime.TimeZone))

const(pure nothrow @property immutable(char)[] function()) std.file.DirEntry.name

Used by:

• bool std.file.DirEntry.__xopEquals(ref const(std.file.DirEntry), ref const(std.file.DirEntry))
• ref std.file.DirIteratorImpl std.file.DirIteratorImpl.__ctor(immutable(char)[], std.file.SpanMode, bool)
• void std.file.DirIteratorImpl.popFront()
• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])
• bool std.file.DirIteratorImpl.__xopEquals(ref const(std.file.DirIteratorImpl), ref const(std.file.DirIteratorImpl))
• bool std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.Impl.__xopEquals(ref const(std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.Impl), ref const(std.typecons.__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.RefCountedStore.Impl))

@property ulong std.file.DirEntry.size()

Uses:

• void std.file.DirEntry._ensureStatDone()

void std.file.DirEntry._init(const(char[]), core.sys.posix.dirent.dirent*)

Used by:

• bool std.file.DirIteratorImpl.next()

Uses:

• strlen@plt
• _memset128ii
• pure @safe immutable(char)[] std.path.buildPath!(char).buildPath(const(char[])[]...)

void std.file.DirEntry._init(const(char[]))

Uses:

• _adDupT

@property bool std.file.DirEntry.isDir()

Used by:

• bool std.file.DirIteratorImpl.mayStepIn()

Uses:

• void std.file.DirEntry._ensureStatDone()

@property bool std.file.DirEntry.isFile()

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• void std.file.DirEntry._ensureStatDone()

@property core.sys.posix.sys.stat.stat_t std.file.DirEntry.statBuf()

Uses:

• void std.file.DirEntry._ensureStatDone()

@property bool std.file.DirEntry.isSymlink()

Uses:

• void std.file.DirEntry._ensureLStatDone()

void std.file.__assert(int)

Uses:

• _d_assertm

nothrow bool std.file.attrIsDir(uint)

Used by:

• bool std.file.DirIteratorImpl.mayStepIn()

pure nothrow @trusted ulong std.math.pow!(ulong, ulong).pow(ulong, ulong)

Used by:

• std.numeric.Fft std.numeric.Fft.__ctor(float[])

void std.math.__unittest_fail(int)

Uses:

• _d_unittestm

std.math.__array

Uses:

• _d_array_bounds

void std.math.__assert(int)

Uses:

• _d_assertm

pure nothrow @safe bool std.path.isDirSeparator(dchar)

Used by:

• pure nothrow @safe bool std.path.isRooted!(char).isRooted(const(char[]))
• pure @safe const(char)[] std.algorithm.find!(_D3std4path14isDirSeparatorFNaNbNfwZb, const(char)[]).find(const(char)[])
• pure nothrow @safe long std.path.lastSeparator!(char).lastSeparator(const(char[]))
• pure @safe immutable(char)[] std.path.buildPath!(char).buildPath(const(char[])[]...).pure @trusted immutable(char)[] joinPaths(const(char)[], const(char)[])
• pure nothrow @safe long std.path.extSeparatorPos!(char).extSeparatorPos(const(char[]))
• pure nothrow @safe inout(char)[] std.path.rtrimDirSeparators!(char).rtrimDirSeparators(inout(char)[])
• pure nothrow @safe int std.path.__T15filenameCharCmpVE3std4path13CaseSensitive1Z.filenameCharCmp(dchar, dchar)

pure nothrow @safe const(char)[] std.path.dirName!(const(char)).dirName(const(char)[])

Uses:

• pure nothrow @safe long std.path.lastSeparator!(char).lastSeparator(const(char[]))
• pure nothrow @safe inout(char)[] std.path.rtrimDirSeparators!(char).rtrimDirSeparators(inout(char)[])

pure nothrow @trusted inout(char)[] std.path.baseName!(char).baseName(inout(char)[])

Used by:

• modules.commandline_parser.parseoptions modules.commandline_parser.parseoptions.__ctor(immutable(char)[][], modules.sharedtypes.logSettings*)
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8popFrontMFZv
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult6__ctorMFNcS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• pure nothrow @safe long std.path.lastSeparator!(char).lastSeparator(const(char[]))
• pure nothrow @safe inout(char)[] std.path.rtrimDirSeparators!(char).rtrimDirSeparators(inout(char)[])

pure nothrow @safe bool std.path.isRooted!(char).isRooted(const(char[]))

Used by:

• pure @safe immutable(char)[] std.path.buildPath!(char).buildPath(const(char[])[]...).pure @trusted immutable(char)[] joinPaths(const(char)[], const(char)[])

Uses:

• pure nothrow @safe bool std.path.isDirSeparator(dchar)

void std.path.__unittest_fail(int)

Uses:

• _d_unittestm

pure @safe immutable(char)[] std.path.buildPath!(char).buildPath(const(char[])[]...)

Used by:

• void std.file.DirEntry._init(const(char[]), core.sys.posix.dirent.dirent*)
• @trusted immutable(char)[] std.process.searchPathFor(const(char[]))

Uses:

• pure @safe const(char)[] std.algorithm.reduce!(_D3std4path16__T9buildPathTaZ9buildPathFNaNfAxAaXAya9joinPathsFNaNeAxaAxaZAya).reduce!(const(char[])[]).reduce(const(char[])[])
• _adDupT

pure @safe immutable(char)[] std.path.buildPath!(char).buildPath(const(char[])[]...).pure @trusted immutable(char)[] joinPaths(const(char)[], const(char)[])

Used by:

• pure @safe const(char)[] std.algorithm.reduce!(_D3std4path16__T9buildPathTaZ9buildPathFNaNfAxAaXAya9joinPathsFNaNeAxaAxaZAya).reduce!(const(char)[], const(char[])[]).reduce(const(char)[], const(char[])[])

Uses:

• pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))
• pure nothrow @safe bool std.path.isRooted!(char).isRooted(const(char[]))
• _d_arraycatT
• _d_arraycatnT
• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)[]).to(const(char)[])
• pure nothrow @safe bool std.path.isDirSeparator(dchar)

pure nothrow @safe inout(char)[] std.path.extension!(char).extension(inout(char)[])

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• pure nothrow @safe long std.path.extSeparatorPos!(char).extSeparatorPos(const(char[]))

pure nothrow @safe inout(char)[] std.path.stripDrive!(char).stripDrive(inout(char)[])

pure nothrow @safe long std.path.lastSeparator!(char).lastSeparator(const(char[]))

Used by:

• pure nothrow @safe const(char)[] std.path.dirName!(const(char)).dirName(const(char)[])
• pure nothrow @trusted inout(char)[] std.path.baseName!(char).baseName(inout(char)[])

Uses:

• pure nothrow @safe bool std.path.isDirSeparator(dchar)

pure nothrow @safe long std.path.extSeparatorPos!(char).extSeparatorPos(const(char[]))

Used by:

• pure nothrow @safe inout(char)[] std.path.extension!(char).extension(inout(char)[])

Uses:

• pure nothrow @safe bool std.path.isDirSeparator(dchar)

pure nothrow @safe inout(char)[] std.path.rtrimDirSeparators!(char).rtrimDirSeparators(inout(char)[])

Used by:

• pure nothrow @safe const(char)[] std.path.dirName!(const(char)).dirName(const(char)[])
• pure nothrow @trusted inout(char)[] std.path.baseName!(char).baseName(inout(char)[])

Uses:

• pure nothrow @safe bool std.path.isDirSeparator(dchar)

pure nothrow @safe bool std.path.__T9globMatchVE3std4path13CaseSensitive1TaZ.globMatch(const(char)[], const(char)[])

Used by:

• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8popFrontMFZv
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult6__ctorMFNcS3std4file11DirIteratorZS3std4file10dirEntries93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

Uses:

• _d_arraycatT
• pure nothrow @safe int std.path.__T15filenameCharCmpVE3std4path13CaseSensitive1Z.filenameCharCmp(dchar, dchar)

pure nothrow @safe int std.path.__T15filenameCharCmpVE3std4path13CaseSensitive1Z.filenameCharCmp(dchar, dchar)

Used by:

• pure nothrow @safe bool std.path.__T9globMatchVE3std4path13CaseSensitive1TaZ.globMatch(const(char)[], const(char)[])

Uses:

• pure nothrow @safe bool std.path.isDirSeparator(dchar)

std.path.__array

Uses:

• _d_array_bounds

void std.path.__assert(int)

Uses:

• _d_assertm

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

Uses:

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

pure nothrow ref @property @safe ubyte std.array.back!(ubyte).back(ubyte[])

pure nothrow ref @property @safe uint std.array.back!(uint).back(uint[])

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

pure nothrow @property @safe char[] std.array.save!(char).save(char[])

pure nothrow @property @safe float[] std.array.save!(float).save(float[])

pure nothrow @property @safe ubyte[] std.array.save!(ubyte).save(ubyte[])

pure nothrow @property @safe uint[] std.array.save!(uint).save(uint[])

pure nothrow @property @safe dchar[] std.array.save!(dchar).save(dchar[])

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

Uses:

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

pure nothrow ref @property @safe const(uint) std.array.back!(const(uint)).back(const(uint)[])

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

Used by:

• std.algorithm.__T8splitterTAyaTaZ.splitter.FAyaaZS3std9algorithm19__T8splitterTAyaTaZ8splitterFAyaaZ6Result6Result7popBackMFZv

Uses:

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

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

pure nothrow @property @safe const(uint)[] std.array.save!(const(uint)).save(const(uint)[])

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

Used by:

• std.algorithm.__T8splitterTAyaTaZ.splitter.FAyaaZS3std9algorithm19__T8splitterTAyaTaZ8splitterFAyaaZ6Result6Result4saveMFNdZS3std9algorithm19__T8splitterTAyaTaZ8splitterFAyaaZ6Result
• std.algorithm.__T8splitterTAyaTAyaZ.splitter.FAyaAyaZS3std9algorithm21__T8splitterTAyaTAyaZ8splitterFAyaAyaZ6Result6Result4saveMFNdZS3std9algorithm21__T8splitterTAyaTAyaZ8splitterFAyaAyaZ6Result

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

Used by:

• std.algorithm.__T8splitterTAyaTaZ.splitter.FAyaaZS3std9algorithm19__T8splitterTAyaTaZ8splitterFAyaaZ6Result6Result7popBackMFZv
• immutable(std.datetime.PosixTimeZone) std.datetime.PosixTimeZone.getTimeZone(immutable(char)[], immutable(char)[])
• std.process.ProcessException std.process.ProcessException.newFromErrno(immutable(char)[], immutable(char)[], ulong)
• pure @safe immutable(char)[] std.path.buildPath!(char).buildPath(const(char[])[]...).pure @trusted immutable(char)[] joinPaths(const(char)[], const(char)[])
• pure nothrow immutable(char)* std.string.toStringz(immutable(char)[])
• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])
• immutable(immutable(std.datetime.PosixTimeZone) function(immutable(std.datetime.PosixTimeZone.Transition[]), immutable(std.datetime.PosixTimeZone.LeapSecond[]), immutable(char)[], immutable(char)[], immutable(char)[], bool)) std.datetime.PosixTimeZone.__ctor
• std.file.FileException std.file.FileException.__ctor(const(char[]), const(char[]), immutable(char)[], ulong)

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

Used by:

• immutable(std.datetime.PosixTimeZone) std.datetime.PosixTimeZone.getTimeZone(immutable(char)[], immutable(char)[])

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

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

Used by:

• const(@property @safe bool function()) std.internal.uni.CodepointSet.ByCodepoint.empty
• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.add(std.internal.uni.Interval)
• const(pure nothrow @property @safe bool function()) std.internal.uni.CodepointSet.empty
• const(@property @safe uint function()) std.internal.uni.CodepointSet.extent

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

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

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

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

Uses:

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

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

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

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

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

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

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

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

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

Uses:

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

pure nothrow ref @property @safe const(ubyte) std.array.front!(const(ubyte)).front(const(ubyte)[])

pure nothrow ref @property @safe const(uint) std.array.front!(const(uint)).front(const(uint)[])

pure @property @safe dchar std.array.front!(const(wchar)).front(const(wchar)[])

Uses:

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

pure nothrow ref @property @safe const(dchar) std.array.front!(const(dchar)).front(const(dchar)[])

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

Used by:

• std.range.__T5retroTAyaZ.retro.FNaNbNfAyaZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result6Result4backMFNdZw

Uses:

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

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

Used by:

• @trusted std.process.Pid std.process.spawnProcessImpl(const(char[][]), std.stdio.File, std.stdio.File, std.stdio.File, const(immutable(char)[][immutable(char)[]]), std.process.Config)

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)[][])

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

pure nothrow @trusted inout(void)[] std.array.overlap!(void).overlap(inout(void)[], inout(void)[])

Used by:

• pure nothrow @trusted bool std.exception.pointsTo!(std.stdio.File, std.stdio.File, void).pointsTo(ref const(std.stdio.File), ref const(std.stdio.File))
• pure nothrow @trusted bool std.exception.pointsTo!(immutable(char)[], std.stdio.File, void).pointsTo(ref const(immutable(char)[]), ref const(std.stdio.File))
• pure nothrow @trusted bool std.exception.pointsTo!(std.stdio.File, std.stdio.LockingTextReader, void).pointsTo(ref const(std.stdio.File), ref const(std.stdio.LockingTextReader))
• pure nothrow @trusted bool std.exception.pointsTo!(std.file.DirEntry, std.file.DirIteratorImpl, void).pointsTo(ref const(std.file.DirEntry), ref const(std.file.DirIteratorImpl))
• pure nothrow @trusted bool std.exception.pointsTo!(immutable(char)[], std.file.DirIteratorImpl, void).pointsTo(ref const(immutable(char)[]), ref const(std.file.DirIteratorImpl))
• pure nothrow @trusted bool std.exception.pointsTo!(immutable(char)[], immutable(char)[], void).pointsTo(ref const(immutable(char)[]), ref const(immutable(char)[]))
• pure nothrow @trusted bool std.exception.pointsTo!(immutable(char)[], std.stdio.LockingTextReader, void).pointsTo(ref const(immutable(char)[]), ref const(std.stdio.LockingTextReader))

pure nothrow @trusted inout(void)[] std.array.overlap!(void).overlap(inout(void)[], inout(void)[]).nothrow inout(void)* max(inout(void)*, inout(void)*)

pure nothrow @trusted inout(void)[] std.array.overlap!(void).overlap(inout(void)[], inout(void)[]).nothrow inout(void)* min(inout(void)*, inout(void)*)

pure @trusted void std.array.popBack!(char).popBack(ref char[])

Uses:

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

pure nothrow @safe void std.array.popBack!(ubyte).popBack(ref ubyte[])

pure nothrow @safe void std.array.popBack!(uint).popBack(ref uint[])

pure nothrow @safe void std.array.popBack!(dchar).popBack(ref dchar[])

pure @trusted void std.array.popBack!(const(char)).popBack(ref const(char)[])

Uses:

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

pure nothrow @safe void std.array.popBack!(const(uint)).popBack(ref const(uint)[])

pure @trusted void std.array.popBack!(immutable(char)).popBack(ref immutable(char)[])

Used by:

• std.algorithm.__T8splitterTAyaTaZ.splitter.FAyaaZS3std9algorithm19__T8splitterTAyaTaZ8splitterFAyaaZ6Result6Result7popBackMFZv
• nothrow immutable(char)[] std.datetime.fracSecToISOString(int)

Uses:

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

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

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

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

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

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

void std.array.__unittest_fail(int)

Uses:

• _d_unittestm

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

void std.array.Appender!(char[]).Appender.put!(char).put(char)

Uses:

• void std.array.Appender!(char[]).Appender.ensureAddable(ulong)

void std.array.Appender!(char[]).Appender.put!(dchar).put(dchar)

Uses:

• void std.array.Appender!(char[]).Appender.ensureAddable(ulong)
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt

void std.array.Appender!(char[]).Appender.put!(char[]).put(char[])

Uses:

• void std.array.Appender!(char[]).Appender.ensureAddable(ulong)
• memcpy@plt

ulong std.array.Appender!(char[]).Appender.newCapacity(ulong)

void std.array.Appender!(char[]).Appender.put!(immutable(char)[]).put(immutable(char)[])

Uses:

• void std.array.Appender!(char[]).Appender.ensureAddable(ulong)
• memcpy@plt

void std.array.Appender!(char[]).Appender.ensureAddable(ulong)

Used by:

• char[] std.array.replace!(char, immutable(char)[], immutable(char)[]).replace(char[], immutable(char)[], immutable(char)[])
• void std.array.Appender!(char[]).Appender.put!(dchar).put(dchar)
• void std.array.Appender!(char[]).Appender.put!(char).put(char)
• void std.array.replaceInto!(char, std.array.Appender!(char[]).Appender, immutable(char)[], immutable(char)[]).replaceInto(std.array.Appender!(char[]).Appender, char[], immutable(char)[], immutable(char)[])
• void std.range.put!(std.array.Appender!(char[]).Appender, char).put(ref std.array.Appender!(char[]).Appender, char)
• void std.array.Appender!(char[]).Appender.put!(immutable(char)[]).put(immutable(char)[])
• void std.array.Appender!(char[]).Appender.put!(char[]).put(char[])

Uses:

• gc_extend
• TypeInfo_Aa.__init
• _d_newitemT
• gc_qalloc
• memcpy@plt

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

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

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

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

Used by:

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

Uses:

• _d_arraysetcapacity
• _d_newitemT

nothrow void std.array.Appender!(char[]).Appender.reserve(ulong)

Uses:

• gc_extend
• TypeInfo_Aa.__init
• _d_newitemT
• gc_qalloc
• memcpy@plt

const(pure nothrow @property @safe ulong function()) std.array.Appender!(char[]).Appender.capacity

pure @safe void std.array.Appender!(char[]).Appender.shrinkTo(ulong)

Uses:

• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

pure @safe void std.array.Appender!(char[]).Appender.shrinkTo(ulong).pure nothrow @safe const(char)[] __dgliteral2513()

pure @safe void std.array.Appender!(char[]).Appender.shrinkTo(ulong).pure nothrow @safe const(char)[] __dgliteral2514()

void std.array.Appender!(ubyte[]).Appender.put!(ubyte).put(ubyte)

Uses:

• void std.array.Appender!(ubyte[]).Appender.ensureAddable(ulong)

void std.array.Appender!(ubyte[]).Appender.put!(ubyte[]).put(ubyte[])

Used by:

• std.process.__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ.executeImpl.FAyaxHAyaAyaE3std7process6ConfigmZS3std7process137__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ11executeImplFAyaxHAyaAyaE3std7process6ConfigmZ13ProcessOutput
• std.process.__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAAyaZ.executeImpl.FAAyaxHAyaAyaE3std7process6ConfigmZS3std7process138__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAAyaZ11executeImplFAAyaxHAyaAyaE3std7process6ConfigmZ13ProcessOutput
• std.process.__T11executeImplS108_D3std7process9pipeShellFNfAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ.executeImpl.FAyaxHAyaAyaE3std7process6ConfigmZS3std7process133__T11executeImplS108_D3std7process9pipeShellFNfAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ11executeImplFAyaxHAyaAyaE3std7process6ConfigmZ13ProcessOutput

Uses:

• void std.array.Appender!(ubyte[]).Appender.ensureAddable(ulong)
• memcpy@plt

ulong std.array.Appender!(ubyte[]).Appender.newCapacity(ulong)

void std.array.Appender!(ubyte[]).Appender.ensureAddable(ulong)

Used by:

• void std.array.Appender!(ubyte[]).Appender.put!(ubyte[]).put(ubyte[])
• void std.array.Appender!(ubyte[]).Appender.put!(ubyte).put(ubyte)

Uses:

• gc_extend
• TypeInfo_Ah.__init
• _d_newitemT
• gc_qalloc
• memcpy@plt

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

std.array.Appender!(ubyte[]).Appender.datainout(pure nothrow @property @safe inout(ubyte)[] function())

pure nothrow @safe void std.array.Appender!(ubyte[]).Appender.clear()

pure nothrow ref std.array.Appender!(ubyte[]).Appender std.array.Appender!(ubyte[]).Appender.__ctor(ubyte[])

Used by:

• pure nothrow std.array.Appender!(ubyte[]).Appender std.array.appender!(ubyte[], ubyte).appender(ubyte[])
• std.process.__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ.executeImpl.FAyaxHAyaAyaE3std7process6ConfigmZS3std7process137__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ11executeImplFAyaxHAyaAyaE3std7process6ConfigmZ13ProcessOutput
• std.process.__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAAyaZ.executeImpl.FAAyaxHAyaAyaE3std7process6ConfigmZS3std7process138__T11executeImplS112_D3std7process11pipeProcessFNeAAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAAyaZ11executeImplFAAyaxHAyaAyaE3std7process6ConfigmZ13ProcessOutput
• std.process.__T11executeImplS108_D3std7process9pipeShellFNfAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ.executeImpl.FAyaxHAyaAyaE3std7process6ConfigmZS3std7process133__T11executeImplS108_D3std7process9pipeShellFNfAyaE3std7process8RedirectxHAyaAyaE3std7process6ConfigZS3std7process12ProcessPipesTAyaZ11executeImplFAyaxHAyaAyaE3std7process6ConfigmZ13ProcessOutput

Uses:

• _d_arraysetcapacity
• _d_newitemT

nothrow void std.array.Appender!(ubyte[]).Appender.reserve(ulong)

Uses:

• gc_extend
• TypeInfo_Ah.__init
• _d_newitemT
• gc_qalloc
• memcpy@plt

const(pure nothrow @property @safe ulong function()) std.array.Appender!(ubyte[]).Appender.capacity

pure @safe void std.array.Appender!(ubyte[]).Appender.shrinkTo(ulong)

Uses:

• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

pure @safe void std.array.Appender!(ubyte[]).Appender.shrinkTo(ulong).pure nothrow @safe const(char)[] __dgliteral4404()

pure @safe void std.array.Appender!(ubyte[]).Appender.shrinkTo(ulong).pure nothrow @safe const(char)[] __dgliteral4405()

pure nothrow @trusted void std.array.popFront!(const(char)).popFront(ref const(char)[])

pure nothrow @safe void std.array.popFront!(const(ubyte)).popFront(ref const(ubyte)[])

pure nothrow @safe void std.array.popFront!(const(uint)).popFront(ref const(uint)[])

pure nothrow @trusted void std.array.popFront!(const(wchar)).popFront(ref const(wchar)[])

pure nothrow @safe void std.array.popFront!(const(dchar)).popFront(ref const(dchar)[])

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

Used by:

• timeduration.returndtfromtext.__ctor.MFNcAyaAyaZS12timeduration16returndtfromtext17__foreachbody2750MFKwZi
• std.range.__T5retroTAyaZ.retro.FNaNbNfAyaZS3std5range14__T5retroTAyaZ5retroFAyaZ6Result6Result7popBackMFZv

void std.array.Appender!(const(char)[]).Appender.put!(char).put(char)

Uses:

• void std.array.Appender!(const(char)[]).Appender.ensureAddable(ulong)

void std.array.Appender!(const(char)[]).Appender.put!(dchar).put(dchar)

Uses:

• void std.array.Appender!(const(char)[]).Appender.ensureAddable(ulong)
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• memcpy@plt

void std.array.Appender!(const(char)[]).Appender.put!(char[]).put(char[])

Uses:

• void std.array.Appender!(const(char)[]).Appender.ensureAddable(ulong)
• memcpy@plt

ulong std.array.Appender!(const(char)[]).Appender.newCapacity(ulong)

void std.array.Appender!(const(char)[]).Appender.ensureAddable(ulong)

Used by:

• const(char)[] std.format.FormatSpec!(char).FormatSpec.headUpToNextSpec()
• void std.array.Appender!(const(char)[]).Appender.put!(char[]).put(char[])
• void std.array.Appender!(const(char)[]).Appender.put!(char).put(char)
• void std.array.Appender!(const(char)[]).Appender.put!(dchar).put(dchar)

Uses:

• gc_extend
• TypeInfo_Axa.__init
• _d_newitemT
• gc_qalloc
• memcpy@plt

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

std.array.Appender!(const(char)[]).Appender.datainout(pure nothrow @property @safe const(char)[] function())

pure nothrow ref std.array.Appender!(const(char)[]).Appender std.array.Appender!(const(char)[]).Appender.__ctor(const(char)[])

Used by:

• pure nothrow std.array.Appender!(const(char)[]).Appender std.array.appender!(const(char)[], const(char)).appender(const(char)[])
• const(char)[] std.format.FormatSpec!(char).FormatSpec.headUpToNextSpec()

Uses:

• _d_arraysetcapacity
• _d_newitemT

nothrow void std.array.Appender!(const(char)[]).Appender.reserve(ulong)

Uses:

• gc_extend
• TypeInfo_Axa.__init
• _d_newitemT
• gc_qalloc
• memcpy@plt

const(pure nothrow @property @safe ulong function()) std.array.Appender!(const(char)[]).Appender.capacity

void std.array.Appender!(immutable(char)[]).Appender.put!(char).put(char)

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)

void std.array.Appender!(immutable(char)[]).Appender.put!(dchar).put(dchar)

Uses:

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

void std.array.Appender!(immutable(char)[]).Appender.put!(char[]).put(char[])

Uses:

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

void std.array.Appender!(immutable(char)[]).Appender.put!(const(char)).put(const(char))

Uses:

• void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)

void std.array.Appender!(immutable(char)[]).Appender.put!(const(dchar)).put(const(dchar))

Uses:

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

ulong std.array.Appender!(immutable(char)[]).Appender.newCapacity(ulong)

void std.array.Appender!(immutable(char)[]).Appender.put!(const(char)[]).put(const(char)[])

Uses:

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

void std.array.Appender!(immutable(char)[]).Appender.put!(immutable(char)[]).put(immutable(char)[])

Uses:

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

void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)

Used by:

• immutable(char)[] std.conv.toImpl!(immutable(char)[], dchar).toImpl(dchar)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[]).textImpl(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[])
• 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)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[][], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[][], ref std.format.FormatSpec!(char).FormatSpec)
• void std.array.Appender!(immutable(char)[]).Appender.put!(const(dchar)).put(const(dchar))
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatElement!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], char).formatElement(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatObject!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.DateTime), char).formatObject(ref std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.DateTime), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.array.Appender!(immutable(char)[]).Appender.put!(immutable(char)[]).put(immutable(char)[])
• void std.format.formatChar!(std.array.Appender!(immutable(char)[]).Appender).formatChar(std.array.Appender!(immutable(char)[]).Appender, const(dchar), const(char))
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.DateTime), const(std.datetime.DateTime)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.DateTime), const(std.datetime.DateTime))
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition, ref std.format.FormatSpec!(char).FormatSpec)
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, char).put(ref std.array.Appender!(immutable(char)[]).Appender, char)
• void std.array.Appender!(immutable(char)[]).Appender.put!(const(char)).put(const(char))
• immutable(char)[] std.conv.text!(immutable(char)[], dchar, immutable(char)[]).text(immutable(char)[], dchar, immutable(char)[])
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, bool, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, bool, ref std.format.FormatSpec!(char).FormatSpec)
• 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)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, void*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, void*, ref std.format.FormatSpec!(char).FormatSpec)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], char).textImpl(immutable(char)[], char)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.Interval!(std.datetime.DateTime).Interval), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.Interval!(std.datetime.DateTime).Interval), ref std.format.FormatSpec!(char).FormatSpec)
• bool std.format.FormatSpec!(char).FormatSpec.writeUpToNextSpec!(std.array.Appender!(immutable(char)[]).Appender).writeUpToNextSpec(std.array.Appender!(immutable(char)[]).Appender)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, std.regex.IR, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.Month), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.Month), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, long, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, long, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, Exception, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.array.Appender!(immutable(char)[]).Appender.put!(char[]).put(char[])
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[]).put(ref std.array.Appender!(immutable(char)[]).Appender, immutable(char)[])
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, char, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.DateTime), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.DateTime), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TempTransition[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.TempTransition[], ref std.format.FormatSpec!(char).FormatSpec)
• immutable(char)[] timeduration.getTwoEleOut!(immutable(char)[], immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, char[]).put(ref std.array.Appender!(immutable(char)[]).Appender, char[])
• immutable(char)[] std.conv.textImpl!(immutable(char)[], dchar, dchar).textImpl(dchar, dchar)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval))
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, Exception, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, Exception, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, char, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, char, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, const(ubyte)[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref const(ubyte)[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, std.datetime.DateTime, const(std.datetime.DateTime)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, std.datetime.DateTime, const(std.datetime.DateTime))
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, dchar, uint, uint)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], dchar, immutable(char)[]).textImpl(immutable(char)[], dchar, immutable(char)[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval))
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, immutable(std.datetime.PosixTimeZone.TTInfo)*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, immutable(std.datetime.PosixTimeZone.TTInfo)*, ref std.format.FormatSpec!(char).FormatSpec)
• 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)
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, const(char)[]).put(ref std.array.Appender!(immutable(char)[]).Appender, const(char)[])
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.DateTime, char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval))
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, const(dchar)).put(ref std.array.Appender!(immutable(char)[]).Appender, const(dchar))
• void std.array.Appender!(immutable(char)[]).Appender.put!(const(char)[]).put(const(char)[])
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(short), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, const(short), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.DateTime, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.DateTime, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatObject!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), char).formatObject(ref std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, dchar, uint)
• const(immutable(char)[] function()) std.format.FormatSpec!(char).FormatSpec.getCurFmtStr
• immutable(char)[] std.conv.toStr!(immutable(char)[], char).toStr(char)
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, dchar).put(ref std.array.Appender!(immutable(char)[]).Appender, dchar)
• void std.array.Appender!(immutable(char)[]).Appender.put!(char).put(char)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(ubyte), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, const(ubyte), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.DateTime)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.DateTime))
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.Interval!(std.datetime.DateTime).Interval), char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatObject!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.Interval!(std.datetime.DateTime).Interval), char).formatObject(ref std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.Interval!(std.datetime.DateTime).Interval), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval))
• void std.format.formatObject!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), char).formatObject(ref std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval))
• immutable(char)[] std.conv.toImpl!(immutable(char)[], char).toImpl(char)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ubyte, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ubyte, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval))
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ref const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.LeapSecond[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.PosixTimeZone.LeapSecond[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, const(char)).put(ref std.array.Appender!(immutable(char)[]).Appender, const(char))
• immutable(char)[] std.conv.toStr!(immutable(char)[], dchar).toStr(dchar)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(int), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, const(int), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatElement!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatElement(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatObject!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.DateTime, char).formatObject(ref std.array.Appender!(immutable(char)[]).Appender, ref std.datetime.DateTime, ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TransitionType*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, std.datetime.PosixTimeZone.TransitionType*, ref std.format.FormatSpec!(char).FormatSpec)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(dchar).to(dchar)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(ubyte)[], char).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(ubyte)[], char)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(uint), char).formatValue(std.array.Appender!(immutable(char)[]).Appender, const(uint), ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, ushort, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, ushort, ref std.format.FormatSpec!(char).FormatSpec)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(char).to(char)
• void std.format.formatObject!(std.array.Appender!(immutable(char)[]).Appender, Exception, char).formatObject(ref std.array.Appender!(immutable(char)[]).Appender, ref Exception, ref std.format.FormatSpec!(char).FormatSpec)
• int timeduration.getTwoEleOut!(int, immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• 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)
• void std.format.formatRange!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], char).formatRange(ref std.array.Appender!(immutable(char)[]).Appender, ref immutable(char)[], ref std.format.FormatSpec!(char).FormatSpec)
• void std.format.formatGeneric!(std.array.Appender!(immutable(char)[]).Appender, const(std.datetime.DateTime), char).formatGeneric(std.array.Appender!(immutable(char)[]).Appender, const(void)*, ref std.format.FormatSpec!(char).FormatSpec)
• 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)
• void std.array.Appender!(immutable(char)[]).Appender.put!(dchar).put(dchar)
• immutable(char)[] std.conv.text!(immutable(char)[], char).text(immutable(char)[], char)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval))
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, Exception).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, Exception)

Uses:

• TypeInfo_Aya.__init
• gc_extend
• _d_newitemT
• gc_qalloc
• 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))

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

Used by:

• const(@trusted immutable(char)[] function()) std.internal.uni.Interval.toString

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

Used by:

• immutable(char)[] std.string.format!(char, std.datetime.DateTime, const(std.datetime.DateTime)).format(const(char[]), std.datetime.DateTime, const(std.datetime.DateTime))
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[]).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[])
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], std.datetime.PosixTimeZone.LeapSecond, immutable(char)[], ulong, immutable(char)[], ulong)
• immutable(char)[] std.conv.toStr!(immutable(char)[], ushort).toStr(ushort)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, immutable(char)[], uint).immutable(char)[] gencode!(2uL).gencode()
• modules.commandline_parser.parseoptions modules.commandline_parser.parseoptions.__ctor(immutable(char)[][], modules.sharedtypes.logSettings*)
• immutable(char)[] std.string.format!(char, const(ubyte), const(ubyte), const(ubyte)).format(const(char[]), const(ubyte), const(ubyte), const(ubyte))
• immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition).toImpl(std.datetime.PosixTimeZone.TempTransition)
• @trusted immutable(char)[] std.regex.ctSub!(int, int, immutable(char)[], int).ctSub(immutable(char)[], int, int, immutable(char)[], int)
• @trusted immutable(char)[] std.regex.ctSub!(int, int, int, immutable(char)[], int).ctSub(immutable(char)[], int, int, int, immutable(char)[], int)
• immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond).toImpl(std.datetime.PosixTimeZone.LeapSecond)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(int).to(int)
• immutable(char)[] std.string.format!(char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).format(const(char[]), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval))
• immutable(char)[] std.string.format!(char, const(short), const(std.datetime.Month), const(ubyte)).format(const(char[]), const(short), const(std.datetime.Month), const(ubyte))
• immutable(char)[] std.conv.toStr!(immutable(char)[], int).toStr(int)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, Exception).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, Exception).immutable(char)[] gencode!(1uL).gencode()
• immutable(char)[] std.string.format!(char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).format(const(char[]), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval))
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(uint)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(uint)).immutable(char)[] gencode!(1uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).immutable(char)[] gencode!(2uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, int).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, int).immutable(char)[] gencode!(1uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, ulong).immutable(char)[] gencode!(1uL).gencode()
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], std.datetime.PosixTimeZone.TempTransition, immutable(char)[], ulong, immutable(char)[], ulong)
• @trusted immutable(char)[] std.regex.ctSub!(int, immutable(char)[], immutable(char)[], int, int, immutable(char)[]).ctSub(immutable(char)[], int, immutable(char)[], immutable(char)[], int, int, immutable(char)[])
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(bool).to(bool)
• immutable(char)[] std.string.format!(char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).format(const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval))
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.LeapSecond).to(std.datetime.PosixTimeZone.LeapSecond)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(immutable(char)[][]).to(immutable(char)[][])
• @trusted immutable(char)[] std.regex.ctSub!(int, int, int, immutable(char)[], immutable(char)[], int, int, immutable(char)[]).ctSub(immutable(char)[], int, int, int, immutable(char)[], immutable(char)[], int, int, immutable(char)[])
• void std.format.formatNth!(void delegate(const(char)[]), char, const(real)).formatNth(void delegate(const(char)[]), ref std.format.FormatSpec!(char).FormatSpec, ulong, const(real)).immutable(char)[] gencode!(1uL).gencode()
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.TempTransition[]).to(std.datetime.PosixTimeZone.TempTransition[])
• immutable(char)[] std.conv.text!(immutable(char)[], dchar, immutable(char)[]).text(immutable(char)[], dchar, immutable(char)[])
• immutable(char)[] std.string.format!(char, Exception).format(const(char[]), Exception)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(uint), const(uint)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(uint), const(uint)).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[][], immutable(char)[])
• @trusted immutable(char)[] std.regex.ctSub!(uint, immutable(char)[]).ctSub(immutable(char)[], uint, immutable(char)[])
• immutable(char)[] std.string.format!(char, const(std.datetime.DateTime), const(std.datetime.DateTime)).format(const(char[]), const(std.datetime.DateTime), const(std.datetime.DateTime))
• immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[])
• @trusted immutable(char)[] std.regex.ctSub!(int, int, immutable(char)[], immutable(char)[], int, int, immutable(char)[]).ctSub(immutable(char)[], int, int, immutable(char)[], immutable(char)[], int, int, immutable(char)[])
• immutable(char)[] std.conv.toStr!(immutable(char)[], immutable(char)[][]).toStr(immutable(char)[][])
• @trusted immutable(char)[] std.regex.ctSub!(uint, uint).ctSub(immutable(char)[], uint, uint)
• @trusted immutable(char)[] std.regex.ctSub!(uint).ctSub(immutable(char)[], uint)
• @trusted immutable(char)[] std.regex.ctSub!(int, int, int, immutable(char)[], immutable(char)[], int, int, int, immutable(char)[], int).ctSub(immutable(char)[], int, int, int, immutable(char)[], immutable(char)[], int, int, int, immutable(char)[], int)
• immutable(char)[] std.string.format!(char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).format(const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval))
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, long, long).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, long, long).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.string.format!(char, uint).format(const(char[]), uint)
• @trusted immutable(char)[] std.regex.ctSub!(uint, immutable(char)[], uint, int).ctSub(immutable(char)[], uint, immutable(char)[], uint, int)
• @trusted immutable(char)[] std.regex.ctSub!(int, immutable(char)[], int).ctSub(immutable(char)[], int, immutable(char)[], int)
• immutable(char)[] std.string.format!(char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).format(const(char[]), const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval))
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, std.datetime.DateTime, const(std.datetime.DateTime)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, std.datetime.DateTime, const(std.datetime.DateTime)).immutable(char)[] gencode!(2uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(ubyte)[], char).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(ubyte)[], char).immutable(char)[] gencode!(2uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(ubyte).to(ubyte)
• immutable(char)[] std.string.format!(char, ulong).format(const(char[]), ulong)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, uint, uint, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, uint, uint, uint).immutable(char)[] gencode!(3uL).gencode()
• immutable(char)[] std.conv.toImpl!(immutable(char)[], std.regex.IR).toImpl(std.regex.IR)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.conv.toImpl!(immutable(char)[], immutable(char)[][]).toImpl(immutable(char)[][])
• immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition[]).toImpl(std.datetime.PosixTimeZone.TempTransition[])
• immutable(char)[] std.string.format!(char, long, long).format(const(char[]), long, long)
• immutable(char)[] std.string.format!(char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).format(const(char[]), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval))
• immutable(char)[] std.conv.toImpl!(immutable(char)[], bool).toImpl(bool)
• immutable(char)[] std.string.format!(char, immutable(char)[], immutable(char)[]).format(const(char[]), immutable(char)[], immutable(char)[])
• immutable(char)[] std.conv.toStr!(immutable(char)[], uint).toStr(uint)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(char).to(char)
• immutable(char)[] std.conv.toStr!(immutable(char)[], void*).toStr(void*)
• immutable(char)[] std.string.format!(char, ulong, immutable(char)[], ulong).format(const(char[]), ulong, immutable(char)[], ulong)
• pure nothrow std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender(immutable(char)[])
• immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(ubyte), const(ubyte), const(ubyte)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(ubyte), const(ubyte), const(ubyte)).immutable(char)[] gencode!(3uL).gencode()
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(uint).to(uint)
• immutable(char)[] std.string.format!(char, void*, ulong, immutable(char)[]).format(const(char[]), void*, ulong, immutable(char)[])
• immutable(char)[] std.string.format!(char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).format(const(char[]), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval))
• immutable(char)[] std.conv.toImpl!(immutable(char)[], dchar).toImpl(dchar)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], dchar, immutable(char)[]).textImpl(immutable(char)[], dchar, immutable(char)[])
• @trusted immutable(char)[] std.regex.ctSub!(int, immutable(char)[], immutable(char)[], int).ctSub(immutable(char)[], int, immutable(char)[], immutable(char)[], int)
• immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition[]).toStr(std.datetime.PosixTimeZone.TempTransition[])
• @trusted immutable(char)[] std.regex.ctSub!(uint, immutable(char)[], immutable(char)[], immutable(char)[]).ctSub(immutable(char)[], uint, immutable(char)[], immutable(char)[], immutable(char)[])
• @trusted immutable(char)[] std.regex.ctSub!(uint, int, int, immutable(char)[], int).ctSub(immutable(char)[], uint, int, int, immutable(char)[], int)
• immutable(char)[] std.conv.text!(immutable(char)[], char).text(immutable(char)[], char)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.regex.IR).to(std.regex.IR)
• immutable(char)[] std.conv.toStr!(immutable(char)[], dchar).toStr(dchar)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.Interval!(std.datetime.DateTime).Interval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).immutable(char)[] gencode!(2uL).gencode()
• void std.format.formatElement!(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], char).formatElement(std.array.Appender!(immutable(char)[]).Appender, immutable(char)[], ref std.format.FormatSpec!(char).FormatSpec)
• const(immutable(char)[] function()) std.format.FormatSpec!(char).FormatSpec.getCurFmtStr
• @trusted immutable(char)[] std.regex.ctSub!(int).ctSub(immutable(char)[], int)
• @trusted immutable(char)[] std.regex.ctSub!(uint, int, uint, int).ctSub(immutable(char)[], uint, int, uint, int)
• immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint)
• immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, uint).immutable(char)[] gencode!(1uL).gencode()
• immutable(char)[] std.conv.toImpl!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[]).toImpl(std.datetime.PosixTimeZone.LeapSecond[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.DateTime), const(std.datetime.DateTime)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.DateTime), const(std.datetime.DateTime)).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.TempTransition).toStr(std.datetime.PosixTimeZone.TempTransition)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.TempTransition).to(std.datetime.PosixTimeZone.TempTransition)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(short), immutable(char)[], const(ubyte)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(short), immutable(char)[], const(ubyte)).immutable(char)[] gencode!(3uL).gencode()
• @trusted immutable(char)[] std.regex.ctSub!(uint, int).ctSub(immutable(char)[], uint, int)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, uint, const(uint), const(uint), const(uint)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, uint, const(uint), const(uint), const(uint)).immutable(char)[] gencode!(4uL).gencode()
• immutable(char)[] std.conv.toStr!(immutable(char)[], char).toStr(char)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(std.datetime.PosixTimeZone.LeapSecond[]).to(std.datetime.PosixTimeZone.LeapSecond[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.Interval!(std.datetime.DateTime).Interval)).immutable(char)[] gencode!(2uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, dchar, uint, uint).immutable(char)[] gencode!(3uL).gencode()
• @trusted immutable(char)[] std.regex.ctSub!(int, int, immutable(char)[]).ctSub(immutable(char)[], int, int, immutable(char)[])
• @trusted immutable(char)[] std.regex.ctSub!(int, int).ctSub(immutable(char)[], int, int)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(void*).to(void*)
• immutable(char)[] std.string.format!(char, int).format(const(char[]), int)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[]).textImpl(immutable(char)[], void*, immutable(char)[], int, immutable(char)[], int, immutable(char)[], char, immutable(char)[], ubyte, immutable(char)[], ubyte, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], bool, immutable(char)[], const(char)[], immutable(char)[], const(char)[], immutable(char)[])
• @trusted immutable(char)[] std.regex.ctSub!(int, immutable(char)[]).ctSub(immutable(char)[], int, immutable(char)[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval), const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval)).immutable(char)[] gencode!(2uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], immutable(char)[], immutable(char)[]).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, immutable(char)[], immutable(char)[], immutable(char)[]).immutable(char)[] gencode!(3uL).gencode()
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.NegInfInterval!(std.datetime.DateTime).NegInfInterval), const(std.datetime.PosInfInterval!(std.datetime.DateTime).PosInfInterval)).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong)
• int timeduration.getTwoEleOut!(int, immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(ushort).to(ushort)
• immutable(char)[] std.string.format!(char, const(short), immutable(char)[], const(ubyte)).format(const(char[]), const(short), immutable(char)[], const(ubyte))
• immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort)
• immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond).toStr(std.datetime.PosixTimeZone.LeapSecond)
• immutable(char)[] std.conv.toStr!(immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[]).toStr(std.datetime.PosixTimeZone.LeapSecond[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, ulong, immutable(char)[], ulong).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, ulong, immutable(char)[], ulong).immutable(char)[] gencode!(3uL).gencode()
• immutable(char)[] std.conv.toStr!(immutable(char)[], ulong).toStr(ulong)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], dchar, dchar).textImpl(dchar, dchar)
• @trusted immutable(char)[] std.regex.ctSub!(int, immutable(char)[], immutable(char)[], int, int, int, immutable(char)[], int).ctSub(immutable(char)[], int, immutable(char)[], immutable(char)[], int, int, int, immutable(char)[], int)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, void*, ulong, immutable(char)[]).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, void*, ulong, immutable(char)[]).immutable(char)[] gencode!(3uL).gencode()
• immutable(char)[] std.string.format!(char, immutable(char)[]).format(const(char[]), immutable(char)[])
• immutable(char)[] std.conv.toStr!(immutable(char)[], std.regex.IR).toStr(std.regex.IR)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, dchar, uint).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, dchar, uint).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], ulong, immutable(char)[], ulong)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], immutable(char)[]).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, immutable(char)[], immutable(char)[]).immutable(char)[] gencode!(2uL).gencode()
• immutable(char)[] std.conv.toStr!(immutable(char)[], bool).toStr(bool)
• immutable(char)[] std.conv.toImpl!(immutable(char)[], char).toImpl(char)
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong).to(ulong)
• immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte)
• immutable(char)[] std.conv.to!(immutable(char)[]).to!(dchar).to(dchar)
• @trusted immutable(char)[] std.regex.ctSub!(uint, immutable(char)[], immutable(char)[]).ctSub(immutable(char)[], uint, immutable(char)[], immutable(char)[])
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[]).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.TempTransition[], immutable(char)[])
• immutable(char)[] std.conv.toImpl!(immutable(char)[], void*).toImpl(void*)
• immutable(char)[] std.string.format!(char, immutable(char)[], immutable(char)[], immutable(char)[]).format(const(char[]), immutable(char)[], immutable(char)[], immutable(char)[])
• @trusted immutable(char)[] std.regex.ctSub!(int, uint, int).ctSub(immutable(char)[], int, uint, int)
• immutable(char)[] std.conv.toStr!(immutable(char)[], ubyte).toStr(ubyte)
• @trusted immutable(char)[] std.regex.ctSub!(int, int, immutable(char)[], immutable(char)[], int, int, int, immutable(char)[], int).ctSub(immutable(char)[], int, int, immutable(char)[], immutable(char)[], int, int, int, immutable(char)[], int)
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[]).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, immutable(char)[]).immutable(char)[] gencode!(1uL).gencode()
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], char).textImpl(immutable(char)[], char)
• _Dmain
• immutable(char)[] timeduration.getTwoEleOut!(immutable(char)[], immutable(char)[]).getTwoEleOut(ref immutable(char)[])
• immutable(char)[] std.conv.text!(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).text(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(std.datetime.DateTime)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(std.datetime.DateTime)).immutable(char)[] gencode!(1uL).gencode()
• immutable(char)[] std.string.format!(char, const(std.datetime.DateTime)).format(const(char[]), const(std.datetime.DateTime))
• immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[]).textImpl(immutable(char)[], immutable(char)[], immutable(char)[], std.datetime.PosixTimeZone.LeapSecond[], immutable(char)[])
• void std.format.formatNth!(std.array.Appender!(immutable(char)[]).Appender, char, const(short), const(std.datetime.Month), const(ubyte)).formatNth(std.array.Appender!(immutable(char)[]).Appender, ref std.format.FormatSpec!(char).FormatSpec, ulong, const(short), const(std.datetime.Month), const(ubyte)).immutable(char)[] gencode!(3uL).gencode()

Uses:

• _d_arraysetcapacity
• _d_newitemT

nothrow void std.array.Appender!(immutable(char)[]).Appender.reserve(ulong)

Uses:

• TypeInfo_Aya.__init
• gc_extend
• _d_newitemT
• gc_qalloc
• memcpy@plt

const(pure nothrow @property @safe ulong function()) std.array.Appender!(immutable(char)[]).Appender.capacity

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

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

immutable(char)[][] std.array.split!(immutable(char)[], immutable(char)[]).split(immutable(char)[], immutable(char)[])

Used by:

• bool std.getopt.optMatch(immutable(char)[], immutable(char)[], ref immutable(char)[], std.getopt.configuration)

Uses:

• pure nothrow ref std.array.Appender!(immutable(char)[][]).Appender std.array.Appender!(immutable(char)[][]).Appender.__ctor(immutable(char)[][])
• std.algorithm.__T8splitterTAyaTAyaZ.splitter.FAyaAyaZS3std9algorithm21__T8splitterTAyaTAyaZ8splitterFAyaAyaZ6Result
• std.algorithm.__T8splitterTAyaTAyaZ.splitter.FAyaAyaZS3std9algorithm21__T8splitterTAyaTAyaZ8splitterFAyaAyaZ6Result6Result17ensureFrontLengthMFZv
• void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)
• std.algorithm.__T8splitterTAyaTAyaZ.splitter.FAyaAyaZS3std9algorithm21__T8splitterTAyaTAyaZ8splitterFAyaAyaZ6Result6Result8popFrontMFZv

ulong std.array.Appender!(immutable(char)[][]).Appender.newCapacity(ulong)

void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

• void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)

void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)

Used by:

• immutable(char)[][] std.array.split!(immutable(char)[], immutable(char)[]).split(immutable(char)[], immutable(char)[])
• void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])

Uses:

• TypeInfo_AAya.__init
• gc_extend
• _d_newitemT
• gc_qalloc
• 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

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

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

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

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

Used by:

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

Uses:

• _d_arraysetcapacity
• _d_newitemT

nothrow void std.array.Appender!(immutable(char)[][]).Appender.reserve(ulong)

Uses:

• TypeInfo_AAya.__init
• gc_extend
• _d_newitemT
• gc_qalloc
• memcpy@plt

const(pure nothrow @property @safe ulong function()) std.array.Appender!(immutable(char)[][]).Appender.capacity

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

Uses:

• pure @safe void std.exception.bailOut(immutable(char)[], ulong, const(char[]))

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

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

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

Uses:

• pure nothrow ref std.array.Appender!(char[]).Appender std.array.Appender!(char[]).Appender.__ctor(char[])

pure nothrow std.array.Appender!(ubyte[]).Appender std.array.appender!(ubyte[], ubyte).appender(ubyte[])

Uses:

• pure nothrow ref std.array.Appender!(ubyte[]).Appender std.array.Appender!(ubyte[]).Appender.__ctor(ubyte[])

pure nothrow std.array.Appender!(const(char)[]).Appender std.array.appender!(const(char)[], const(char)).appender(const(char)[])

Uses:

• pure nothrow ref std.array.Appender!(const(char)[]).Appender std.array.Appender!(const(char)[]).Appender.__ctor(const(char)[])

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

Used by:

• const(@trusted immutable(char)[] function()) std.internal.uni.Interval.toString

Uses:

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

nothrow void std.array.copyBackwards!(uint).copyBackwards(uint[], uint[])

Uses:

• memmove@plt

char[] std.array.replace!(char, immutable(char)[], immutable(char)[]).replace(char[], immutable(char)[], immutable(char)[])

Used by:

• modules.commandline_parser.parseoptions modules.commandline_parser.parseoptions.__ctor(immutable(char)[][], modules.sharedtypes.logSettings*)

Uses:

• pure nothrow @safe ubyte[] std.algorithm.find!("a == b", ubyte[], ubyte[]).find(ubyte[], ubyte[])
• void std.array.replaceInto!(char, std.array.Appender!(char[]).Appender, immutable(char)[], immutable(char)[]).replaceInto(std.array.Appender!(char[]).Appender, char[], immutable(char)[], immutable(char)[])
• pure nothrow ref std.array.Appender!(char[]).Appender std.array.Appender!(char[]).Appender.__ctor(char[])
• void std.array.Appender!(char[]).Appender.ensureAddable(ulong)
• memcpy@plt

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

Used by:

• immutable(char)[][] std.datetime.PosixTimeZone.getInstalledTZNames(immutable(char)[], immutable(char)[])

Uses:

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

nothrow void std.array.insertInPlace!(uint, uint[]).insertInPlace(ref uint[], ulong, uint[])

Uses:

• memmove@plt
• _d_arraysetlengthT

pure nothrow float[] std.array.arrayAllocImpl!(false, float[], ulong).arrayAllocImpl(ulong)

Uses:

• gc_malloc

pure nothrow ubyte[] std.array.arrayAllocImpl!(false, ubyte[], immutable(ulong)).arrayAllocImpl(immutable(ulong))

Uses:

• gc_malloc

pure nothrow float[] std.array.uninitializedArray!(float[], ulong).uninitializedArray(ulong)

Used by:

• std.numeric.Fft std.numeric.Fft.__ctor(ulong)

Uses:

• gc_malloc

pure nothrow ubyte[] std.array.uninitializedArray!(ubyte[], immutable(ulong)).uninitializedArray(immutable(ulong))

Uses:

• gc_malloc

pure nothrow @property @safe std.regex.Bytecode[] std.array.save!(std.regex.Bytecode).save(std.regex.Bytecode[])

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

Used by:

• bool std.file.DirIteratorImpl.hasExtra()
• @property bool std.file.DirIteratorImpl.empty()

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

pure nothrow ref @property @safe std.regex.Bytecode std.array.front!(std.regex.Bytecode).front(std.regex.Bytecode[])

ulong std.array.Appender!(std.file.DirEntry[]).Appender.newCapacity(ulong)

Used by:

• void std.array.Appender!(std.file.DirEntry[]).Appender.ensureAddable(ulong)

void std.array.Appender!(std.file.DirEntry[]).Appender.ensureAddable(ulong)

Used by:

• void std.array.Appender!(std.file.DirEntry[]).Appender.put!(std.file.DirEntry).put(std.file.DirEntry)

Uses:

• ulong std.array.Appender!(std.file.DirEntry[]).Appender.newCapacity(ulong)
• pure nothrow core.memory.BlkInfo_ core.memory.GC.qalloc(ulong, uint)
• TypeInfo_AS3std4file8DirEntry.__init
• _d_newitemT
• pure nothrow ulong core.memory.GC.extend(void*, ulong, ulong)
• memcpy@plt

void std.array.Appender!(std.file.DirEntry[]).Appender.put!(std.file.DirEntry).put(std.file.DirEntry)

Used by:

• void std.file.DirIteratorImpl.pushExtra(std.file.DirEntry)

Uses:

• void std.array.Appender!(std.file.DirEntry[]).Appender.ensureAddable(ulong)

bool std.array.Appender!(std.file.DirEntry[]).Appender.Data.__xopEquals(ref const(std.array.Appender!(std.file.DirEntry[]).Appender.Data), ref const(std.array.Appender!(std.file.DirEntry[]).Appender.Data))

Uses:

• _adEq2

std.array.Appender!(std.file.DirEntry[]).Appender.datainout(pure nothrow @property @safe inout(std.file.DirEntry)[] function())

Used by:

• std.file.DirEntry std.file.DirIteratorImpl.popExtra()
• bool std.file.DirIteratorImpl.hasExtra()
• @property bool std.file.DirIteratorImpl.empty()

pure nothrow @safe void std.array.Appender!(std.file.DirEntry[]).Appender.clear()

pure nothrow ref std.array.Appender!(std.file.DirEntry[]).Appender std.array.Appender!(std.file.DirEntry[]).Appender.__ctor(std.file.DirEntry[])

Used by:

• pure nothrow std.array.Appender!(std.file.DirEntry[]).Appender std.array.appender!(std.file.DirEntry[], std.file.DirEntry).appender(std.file.DirEntry[])

Uses:

• _d_newitemT
• pure nothrow @property ulong object.capacity!(std.file.DirEntry).capacity(std.file.DirEntry[])

nothrow void std.array.Appender!(std.file.DirEntry[]).Appender.reserve(ulong)

Uses:

• pure nothrow core.memory.BlkInfo_ core.memory.GC.qalloc(ulong, uint)
• TypeInfo_AS3std4file8DirEntry.__init
• _d_newitemT
• pure nothrow ulong core.memory.GC.extend(void*, ulong, ulong)
• memcpy@plt

const(pure nothrow @property @safe ulong function()) std.array.Appender!(std.file.DirEntry[]).Appender.capacity

pure @safe void std.array.Appender!(std.file.DirEntry[]).Appender.shrinkTo(ulong)

Used by:

• std.file.DirEntry std.file.DirIteratorImpl.popExtra()

Uses:

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

pure @safe void std.array.Appender!(std.file.DirEntry[]).Appender.shrinkTo(ulong).pure nothrow @safe const(char)[] __dgliteral3784()

pure @safe void std.array.Appender!(std.file.DirEntry[]).Appender.shrinkTo(ulong).pure nothrow @safe const(char)[] __dgliteral3785()

pure nothrow @safe void std.array.popFront!(std.regex.Bytecode).popFront(ref std.regex.Bytecode[])

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

Used by:

• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.sub(const(std.internal.uni.CodepointSet))
• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.intersect(const(std.internal.uni.CodepointSet))

pure nothrow ref @property @safe std.internal.uni.Interval std.array.front!(std.internal.uni.Interval).front(std.internal.uni.Interval[])

Used by:

• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.sub(const(std.internal.uni.CodepointSet))

pure nothrow ref @property @safe const(std.internal.uni.Interval) std.array.front!(const(std.internal.uni.Interval)).front(const(std.internal.uni.Interval)[])

Used by:

• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.sub(const(std.internal.uni.CodepointSet))
• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.intersect(const(std.internal.uni.CodepointSet))

pure nothrow @safe void std.array.popFront!(std.internal.uni.Interval).popFront(ref std.internal.uni.Interval[])

Used by:

• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.sub(const(std.internal.uni.CodepointSet))

pure nothrow @safe void std.array.popFront!(const(std.internal.uni.Interval)).popFront(ref const(std.internal.uni.Interval)[])

Used by:

• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.sub(const(std.internal.uni.CodepointSet))
• ref @trusted std.internal.uni.CodepointSet std.internal.uni.CodepointSet.intersect(const(std.internal.uni.CodepointSet))

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

Used by:

• bool std.file.DirIteratorImpl.next()
• @property bool std.file.DirIteratorImpl.empty()

pure nothrow ref @property @safe immutable(std.internal.uni_tab.CommonCaseEntry) std.array.back!(immutable(std.internal.uni_tab.CommonCaseEntry)).back(immutable(std.internal.uni_tab.CommonCaseEntry)[])

pure nothrow ref @property @safe immutable(std.internal.uni_tab.UnicodeProperty) std.array.back!(immutable(std.internal.uni_tab.UnicodeProperty)).back(immutable(std.internal.uni_tab.UnicodeProperty)[])

pure nothrow @property @safe immutable(std.internal.uni_tab.CommonCaseEntry)[] std.array.save!(immutable(std.internal.uni_tab.CommonCaseEntry)).save(immutable(std.internal.uni_tab.CommonCaseEntry)[])

pure nothrow @property @safe immutable(std.internal.uni_tab.UnicodeProperty)[] std.array.save!(immutable(std.internal.uni_tab.UnicodeProperty)).save(immutable(std.internal.uni_tab.UnicodeProperty)[])

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

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

pure nothrow ref @property @safe std.datetime.PosixTimeZone.LeapSecond std.array.back!(std.datetime.PosixTimeZone.LeapSecond).back(std.datetime.PosixTimeZone.LeapSecond[])

pure nothrow ref @property @safe std.datetime.PosixTimeZone.Transition std.array.back!(std.datetime.PosixTimeZone.Transition).back(std.datetime.PosixTimeZone.Transition[])

Used by:

• std.range.__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ.retro.FNaNbNfAS3std8datetime13PosixTimeZone10TransitionZS3std5range53__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ5retroFAS3std8datetime13PosixTimeZone10TransitionZ6Result6Result5frontMFNcNdZS3std8datetime13PosixTimeZone10Transition
• std.range.__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ.retro.FNaNbNfAS3std8datetime13PosixTimeZone10TransitionZS3std5range53__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ5retroFAS3std8datetime13PosixTimeZone10TransitionZ6Result6Result5frontMFNdS3std8datetime13PosixTimeZone10TransitionZv

pure nothrow @property @safe std.datetime.PosixTimeZone.LeapSecond[] std.array.save!(std.datetime.PosixTimeZone.LeapSecond).save(std.datetime.PosixTimeZone.LeapSecond[])

pure nothrow @property @safe std.datetime.PosixTimeZone.Transition[] std.array.save!(std.datetime.PosixTimeZone.Transition).save(std.datetime.PosixTimeZone.Transition[])

Used by:

• std.range.__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ.retro.FNaNbNfAS3std8datetime13PosixTimeZone10TransitionZS3std5range53__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ5retroFAS3std8datetime13PosixTimeZone10TransitionZ6Result6Result4saveMFNdZS3std5range53__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ5retroFAS3std8datetime13PosixTimeZone10TransitionZ6Result

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

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

pure nothrow ref @property @safe immutable(std.datetime.PosixTimeZone.LeapSecond) std.array.back!(immutable(std.datetime.PosixTimeZone.LeapSecond)).back(immutable(std.datetime.PosixTimeZone.LeapSecond)[])

Used by:

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

pure nothrow ref @property @safe immutable(std.datetime.PosixTimeZone.Transition) std.array.back!(immutable(std.datetime.PosixTimeZone.Transition)).back(immutable(std.datetime.PosixTimeZone.Transition)[])

Used by:

• 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.PosixTimeZone.tzToUTC

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

Used by:

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

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

Used by:

• std.range.__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ.retro.FNaNbNfAS3std8datetime13PosixTimeZone10TransitionZS3std5range53__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ5retroFAS3std8datetime13PosixTimeZone10TransitionZ6Result6Result5emptyMFNdZb
• immutable(immutable(std.datetime.PosixTimeZone) function(immutable(std.datetime.PosixTimeZone.Transition[]), immutable(std.datetime.PosixTimeZone.LeapSecond[]), immutable(char)[], immutable(char)[], immutable(char)[], bool)) std.datetime.PosixTimeZone.__ctor

pure nothrow ref @property @safe std.datetime.PosixTimeZone.LeapSecond std.array.front!(std.datetime.PosixTimeZone.LeapSecond).front(std.datetime.PosixTimeZone.LeapSecond[])

pure nothrow ref @property @safe std.datetime.PosixTimeZone.Transition std.array.front!(std.datetime.PosixTimeZone.Transition).front(std.datetime.PosixTimeZone.Transition[])

Used by:

• std.range.__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ.retro.FNaNbNfAS3std8datetime13PosixTimeZone10TransitionZS3std5range53__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ5retroFAS3std8datetime13PosixTimeZone10TransitionZ6Result6Result4backMFNdS3std8datetime13PosixTimeZone10TransitionZv
• std.range.__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ.retro.FNaNbNfAS3std8datetime13PosixTimeZone10TransitionZS3std5range53__T5retroTAS3std8datetime13PosixTimeZone10TransitionZ5retroFAS3std8datetime13PosixTimeZone10TransitionZ6Result6Result4backMFNcNdZS3std8datetime13PosixTimeZone10Transition

ulong std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.newCapacity(ulong)

Used by:

• void std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.ensureAddable(ulong)

void std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.ensureAddable(ulong)

Used by:

• void std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.put!(std.file.DirIteratorImpl.DirHandle).put(std.file.DirIteratorImpl.DirHandle)

Uses:

• TypeInfo_AS3std4file15DirIteratorImpl9DirHandle.__init
• pure nothrow core.memory.BlkInfo_ core.memory.GC.qalloc(ulong, uint)
• _d_newitemT
• ulong std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.newCapacity(ulong)
• pure nothrow ulong core.memory.GC.extend(void*, ulong, ulong)
• memcpy@plt

void std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.put!(std.file.DirIteratorImpl.DirHandle).put(std.file.DirIteratorImpl.DirHandle)

Used by:

• bool std.file.DirIteratorImpl.stepIn(immutable(char)[])

Uses:

• void std.array.Appender!(std.file.DirIteratorImpl.DirHandle[]).Appender.ensureAddable(ulong)