GraphViz .dot file

Jump to D main()

BIO_get_app_data

Uses:

• BIO_get_ex_data@plt

BIO_get_ex_data@plt

Used by:

• BIO_get_app_data

BIO_new_mem_buf@plt

Used by:

• ubyte[] utils.crypto.RSAUtils.RSAUtils.DofusDecrypt(ubyte[])
• ubyte[] utils.crypto.RSAUtils.RSAUtils.LoginEncrypt(ubyte[])

BIO_new_mem_buf@plt-0x10

BIO_set_app_data

Uses:

• BIO_set_ex_data@plt

BIO_set_ex_data@plt

Used by:

• BIO_set_app_data

PEM_read_bio_RSA_PUBKEY@plt

Used by:

• ubyte[] utils.crypto.RSAUtils.RSAUtils.DofusDecrypt(ubyte[])
• ubyte[] utils.crypto.RSAUtils.RSAUtils.LoginEncrypt(ubyte[])

RSA_public_decrypt@plt

Used by:

• ubyte[] utils.crypto.RSAUtils.RSAUtils.DofusDecrypt(ubyte[])

RSA_public_encrypt@plt

Used by:

• ubyte[] utils.crypto.RSAUtils.RSAUtils.LoginEncrypt(ubyte[])

SSL_CTX_callback_ctrl@plt

Used by:

• SSL_CTX_set_tlsext_servername_callback
• SSL_CTX_set_tlsext_opaque_prf_input_callback
• SSL_CTX_set_tlsext_status_cb

SSL_CTX_ctrl@plt

Used by:

• SSL_CTX_set_tlsext_opaque_prf_input_callback_arg
• SSL_CTX_set_tlsext_servername_arg
• SSL_CTX_get_tlsext_ticket_keys
• SSL_CTX_set_tlsext_ticket_keys
• SSL_CTX_set_tlsext_status_arg

SSL_CTX_get_tlsext_ticket_keys

Uses:

• SSL_CTX_ctrl@plt

SSL_CTX_set_tlsext_opaque_prf_input_callback

Uses:

• SSL_CTX_callback_ctrl@plt

SSL_CTX_set_tlsext_opaque_prf_input_callback_arg

Uses:

• SSL_CTX_ctrl@plt

SSL_CTX_set_tlsext_servername_arg

Uses:

• SSL_CTX_ctrl@plt

SSL_CTX_set_tlsext_servername_callback

Uses:

• SSL_CTX_callback_ctrl@plt

SSL_CTX_set_tlsext_status_arg

Uses:

• SSL_CTX_ctrl@plt

SSL_CTX_set_tlsext_status_cb

Uses:

• SSL_CTX_callback_ctrl@plt

SSL_CTX_set_tlsext_ticket_keys

Uses:

• SSL_CTX_ctrl@plt

SSL_ctrl@plt

Used by:

• SSL_set_tlsext_opaque_prf_input

SSL_set_tlsext_opaque_prf_input

Uses:

• SSL_ctrl@plt

_Ccmp

Used by:

• const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_cdouble.TypeInfo_r.equals
• const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_cfloat.TypeInfo_q.equals
• pure nothrow @trusted bool rt.typeinfo.ti_creal.TypeInfo_c._equals(creal, creal)
• pure nothrow @trusted bool rt.typeinfo.ti_cdouble.TypeInfo_r._equals(cdouble, cdouble)
• pure nothrow @trusted bool rt.typeinfo.ti_cfloat.TypeInfo_q._equals(cfloat, cfloat)
• const(pure nothrow @trusted bool function(const(void*), const(void*))) rt.typeinfo.ti_creal.TypeInfo_c.equals

TypeInfo_Axa.__init

Used by:

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

TypeInfo_Aya.__init

Used by:

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

TypeInfo_AAya.__init

Used by:

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

TypeInfo_AS3std4file8DirEntry.__init

Used by:

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

void gc.gc.__unittest_fail(int)

Uses:

• _d_unittestm

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

Used by:

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

Uses:

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

void gc.gc.GC.initialize()

Uses:

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

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

Uses:

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

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

ulong gc.gc.GC.fullCollect()

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

ulong gc.gc.GC.reserveNoSync(ulong)

Uses:

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

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

Used by:

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

Uses:

• memset@plt

void gc.gc.GC.fullCollectNoStack()

Uses:

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

void gc.gc.GC.Dtor()

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

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

void gc.gc.GC.enable()

Uses:

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

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

Uses:

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

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

Used by:

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

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

Uses:

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

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

Uses:

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

gc.gc.GC.__Class

Used by:

• gc_init

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

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

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

void gc.gc.GC.disable()

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

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

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

Uses:

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

ulong gc.gc.GC.reserve(ulong)

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

• gc.gc.Pool* gc.gc.Gcx.findPool(void*)
• onOutOfMemoryError
• calloc@plt

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

Uses:

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

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

Uses:

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

void gc.gc.GC.minimize()

Uses:

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

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

Uses:

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

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

Uses:

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

void gc.gc.Gcx.initialize()

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

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

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

Used by:

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

Uses:

• memmove@plt

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

Uses:

• const(void function()) gc.gc.Gcx.__invariant13

ubyte gc.gc.Gcx.findBinImpl(ulong)

ulong gc.gc.Gcx.fullcollect()

Used by:

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

Uses:

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

void gc.gc.Gcx.log_collect()

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

Used by:

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

Uses:

• memmove@plt

void gc.gc.Gcx.updateCaches(void*, ulong)

const(void function()) gc.gc.Gcx.__invariant13

Used by:

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

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

void gc.gc.Gcx.Dtor()

Used by:

• void gc.gc.GC.Dtor()

Uses:

• free@plt
• munmap@plt

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

Uses:

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

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

Used by:

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

Uses:

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

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

Uses:

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

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

ubyte gc.gc.Gcx.findBin(ulong)

Used by:

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

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

ulong gc.gc.Gcx.reserve(ulong)

Used by:

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

Uses:

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

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

Uses:

• onOutOfMemoryError
• calloc@plt

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

Uses:

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

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

Used by:

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

Uses:

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

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

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

Used by:

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

Uses:

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

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

Used by:

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

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

Used by:

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

Uses:

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

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

Uses:

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

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

void gc.gc.Gcx.log_init()

void gc.gc.Gcx.minimize()

Used by:

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

Uses:

• free@plt
• munmap@plt

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

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

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

int gc.gc.Gcx.allocPage(ubyte)

Used by:

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

Uses:

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

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

ulong gc.gc.Pool.allocPages(ulong)

Used by:

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

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

Used by:

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

Uses:

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

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

Uses:

• const(void function()) gc.gc.Pool.__invariant14

const(void function()) gc.gc.Pool.__invariant14

Used by:

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

void gc.gc.Pool.updateOffsets(ulong)

Used by:

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

void gc.gc.Pool.Dtor()

Uses:

• free@plt
• munmap@plt

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

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

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

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

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

Used by:

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

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

Used by:

• void gc.gc.GC.initialize()

Uses:

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

gc.gc.GCMutex.__Class

Used by:

• void gc.gc.GC.initialize()

gc.gc.__array

Uses:

• _d_array_bounds

void gc.gc.__assert(int)

Uses:

• _d_assertm

void gc.proxy.__unittest_fail(int)

Uses:

• _d_unittestm

gc.gc.GC gc.proxy._gc

Used by:

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

gc.proxy.Proxy* gc.proxy.proxy

Used by:

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

gc.proxy.Proxy gc.proxy.pthis

Used by:

• gc_init

gc.proxy.__array

Uses:

• _d_array_bounds

void gc.proxy.__assert(int)

Uses:

• _d_assertm

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

Used by:

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

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

Used by:

• _d_dso_registry

Uses:

• __tls_get_addr@plt

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
• nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))

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*)
• nothrow void rt.sections_linux.checkModuleCollisions(ref const(core.sys.linux.link.dl_phdr_info), const(object.ModuleInfo*[]))

bool rt.sections_linux._isRuntimeInitialized

Used by:

• rt_init
• rt_term
• _d_dso_registry

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

Used by:

• _d_dso_registry

Uses:

• strlen@plt
• nothrow bool rt.sections_linux.findSegmentForAddr(ref const(core.sys.linux.link.dl_phdr_info), const(void*), core.sys.linux.elf.Elf64_Phdr*)
• stderr@@GLIBC_2.2.5
• __progname_full@@GLIBC_2.2.5
• nothrow bool rt.sections_linux.findDSOInfoForAddr(const(void*), core.sys.linux.link.dl_phdr_info*)
• pure nothrow @property immutable(char)[] object.ModuleInfo.name()
• fprintf@plt

void rt.sections_linux.DSO.__fieldDtor()

Uses:

• @property void rt.util.container.Array!(void[]).Array.length(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_moduleTlsCtor().int __foreachbody1(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody1(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleCtor().int __foreachbody1(ref rt.sections_linux.DSO)
• extern (C) void rt.minfo.rt_moduleTlsDtor().int __foreachbody1(ref rt.sections_linux.DSO)

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

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

Uses:

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

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

Used by:

• rt.deh_win64_posix.__eh_finddata.FPvZPyS2rt15deh_win64_posix9FuncTable14__foreachbody2MFKS2rt14sections_linux3DSOZi

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

Used by:

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

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

Uses:

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

rt.sections_linux.__array

Uses:

• _d_array_bounds

void rt.sections_linux.__assert(int)

Uses:

• _d_assertm

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

Used by:

• rt.deh_win64_posix.__eh_finddata.FPvZPyS2rt15deh_win64_posix9FuncTable14__foreachbody2MFKS2rt14sections_linux3DSOZi

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

Used by:

• _d_throwc

Uses:

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

rt.deh_win64_posix.__eh_finddata.FPvZPyS2rt15deh_win64_posix9FuncTable14__foreachbody2MFKS2rt14sections_linux3DSOZi

Uses:

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

void rt.deh_win64_posix.__unittest_fail(int)

Uses:

• _d_unittestm

rt.deh_win64_posix.__array

Uses:

• _d_array_bounds

void rt.deh_win64_posix.__assert(int)

Uses:

• _d_assertm

void rt.deh_win64_posix.terminate()

Used by:

• _d_throwc

immutable(ulong[]) rt.aaA.prime_list

Used by:

• _aaRehash
• _d_assocarrayliteralTX

void rt.aaA.__unittest_fail(int)

Uses:

• _d_unittestm

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

Uses:

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

const(pure nothrow @property @safe const(TypeInfo) function()) rt.aaA.Impl.keyti

rt.aaA.__array

Uses:

• _d_array_bounds

void rt.aaA.__assert(int)

Uses:

• _d_assertm

extern (C) int rt.aaA._aaEqual(const(TypeInfo), const(rt.aaA.AA), const(rt.aaA.AA)).int _aaKeys_x(const(rt.aaA.Entry)*)

Used by:

• _aaEqual

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(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(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_double.TypeInfo_d.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_real.TypeInfo_e.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ashort.TypeInfo_As.getHash
• const(nothrow @trusted ulong function(const(void*))) object.TypeInfo_Array.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ag.getHash
• 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_Aint.TypeInfo_Ai.getHash
• _aaGetHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_cdouble.TypeInfo_r.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_cfloat.TypeInfo_q.getHash
• const(nothrow @trusted ulong function()) object.TypeInfo.toHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_creal.TypeInfo_c.getHash

Uses:

• pure nothrow @trusted ulong rt.util.hash.hashOf(const(void)*, ulong, ulong).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)

nothrow @safe void rt.util.array._enforceNoOverlap(const(char[]), const(void*), const(void*), const(ulong))

Used by:

• _d_arraycopy

Uses:

• pure nothrow @safe object.Error object.Error.__ctor(immutable(char)[], object.Throwable)
• pure nothrow @trusted char[] rt.util.string._unsignedToTempString!(ulong, 20uL)._unsignedToTempString(const(ulong), ref char[20])
• _d_newclass
• _d_arrayappendT
• _d_throwc

nothrow @safe void rt.util.array._enforceSameLength(const(char[]), const(ulong), const(ulong))

Used by:

• _d_arraycopy

Uses:

• pure nothrow @safe object.Error object.Error.__ctor(immutable(char)[], object.Throwable)
• pure nothrow @trusted char[] rt.util.string._unsignedToTempString!(ulong, 20uL)._unsignedToTempString(const(ulong), ref char[20])
• _d_newclass
• _d_arrayappendT
• _d_throwc

pure nothrow @trusted char[] rt.util.string._unsignedToTempString!(ulong, 20uL)._unsignedToTempString(const(ulong), ref char[20])

Used by:

• const(immutable(char)[] function()) object.TypeInfo_StaticArray.toString
• nothrow @safe void rt.util.array._enforceSameLength(const(char[]), const(ulong), const(ulong))
• nothrow @safe void rt.util.array._enforceNoOverlap(const(char[]), const(void*), const(void*), const(ulong))
• const(void function(scope void delegate(const(char[])))) object.Throwable.toString

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

Used by:

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

Uses:

• memcmp@plt

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

pure nothrow @safe void rt.util.container.Array!(void[]).Array.swap(ref rt.util.container.Array!(void[]).Array)

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:

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

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

Uses:

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

@property void rt.util.container.Array!(void[]).Array.length(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()
• void rt.util.container.Array!(void[]).Array.__dtor()
• void rt.util.container.Array!(void[]).Array.popBack()
• void rt.util.container.Array!(void[]).Array.remove(ulong)
• 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:

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

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

void rt.util.container.Array!(void[]).Array.remove(ulong)

Uses:

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

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

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

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

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

Uses:

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

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

Uses:

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

rt.util.container.Array!(rt.sections_linux.DSO*).Array.backinout(pure nothrow ref @property inout(rt.sections_linux.DSO*) function())

pure nothrow @safe void rt.util.container.Array!(rt.sections_linux.DSO*).Array.swap(ref rt.util.container.Array!(rt.sections_linux.DSO*).Array)

const(pure nothrow @property @safe bool function()) rt.util.container.Array!(rt.sections_linux.DSO*).Array.empty

rt.util.container.Array!(rt.sections_linux.DSO*).Array.frontinout(pure nothrow ref @property @safe inout(rt.sections_linux.DSO*) function())

void rt.util.container.Array!(rt.sections_linux.DSO*).Array.reset()

Uses:

• @property void rt.util.container.Array!(rt.sections_linux.DSO*).Array.length(ulong)

void rt.util.container.Array!(rt.sections_linux.DSO*).Array.__dtor()

Uses:

• @property void rt.util.container.Array!(rt.sections_linux.DSO*).Array.length(ulong)

@property void rt.util.container.Array!(rt.sections_linux.DSO*).Array.length(ulong)

Used by:

• ref rt.util.container.Array!(rt.sections_linux.DSO*).Array rt.util.container.Array!(rt.sections_linux.DSO*).Array.opAssign(rt.util.container.Array!(rt.sections_linux.DSO*).Array)
• _d_dso_registry
• void rt.util.container.Array!(rt.sections_linux.DSO*).Array.__dtor()
• void rt.util.container.Array!(rt.sections_linux.DSO*).Array.popBack()
• void rt.util.container.Array!(rt.sections_linux.DSO*).Array.remove(ulong)
• void rt.util.container.Array!(rt.sections_linux.DSO*).Array.reset()

Uses:

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

const(pure nothrow @property @safe ulong function()) rt.util.container.Array!(rt.sections_linux.DSO*).Array.length

void rt.util.container.Array!(rt.sections_linux.DSO*).Array.remove(ulong)

Uses:

• @property void rt.util.container.Array!(rt.sections_linux.DSO*).Array.length(ulong)

rt.util.container.Array!(rt.sections_linux.DSO*).Array.opIndexinout(pure nothrow ref inout(rt.sections_linux.DSO*) function(ulong))

rt.util.container.Array!(rt.sections_linux.DSO*).Array.opSliceinout(pure nothrow inout(rt.sections_linux.DSO*)[] function())

rt.util.container.Array!(rt.sections_linux.DSO*).Array.opSliceinout(pure nothrow inout(rt.sections_linux.DSO*)[] function(ulong, ulong))

void rt.util.container.Array!(rt.sections_linux.DSO*).Array.popBack()

Uses:

• @property void rt.util.container.Array!(rt.sections_linux.DSO*).Array.length(ulong)

ref rt.util.container.Array!(rt.sections_linux.DSO*).Array rt.util.container.Array!(rt.sections_linux.DSO*).Array.opAssign(rt.util.container.Array!(rt.sections_linux.DSO*).Array)

Uses:

• @property void rt.util.container.Array!(rt.sections_linux.DSO*).Array.length(ulong)

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

Used by:

• @property void rt.util.container.Array!(void[]).Array.length(ulong)
• @property void rt.util.container.Array!(rt.sections_linux.DSO*).Array.length(ulong)

Uses:

• free@plt
• 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 __foreachbody1(ref rt.sections_linux.DSO)
• _d_dso_registry

Uses:

• rt.minfo.runModuleFuncs.S492rt5minfo11ModuleGroup11runTlsCtorsMFZv9__lambda1Z.runModuleFuncs.MFNaAPS6object10ModuleInfoZv

void rt.minfo.ModuleGroup.runTlsDtors()

Used by:

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

Uses:

• rt.minfo.runModuleFuncsRev.S492rt5minfo11ModuleGroup11runTlsDtorsMFZv9__lambda1Z.runModuleFuncsRev.MFNaAPS6object10ModuleInfoZv

void rt.minfo.ModuleGroup.free()

Used by:

• extern (C) void rt.minfo.rt_moduleDtor().int __foreachbody1(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:

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

Uses:

• rt.minfo.runModuleFuncs.S452rt5minfo11ModuleGroup8runCtorsMFZv9__lambda2Z.runModuleFuncs.MFNaAPS6object10ModuleInfoZv
• rt.minfo.runModuleFuncs.S452rt5minfo11ModuleGroup8runCtorsMFZv9__lambda1Z.runModuleFuncs.MFNaAPS6object10ModuleInfoZv

void rt.minfo.ModuleGroup.runDtors()

Used by:

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

Uses:

• rt.minfo.runModuleFuncsRev.S452rt5minfo11ModuleGroup8runDtorsMFZv9__lambda1Z.runModuleFuncsRev.MFNaAPS6object10ModuleInfoZv

void rt.minfo.ModuleGroup.sortCtors()

Used by:

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

Uses:

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

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

Used by:

• void rt.minfo.ModuleGroup.sortCtors()

Uses:

• malloc@plt
• free@plt
• pure nothrow @property object.ModuleInfo*[] object.ModuleInfo.importedModules()
• 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

rt.minfo.ModuleGroup.sortCtors.MFZv8StackRec11__xopEqualsFKxS2rt5minfo11ModuleGroup9sortCtorsMFZv8StackRecKxS2rt5minfo11ModuleGroup9sortCtorsMFZv8StackRecZb

Uses:

• _adEq2

void rt.minfo.ModuleGroup.sortCtors().@property object.ModuleInfo* StackRec.mod()

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

• rt.sections_linux.DSO.moduleGroupinout(ref @property inout(rt.minfo.ModuleGroup) function())
• 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 __foreachbody2(ref rt.sections_linux.DSO)

Uses:

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

rt.minfo.runModuleFuncs.S452rt5minfo11ModuleGroup8runCtorsMFZv9__lambda1Z.runModuleFuncs.MFNaAPS6object10ModuleInfoZv

Used by:

• void rt.minfo.ModuleGroup.runCtors()

Uses:

• pure nothrow void* object.ModuleInfo.addrOf(int)

rt.minfo.runModuleFuncs.S452rt5minfo11ModuleGroup8runCtorsMFZv9__lambda2Z.runModuleFuncs.MFNaAPS6object10ModuleInfoZv

Used by:

• void rt.minfo.ModuleGroup.runCtors()

Uses:

• pure nothrow void* object.ModuleInfo.addrOf(int)

rt.minfo.runModuleFuncsRev.S452rt5minfo11ModuleGroup8runDtorsMFZv9__lambda1Z.runModuleFuncsRev.MFNaAPS6object10ModuleInfoZv

Used by:

• void rt.minfo.ModuleGroup.runDtors()

Uses:

• pure nothrow void* object.ModuleInfo.addrOf(int)

rt.minfo.runModuleFuncs.S492rt5minfo11ModuleGroup11runTlsCtorsMFZv9__lambda1Z.runModuleFuncs.MFNaAPS6object10ModuleInfoZv

Used by:

• void rt.minfo.ModuleGroup.runTlsCtors()

Uses:

• pure nothrow void* object.ModuleInfo.addrOf(int)

rt.minfo.runModuleFuncsRev.S492rt5minfo11ModuleGroup11runTlsDtorsMFZv9__lambda1Z.runModuleFuncsRev.MFNaAPS6object10ModuleInfoZv

Used by:

• void rt.minfo.ModuleGroup.runTlsDtors()

Uses:

• pure nothrow void* object.ModuleInfo.addrOf(int)

void rt.tlsgc.__unittest_fail(int)

Uses:

• _d_unittestm

rt.tlsgc.__array

Uses:

• _d_array_bounds

void rt.tlsgc.__assert(int)

Uses:

• _d_assertm

shared(ulong) rt.dmain2._initCount

Used by:

• rt_init
• rt_term

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

Uses:

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

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

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:

• void rt.dmain2.printThrowable(object.Throwable)

void rt.dmain2.printThrowable(object.Throwable)

Used by:

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

Uses:

• void rt.dmain2.formatThrowable(object.Throwable, nothrow void delegate(const(char[])))

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

Uses:

• stderr@@GLIBC_2.2.5
• fprintf@plt

void rt.dmain2.__unittest_fail(int)

Uses:

• _d_unittestm

void rt.dmain2.formatThrowable(object.Throwable, nothrow void delegate(const(char[])))

Used by:

• void rt.dmain2.printThrowable(object.Throwable)

Uses:

• _d_dynamic_cast

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:

• rt_init

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

• _d_dynamic_cast

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

Used by:

• _d_arraysetlengthiT
• _d_arraysetcapacity
• _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_arrayliteralTX
• _d_arraysetlengthiT
• _d_arraysetcapacity
• _d_newarrayT
• _d_arraycatT
• _d_arraycatnT
• _d_newarrayiT
• _d_arrayappendcTX
• _adDupT
• _d_arraysetlengthT

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 @trusted const(void)[] function()) rt.typeinfo.ti_cdouble.TypeInfo_r.init

Uses:

• _d_arraycast

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

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

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

Uses:

• _Ccmp

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

pure nothrow @trusted bool rt.typeinfo.ti_cdouble.TypeInfo_r._equals(cdouble, cdouble)

Uses:

• _Ccmp

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

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

Uses:

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

pure nothrow @trusted int rt.typeinfo.ti_cdouble.TypeInfo_r._compare(cdouble, cdouble)

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

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

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

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

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

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

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

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

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

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

Uses:

• memcmp@plt

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

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

Uses:

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

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

Uses:

• bool object.TypeInfo.opEquals(Object)

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

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

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

Uses:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Uses:

• memcmp@plt

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

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

Uses:

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

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

Uses:

• bool object.TypeInfo.opEquals(Object)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Uses:

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

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

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

Uses:

• _d_arraycast

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

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

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

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

pure nothrow @trusted bool rt.typeinfo.ti_real.TypeInfo_e._equals(real, real)

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

Uses:

• pure nothrow @trusted int rt.typeinfo.ti_real.TypeInfo_e._compare(real, real)

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

Uses:

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

pure nothrow @trusted int rt.typeinfo.ti_real.TypeInfo_e._compare(real, real)

Used by:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Uses:

• memcmp@plt

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

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

Uses:

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

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

Uses:

• bool object.TypeInfo.opEquals(Object)

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

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

Uses:

• _d_arraycast

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

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

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

Uses:

• _Ccmp

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

pure nothrow @trusted bool rt.typeinfo.ti_creal.TypeInfo_c._equals(creal, creal)

Uses:

• _Ccmp

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

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

Uses:

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

pure nothrow @trusted int rt.typeinfo.ti_creal.TypeInfo_c._compare(creal, creal)

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

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

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

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(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 immutable(char)[] function()) rt.typeinfo.ti_ireal.TypeInfo_j.toString

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Uses:

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

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

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

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

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

Uses:

• memcmp@plt

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

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

Uses:

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

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

Uses:

• bool object.TypeInfo.opEquals(Object)

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

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

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

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

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

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

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

Uses:

• _d_arraycast

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

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

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

Uses:

• _Ccmp

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

pure nothrow @trusted bool rt.typeinfo.ti_cfloat.TypeInfo_q._equals(cfloat, cfloat)

Uses:

• _Ccmp

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

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

Uses:

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

pure nothrow @trusted int rt.typeinfo.ti_cfloat.TypeInfo_q._compare(cfloat, cfloat)

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

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

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

Uses:

• _d_arraycast

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

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

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

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

pure nothrow @trusted bool rt.typeinfo.ti_double.TypeInfo_d._equals(double, double)

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

Uses:

• pure nothrow @trusted int rt.typeinfo.ti_double.TypeInfo_d._compare(double, double)

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

Uses:

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

pure nothrow @trusted int rt.typeinfo.ti_double.TypeInfo_d._compare(double, double)

Used by:

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

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

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

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

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

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

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

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

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

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

TypeInfo_S3std4file15DirIteratorImpl.__init

Used by:

• void object.destroy!(std.file.DirIteratorImpl).destroy(ref std.file.DirIteratorImpl)
• void std.algorithm.move!(std.file.DirIteratorImpl).move(ref std.file.DirIteratorImpl, ref std.file.DirIteratorImpl)

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

Used by:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm
• std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm
• pure nothrow @safe bool std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.geq!(uint, uint).geq(uint, uint)

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

Used by:

• pure nothrow @safe bool std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.geq!(uint, int).geq(uint, int)

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

Used by:

• std.algorithm.HeapSortImpl.S593std10functional31__T9binaryFunVAyaa5_61203c2062Z9binaryFunTAAyaZ.sift.FAAyamymZv
• std.algorithm.optimisticInsertionSort.S593std10functional31__T9binaryFunVAyaa5_61203c2062Z9binaryFunTAAyaZ.optimisticInsertionSort.FNaNbNfAAyaZv
• std.algorithm.quickSortImpl.S593std10functional31__T9binaryFunVAyaa5_61203c2062Z9binaryFunTAAyaZ.quickSortImpl.FAAyaeZv
• std.algorithm.getPivot.S593std10functional31__T9binaryFunVAyaa5_61203c2062Z9binaryFunTAAyaZ.getPivot.FNaNbNfAAyaZm

Uses:

• _adCmp2

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

Used by:

• pure nothrow @safe ubyte[] std.algorithm.find!("a == b", ubyte[], ubyte[]).find(ubyte[], ubyte[])

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

Used by:

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

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

@safe bool std.functional.binaryFun!("a.a < b.a").binaryFun!(std.uni.CodepointInterval, std.uni.CodepointInterval).binaryFun(std.uni.CodepointInterval, std.uni.CodepointInterval)

Used by:

• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb1Vb1Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FNfS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.greater.FS3std3uni17CodepointIntervalS3std3uni17CodepointIntervalZb
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.greaterEqual.FS3std3uni17CodepointIntervalS3std3uni17CodepointIntervalZb
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.lessEqual.FS3std3uni17CodepointIntervalS3std3uni17CodepointIntervalZb
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.binaryInsertionSort.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsmZv

Uses:

• ref @property @safe uint std.uni.CodepointInterval.a()

pure nothrow @safe bool std.functional.unaryFun!("a[0] > 0x80").unaryFun!(std.uni.CodepointInterval).unaryFun(std.uni.CodepointInterval)

Used by:

• pure nothrow @safe long std.algorithm.countUntil!("a[0] > 0x80", std.uni.CodepointInterval[]).countUntil(std.uni.CodepointInterval[])

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

Used by:

• pure nothrow @safe long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], long).countUntil(std.datetime.PosixTimeZone.Transition[], long).nothrow @safe bool pred2(std.datetime.PosixTimeZone.Transition)

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

Used by:

• pure nothrow @safe long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).countUntil(std.datetime.PosixTimeZone.LeapSecond[], immutable(long)).pure nothrow @safe bool pred2(std.datetime.PosixTimeZone.LeapSecond)

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

Used by:

• pure nothrow @safe long std.algorithm.countUntil!("b < a.timeT", std.datetime.PosixTimeZone.Transition[], immutable(long)).countUntil(std.datetime.PosixTimeZone.Transition[], immutable(long)).pure nothrow @safe bool pred2(std.datetime.PosixTimeZone.Transition)

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)

Used by:

• std.algorithm.HeapSortImpl.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone14TempTransitionZ.sift.FAS3std8datetime13PosixTimeZone14TempTransitionmymZv
• std.algorithm.getPivot.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone14TempTransitionZ.getPivot.FNaNbNfAS3std8datetime13PosixTimeZone14TempTransitionZm
• std.algorithm.optimisticInsertionSort.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone14TempTransitionZ.optimisticInsertionSort.FNaNbNfAS3std8datetime13PosixTimeZone14TempTransitionZv
• std.algorithm.quickSortImpl.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone14TempTransitionZ.quickSortImpl.FAS3std8datetime13PosixTimeZone14TempTransitioneZv

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)

Used by:

• std.algorithm.getPivot.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone10LeapSecondZ.getPivot.FNaNbNfAS3std8datetime13PosixTimeZone10LeapSecondZm
• std.algorithm.quickSortImpl.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone10LeapSecondZ.quickSortImpl.FAS3std8datetime13PosixTimeZone10LeapSecondeZv
• std.algorithm.HeapSortImpl.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone10LeapSecondZ.sift.FAS3std8datetime13PosixTimeZone10LeapSecondmymZv
• std.algorithm.optimisticInsertionSort.S843std10functional56__T9binaryFunVAyaa17_612e74696d6554203c20622e74696d6554Z9binaryFunTAS3std8datetime13PosixTimeZone10LeapSecondZ.optimisticInsertionSort.FNaNbNfAS3std8datetime13PosixTimeZone10LeapSecondZv

ulong std.socketstream.SocketStream.writeBlock(const(void*), ulong)

Uses:

• void std.stream.Stream.assertWriteable()

ulong std.socketstream.SocketStream.seek(long, std.stream.SeekPos)

Uses:

• _d_newclass
• std.stream.SeekException std.stream.SeekException.__ctor(immutable(char)[])
• _d_throwc

void std.socketstream.SocketStream.close()

Uses:

• void std.stream.Stream.close()

std.socketstream.SocketStream std.socketstream.SocketStream.__ctor(std.socket.Socket, std.stream.FileMode)

Uses:

• std.stream.Stream std.stream.Stream.__ctor()

std.socketstream.SocketStream std.socketstream.SocketStream.__ctor(std.socket.Socket)

Uses:

• std.stream.Stream std.stream.Stream.__ctor()

std.socket.Socket std.socketstream.SocketStream.socket()

immutable(char)[] std.socketstream.SocketStream.toString()

ulong std.socketstream.SocketStream.readBlock(void*, ulong)

Uses:

• void std.stream.Stream.assertReadable()

void std.socketstream.__unittest_fail(int)

Uses:

• _d_unittestm

std.socketstream.__array

Uses:

• _d_array_bounds

void std.socketstream.__assert(int)

Uses:

• _d_assertm

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())

Used by:

• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function(inout(ulong)*))
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.raw_ptr!(0uL).raw_ptrinout(pure nothrow @property @safe inout(ulong)* function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function())

Used by:

• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function(inout(ulong)*))
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.raw_ptr!(1uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl) function())

Used by:

• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

Uses:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())
• std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl) function(inout(ulong)*))

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.raw_ptr!(0uL).raw_ptrinout(pure nothrow @property @safe inout(ulong)* function())

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.raw_ptr!(1uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl) function())

pure nothrow @safe bool std.uni.isPowerOf2(ulong)

Used by:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

pure nothrow @trusted dchar std.uni.toLowerTab(ulong)

Used by:

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

Uses:

• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toLowerTable()

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

Used by:

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

Uses:

• pure nothrow @property @safe immutable(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie) std.uni.graphicalTrie()
• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.length
• const(pure nothrow @safe std.uni.BitPacked!(bool, 1).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(bool, 1).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(bool, 1).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.back

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.empty

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(bool, 1).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(bool, 1).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.front

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.length

Used by:

• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opDollar
• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

const(pure nothrow @safe std.uni.BitPacked!(bool, 1).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opDollar

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.length

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.zeros(ulong, ulong)

bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.length
• const(pure nothrow @safe std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(uint, 8uL).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(uint, 8uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.back

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))

std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.empty

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(uint, 8uL).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(uint, 8uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.front

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.length

Used by:

• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opDollar
• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

const(pure nothrow @safe std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opDollar

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.length

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl*)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl*)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSlice(ulong, ulong)

bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.length
• const(pure nothrow @safe std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(uint, 13uL).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(uint, 13uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.empty

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(uint, 13uL).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(uint, 13uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.length

Used by:

• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opDollar
• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

const(pure nothrow @safe std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opDollar

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.length

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @safe std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.length

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(uint, 15uL).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(uint, 15uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))

std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.empty

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(uint, 15uL).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

const(pure nothrow @property @safe std.uni.BitPacked!(uint, 15uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.length

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals
• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opDollar

const(pure nothrow @safe std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opDollar

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.length

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl*)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl*)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @safe ulong std.uni.ceilPowerOf2(ulong)

Used by:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

pure nothrow @trusted ushort std.uni.toLowerIndex(dchar)

Used by:

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

Uses:

• pure nothrow @property @safe immutable(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) std.uni.toLowerIndexTrie()
• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

@trusted ubyte[] std.uni.ReallocPolicy.alloc!(ubyte).alloc(ulong)

Used by:

• @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.dupThisReference(uint)
• @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length(ulong)

Uses:

• malloc@plt
• pure @safe void* std.exception.enforce!(void*).enforce(void*, lazy const(char)[], immutable(char)[], ulong)

@trusted ubyte[] std.uni.ReallocPolicy.alloc!(ubyte).alloc(ulong).pure nothrow @safe const(char)[] __dgliteral2()

nothrow @trusted void std.uni.ReallocPolicy.destroy!(ubyte).destroy(ref ubyte[])

Used by:

• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.freeThisReference()
• @trusted ubyte[] std.uni.ReallocPolicy.realloc!(ubyte).realloc(ubyte[], ulong)

Uses:

• free@plt

@trusted ubyte[] std.uni.ReallocPolicy.realloc!(ubyte).realloc(ubyte[], ulong)

Used by:

• @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length(ulong)

Uses:

• nothrow @trusted void std.uni.ReallocPolicy.destroy!(ubyte).destroy(ref ubyte[])
• realloc@plt
• pure @safe void* std.exception.enforce!(void*).enforce(void*, lazy const(char)[], immutable(char)[], ulong)

@trusted ubyte[] std.uni.ReallocPolicy.realloc!(ubyte).realloc(ubyte[], ulong).pure nothrow @safe const(char)[] __dgliteral3()

pure nothrow @safe ulong std.uni.floorPowerOf2(ulong)

Used by:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

pure nothrow @property @safe immutable(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie) std.uni.graphicalTrie()

Used by:

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

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())

Used by:

• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function(inout(ulong)*))
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(0uL).raw_ptrinout(pure nothrow @property @safe inout(ulong)* function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl) function())

Used by:

• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

Uses:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(1uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())
• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl) function(inout(ulong)*))

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function())

Used by:

• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function(inout(ulong)*))
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(0uL).raw_ptrinout(pure nothrow @property @safe inout(ulong)* function())

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(1uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function())

const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

Used by:

• pure nothrow @trusted ushort std.uni.toLowerIndex(dchar)

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))
• pure nothrow uint std.uni.sliceBits!(0uL, 6uL).sliceBits.opCall!(dchar).opCall(dchar)
• std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))
• pure nothrow uint std.uni.sliceBits!(13uL, 21uL).sliceBits.opCall!(dchar).opCall(dchar)
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function())
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl) function())
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())
• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))
• pure nothrow uint std.uni.sliceBits!(6uL, 13uL).sliceBits.opCall!(dchar).opCall(dchar)

void std.uni.__unittest_fail(int)

Uses:

• _d_unittestm

pure nothrow @trusted uint std.uni.unalignedRead24(const(ubyte*), ulong)

Used by:

• pure nothrow @safe uint std.uni.read24(const(ubyte*), ulong)

pure nothrow @property @safe immutable(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) std.uni.toLowerIndexTrie()

Used by:

• pure nothrow @trusted ushort std.uni.toLowerIndex(dchar)

pure nothrow @trusted void std.uni.unalignedWrite24(ubyte*, uint, ulong)

Used by:

• pure nothrow @safe void std.uni.write24(ubyte*, uint, ulong)

@safe bool std.uni.CodepointInterval.__xopEquals(ref const(std.uni.CodepointInterval), ref const(std.uni.CodepointInterval))

Uses:

• const(pure nothrow @safe bool function(const(std.uni.CodepointInterval))) std.uni.CodepointInterval.opEquals!(const(std.uni.CodepointInterval)).opEquals

ref @property @safe uint std.uni.CodepointInterval.a()

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front(std.uni.CodepointInterval)
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.front(std.uni.CodepointInterval)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.back(std.uni.CodepointInterval)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)
• @safe bool std.functional.binaryFun!("a.a < b.a").binaryFun!(std.uni.CodepointInterval, std.uni.CodepointInterval).binaryFun(std.uni.CodepointInterval, std.uni.CodepointInterval)
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8popFrontMFNeZv
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.back(std.uni.CodepointInterval)

ref @property @safe uint std.uni.CodepointInterval.b()

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front(std.uni.CodepointInterval)
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.front(std.uni.CodepointInterval)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.back(std.uni.CodepointInterval)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8popFrontMFNeZv
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.back(std.uni.CodepointInterval)

const(pure nothrow @safe bool function(std.uni.CodepointInterval)) std.uni.CodepointInterval.opEquals!(std.uni.CodepointInterval).opEquals

Uses:

• _d_assert_msg

const(pure nothrow @safe bool function(const(std.uni.CodepointInterval))) std.uni.CodepointInterval.opEquals!(const(std.uni.CodepointInterval)).opEquals

Used by:

• @safe bool std.uni.CodepointInterval.__xopEquals(ref const(std.uni.CodepointInterval), ref const(std.uni.CodepointInterval))

ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.front
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.back
• const(@trusted std.uni.CodepointInterval function(ulong)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndex
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.back
• const(@trusted std.uni.CodepointInterval function(ulong)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opIndex

const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

Used by:

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

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))
• std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))
• pure nothrow uint std.uni.sliceBits!(13uL, 21uL).sliceBits.opCall!(dchar).opCall(dchar)
• pure nothrow uint std.uni.sliceBits!(8uL, 13uL).sliceBits.opCall!(dchar).opCall(dchar)
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl) function())
• pure nothrow uint std.uni.sliceBits!(0uL, 8uL).sliceBits.opCall!(dchar).opCall(dchar)
• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function())

std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

Used by:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

Uses:

• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.length
• pure nothrow @safe bool std.functional.binaryFun!("a<=b").binaryFun!(uint, uint).binaryFun(uint, uint)

pure nothrow uint std.uni.sliceBits!(0uL, 6uL).sliceBits.opCall!(dchar).opCall(dchar)

Used by:

• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

pure nothrow uint std.uni.sliceBits!(0uL, 8uL).sliceBits.opCall!(dchar).opCall(dchar)

Used by:

• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

pure nothrow uint std.uni.sliceBits!(6uL, 13uL).sliceBits.opCall!(dchar).opCall(dchar)

Used by:

• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

pure nothrow uint std.uni.sliceBits!(8uL, 13uL).sliceBits.opCall!(dchar).opCall(dchar)

Used by:

• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

pure nothrow uint std.uni.sliceBits!(13uL, 21uL).sliceBits.opCall!(dchar).opCall(dchar)

Used by:

• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex
• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted ushort function(ulong))

pure nothrow @trusted void std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.simpleWrite(ushort, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.opIndexAssign(ushort, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexAssign(ushort, ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSliceAssign(ushort, ulong, ulong)

std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl) function(inout(ulong)*))

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl) function())
• std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))

Used by:

• std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))
• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

pure nothrow @safe ulong std.uni.replicateBits!(8uL, 8uL).replicateBits(ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

Uses:

• pure nothrow @safe ulong std.uni.replicateBits!(4uL, 16uL).replicateBits(ulong)

bool std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed))) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed)).opEquals

pure nothrow @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndexAssign(int, ulong)

Uses:

• _d_assert_msg
• std.uni.__array
• void std.uni.__assert(int)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.back(int)

Uses:

• _d_assert_msg
• std.uni.__array

const(pure nothrow @property @safe const(int) function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.back

Uses:

• _d_assert_msg
• std.uni.__array

std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed) function())

Uses:

• _d_assert_msg

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.empty

Uses:

• _d_assert_msg

pure nothrow @property @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.front(int)

Uses:

• _d_assert_msg
• std.uni.__array

const(pure nothrow @property @safe const(int) function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.front

Uses:

• _d_assert_msg
• std.uni.__array

const(pure nothrow @safe bool function(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opEquals!(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed).opEquals

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.length
• const(pure nothrow @safe const(int) function(ulong)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndex
• _d_assert_msg

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed))) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed))

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.length
• const(pure nothrow @safe const(int) function(ulong)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndex
• _d_assert_msg

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.length

Used by:

• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opDollar
• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed))) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed)).opEquals
• const(pure nothrow @safe bool function(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opEquals!(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed).opEquals

Uses:

• _d_assert_msg

const(pure nothrow @safe const(int) function(ulong)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndex

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed))) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed)).opEquals
• const(pure nothrow @safe bool function(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opEquals!(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed).opEquals

Uses:

• _d_assert_msg
• std.uni.__array
• void std.uni.__assert(int)

pure nothrow @safe std.uni.SliceOverIndexed!(int[]).SliceOverIndexed std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opSlice()

Uses:

• _d_assert_msg

pure nothrow @safe std.uni.SliceOverIndexed!(int[]).SliceOverIndexed std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opSlice(ulong, ulong)

Uses:

• _d_assert_msg

pure nothrow @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.popBack()

Uses:

• _d_assert_msg

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opDollar

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.length
• _d_assert_msg

pure nothrow @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.popFront()

Uses:

• _d_assert_msg

pure nothrow @safe ulong std.uni.replicateBits!(1uL, 64uL).replicateBits(ulong)

Used by:

• pure nothrow @safe ulong std.uni.replicateBits!(2uL, 32uL).replicateBits(ulong)

pure nothrow @safe ulong std.uni.replicateBits!(2uL, 32uL).replicateBits(ulong)

Used by:

• pure nothrow @safe ulong std.uni.replicateBits!(4uL, 16uL).replicateBits(ulong)

Uses:

• pure nothrow @safe ulong std.uni.replicateBits!(1uL, 64uL).replicateBits(ulong)

pure nothrow @safe ulong std.uni.replicateBits!(4uL, 16uL).replicateBits(ulong)

Used by:

• pure nothrow @safe ulong std.uni.replicateBits!(8uL, 8uL).replicateBits(ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSliceAssign(ushort, ulong, ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

Uses:

• pure nothrow @safe ulong std.uni.replicateBits!(2uL, 32uL).replicateBits(ulong)

pure nothrow @safe ulong std.uni.replicateBits!(64uL, 1uL).replicateBits(ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSliceAssign(bool, ulong, ulong)

@trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)).opEquals

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexAssign(ushort, ulong)

Used by:

• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.front(ushort)
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(ushort, ulong)
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.back(ushort)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.opIndexAssign(ushort, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSliceAssign(ushort, ulong, ulong)

Uses:

• pure nothrow @safe ulong std.uni.replicateBits!(4uL, 16uL).replicateBits(ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.opIndexAssign(ushort, ulong)

pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• const(pure nothrow @property @safe ushort function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.front
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()
• const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.empty
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

Uses:

• std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl) function(inout(ulong)*))

const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.length

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSlice()
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)).opEquals

const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)).opEquals

Used by:

• @trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.length
• std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))

std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))

Used by:

• const(pure nothrow @property @safe ushort function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.front
• const(pure nothrow @safe ushort function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe ushort function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.back
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)).opEquals

Uses:

• std.uni.PackedPtrImpl!(ushort, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSlice()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.length
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSlice()
• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl*)

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()

Used by:

• const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__cpctor
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldPostBlit()
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldPostBlit()

Uses:

• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount

@trusted bool std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__xopEquals(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array), ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

Used by:

• @trusted bool std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__xopEquals(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array), ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))
• @trusted bool std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__xopEquals(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals), ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals))
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange11__xopEqualsFNeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZb
• @trusted bool std.uni.InversionList!(std.uni.GcPolicy).InversionList.__xopEquals(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList), ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList))

Uses:

• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty

const(pure nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

Uses:

• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• _d_assert_msg
• std.uni.__array

pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)

Used by:

• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front(std.uni.CodepointInterval)
• pure @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndexAssign(uint, ulong)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)
• pure @property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.front(uint)
• pure ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.subChar(dchar)
• pure @property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.back(uint)
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.back(std.uni.CodepointInterval)

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.dupThisReference(uint)
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount
• pure nothrow @safe void std.uni.write24(ubyte*, uint, ulong)

pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

Used by:

• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)
• pure @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.algorithm.copy!(int[], std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).copy(int[], std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.dupThisReference(uint)

Used by:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)

Uses:

• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)
• pure nothrow @trusted ubyte[] std.uni.GcPolicy.alloc!(ubyte).alloc(ulong)
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.freeThisReference()

Used by:

• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

Uses:

• _d_arrayliteralTX
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount
• pure nothrow @trusted void std.uni.GcPolicy.destroy!(ubyte[]).destroy(ref ubyte[])

const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty

Used by:

• const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()
• const(pure nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

Used by:

• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldDtor()
• pure nothrow ref @trusted std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opAssign(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)
• const(pure nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldDtor()
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong)

Uses:

• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount
• pure nothrow @trusted void std.uni.GcPolicy.destroy!(ubyte[]).destroy(ref ubyte[])

pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, int[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, int[])
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

Uses:

• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty
• pure nothrow @safe immutable(ulong) std.algorithm.min!(immutable(ulong), ulong).min(immutable(ulong), ulong)
• pure nothrow @trusted ubyte[] std.uni.GcPolicy.alloc!(ubyte).alloc(ulong)
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])
• pure nothrow @trusted ubyte[] std.uni.GcPolicy.realloc!(ubyte).realloc(ubyte[], ulong)
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.freeThisReference()
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount

const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length

Used by:

• pure @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.dropUpTo(uint, ulong)
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.skipUpTo(uint, ulong)
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice()
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, int[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, int[])
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)
• const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.empty
• pure ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.subChar(dchar)
• const(pure nothrow @property @trusted ulong function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.length
• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

Used by:

• pure @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.skipUpTo(uint, ulong)
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front
• const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.front
• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.back
• pure ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.subChar(dchar)
• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.back
• const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.front
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.back
• const(@trusted std.uni.CodepointInterval function(ulong)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opIndex

Uses:

• pure nothrow @safe uint std.uni.read24(const(ubyte*), ulong)

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice()

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)

Used by:

• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.dropUpTo(uint, ulong)
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.skipUpTo(uint, ulong)
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice()
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, int[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, int[])
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array*)

const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice

Used by:

• const(pure nothrow @trusted bool function(uint)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.opIndex

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed function(ulong, ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice

const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed function(ulong, ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice

Used by:

• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)*)

const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__cpctor

Used by:

• pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.byInterval()
• pure nothrow @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opSlice(ulong, ulong)
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong)

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()

pure nothrow ref @trusted std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opAssign(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)

Used by:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.dupThisReference(uint)
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.freeThisReference()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• pure nothrow @safe void std.uni.write24(ubyte*, uint, ulong)

const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount

Used by:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.freeThisReference()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• pure nothrow @safe uint std.uni.read24(const(ubyte*), ulong)

pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.byInterval()

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[])

Uses:

• const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__cpctor
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldDtor()

Used by:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.opAssign(std.uni.InversionList!(std.uni.GcPolicy).InversionList)

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

@trusted bool std.uni.InversionList!(std.uni.GcPolicy).InversionList.__xopEquals(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList), ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)

Used by:

• pure @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice()
• _d_arrayliteralTX
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• pure nothrow @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange std.range.assumeSorted!("a < b", std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).assumeSorted(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• pure nothrow @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.opSlice(ulong, ulong)
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex
• std.range.SortedRange.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa5_61203c2062Z.SortedRange.lowerBound.VE3std5range12SearchPolicy2TiZ.lowerBound.MFNaNbNfiZS3std5range147__T11SortedRangeTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa5_61203c2062Z11SortedRange
• pure nothrow @property @safe ulong std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.length()
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

Uses:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.__cpctor

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange11__fieldDtorMFNaNbNeZv

Used by:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8opAssignMFNaNbNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

Uses:

• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldDtor()

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange11__xopEqualsFNeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZb

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange15__fieldPostBlitMFNaNbNeZv

Used by:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8__cpctorMxFNaNbNeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZv

Uses:

• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldPostBlit()

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange5emptyMxFNaNbNdNeZb

Uses:

• const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.empty

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange5frontMxFNaNbNdNeZw

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

Used by:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

Uses:

• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front
• pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.byInterval()
• ref @property @safe uint std.uni.CodepointInterval.a()
• const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.empty
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldDtor()

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8__cpctorMxFNaNbNeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZv

Uses:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange15__fieldPostBlitMFNaNbNeZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8opAssignMFNaNbNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

Uses:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange11__fieldDtorMFNaNbNeZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8popFrontMFNeZv

Uses:

• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.popFront()
• const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.empty

@trusted bool std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.__xopEquals(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals), ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)).opEquals

@trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeLo.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm
• @safe void std.algorithm.swapAt!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals).swapAt(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, ulong, ulong)
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.binaryInsertionSort.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsmZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeHi.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm

Uses:

• pure @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndexAssign(uint, ulong)
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()

@property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.back(std.uni.CodepointInterval)

Uses:

• pure @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndexAssign(uint, ulong)
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()

const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.back

Used by:

• @property @safe std.uni.CodepointInterval std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.back()

Uses:

• ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)
• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndex

pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.save()

Used by:

• pure nothrow @property @safe std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.save()

const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.empty

Used by:

• pure nothrow @property @safe bool std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.empty()

@property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.front(std.uni.CodepointInterval)

Uses:

• pure @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndexAssign(uint, ulong)
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()

const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.front

Used by:

• @property @safe std.uni.CodepointInterval std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.front()

Uses:

• ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)
• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndex

pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.__ctor(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.length

pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.__ctor(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, ulong, ulong)

Used by:

• pure nothrow @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opSlice(ulong, ulong)

const(pure nothrow @property @trusted ulong function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.length

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeLo.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb0Vb0Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb1Vb1Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FNfS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• @safe void std.algorithm.reverse!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals).reverse(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals)
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb0Vb1Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• std.algorithm.copy.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsTAS3std3uni17CodepointIntervalZ.copy.FNaNfS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsAS3std3uni17CodepointIntervalZAS3std3uni17CodepointInterval11genericImplFNfS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsAS3std3uni17CodepointIntervalZAS3std3uni17CodepointInterval
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.sort.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsAS3std3uni17CodepointIntervalZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.binaryInsertionSort.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsmZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeHi.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.firstRun.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.merge.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsmKmKAS3std3uni17CodepointIntervalZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb1Vb0Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• pure nothrow @property @safe ulong std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.length()

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.length

const(@trusted std.uni.CodepointInterval function(ulong)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndex

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeLo.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb0Vb0Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb1Vb1Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FNfS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• @safe std.uni.CodepointInterval std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.opIndex(ulong)
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb0Vb1Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm
• std.algorithm.copy.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsTAS3std3uni17CodepointIntervalZ.copy.FNaNfS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsAS3std3uni17CodepointIntervalZAS3std3uni17CodepointInterval11genericImplFNfS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsAS3std3uni17CodepointIntervalZAS3std3uni17CodepointInterval
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.binaryInsertionSort.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsmZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeHi.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm
• @safe std.uni.CodepointInterval std.range.moveAt!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, ulong).moveAt(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, ulong)
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.firstRun.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.merge.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsmKmKAS3std3uni17CodepointIntervalZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.Vb1Vb0Z.gallopSearch.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.gallopSearch.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsS3std3uni17CodepointIntervalZm

Uses:

• ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)
• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndex

pure nothrow @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opSlice(ulong, ulong)

Used by:

• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeLo.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeAt.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsAS3std9algorithm292__T11TimSortImplS673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ5SliceymKmKAS3std3uni17CodepointIntervalZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.sort.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsAS3std3uni17CodepointIntervalZv
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.mergeHi.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsymmAS3std3uni17CodepointIntervalZm
• pure nothrow @safe std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.opSlice(ulong, ulong)
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.firstRun.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZm
• std.algorithm.TimSortImpl.S673std10functional39__T9binaryFunVAyaa9_612e61203c20622e61Z9binaryFunTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.merge.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsmKmKAS3std3uni17CodepointIntervalZv

Uses:

• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.__ctor(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, ulong, ulong)

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.popBack()

Used by:

• pure nothrow @safe void std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.popBack()

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.popFront()

Used by:

• pure nothrow @safe void std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.popFront()

@trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[])

Uses:

• pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))
• pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.byInterval()
• @safe std.uni.CodepointInterval[] std.array.array!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals).array(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] bisect!(std.uni.CodepointInterval[]).bisect(std.uni.CodepointInterval[], ulong, immutable(char)[])
• pure nothrow @safe long std.algorithm.countUntil!("a[0] > 0x80", std.uni.CodepointInterval[]).countUntil(std.uni.CodepointInterval[])
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] binaryScope!(std.uni.CodepointInterval[]).binaryScope(std.uni.CodepointInterval[], immutable(char)[])
• pure @safe immutable(char)[] std.string.format!(char, immutable(char)[]).format(const(char[]), immutable(char)[])
• _d_arrayappendT

@trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] bisect!(std.uni.CodepointInterval[]).bisect(std.uni.CodepointInterval[], ulong, immutable(char)[])

Used by:

• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] binaryScope!(std.uni.CodepointInterval[]).binaryScope(std.uni.CodepointInterval[], immutable(char)[])
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[])

Uses:

• _d_arraycatT
• _d_arraycatnT
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] binaryScope!(std.uni.CodepointInterval[]).binaryScope(std.uni.CodepointInterval[], immutable(char)[])
• pure @safe immutable(char)[] std.string.format!(char, immutable(char)[], uint, immutable(char)[]).format(const(char[]), immutable(char)[], uint, immutable(char)[])
• pure @safe immutable(char)[] std.string.format!(char, immutable(char)[], immutable(char)[]).format(const(char[]), immutable(char)[], immutable(char)[])
• _d_arrayappendT
• pure @safe immutable(char)[] std.string.format!(char, immutable(char)[], uint).format(const(char[]), immutable(char)[], uint)

@trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] binaryScope!(std.uni.CodepointInterval[]).binaryScope(std.uni.CodepointInterval[], immutable(char)[])

Used by:

• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] bisect!(std.uni.CodepointInterval[]).bisect(std.uni.CodepointInterval[], ulong, immutable(char)[])
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[])

Uses:

• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).pure @safe immutable(char)[] linearScope!(std.uni.CodepointInterval[]).linearScope(std.uni.CodepointInterval[], immutable(char)[])
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] bisect!(std.uni.CodepointInterval[]).bisect(std.uni.CodepointInterval[], ulong, immutable(char)[])

@trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).pure @safe immutable(char)[] linearScope!(std.uni.CodepointInterval[]).linearScope(std.uni.CodepointInterval[], immutable(char)[])

Used by:

• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).immutable(char)[] binaryScope!(std.uni.CodepointInterval[]).binaryScope(std.uni.CodepointInterval[], immutable(char)[])

Uses:

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

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldPostBlit()

Used by:

• const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.__cpctor

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()

const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.empty

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length

@property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()

Uses:

• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldDtor()
• pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.byInterval()
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()
• const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.empty
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.popFront()

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldDtor()

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• @safe std.uni.CodepointInterval[] std.array.array!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals).array(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opAssign(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange11__fieldDtorMFNaNbNeZv

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

@trusted bool std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__xopEquals(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals), ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

@trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldPostBlit()

Used by:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange15__fieldPostBlitMFNaNbNeZv
• const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__cpctor

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()

@property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.back(std.uni.CodepointInterval)

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()

const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.back

Uses:

• ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.save()

Uses:

• const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__cpctor

const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.empty

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• @safe std.uni.CodepointInterval[] std.array.array!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals).array(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange5emptyMxFNaNbNdNeZb
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8popFrontMFNeZv

@property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front(std.uni.CodepointInterval)

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• ref @property @safe uint std.uni.CodepointInterval.a()
• ref @property @safe uint std.uni.CodepointInterval.b()

const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• @safe std.uni.CodepointInterval[] std.array.array!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals).array(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8popFrontMFNeZv

Uses:

• ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)

Used by:

• pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.byInterval()

Uses:

• const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__cpctor
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong)

Used by:

• pure nothrow @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opSlice(ulong, ulong)

Uses:

• const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__cpctor
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

const(pure nothrow @property @trusted ulong function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.length

Used by:

• @safe std.uni.CodepointInterval[] std.array.array!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals).array(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length

const(@trusted std.uni.CodepointInterval function(ulong)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opIndex

Uses:

• ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

pure nothrow @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opSlice(ulong, ulong)

Uses:

• const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__cpctor
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__ctor(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong)

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.popBack()

const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__cpctor

Used by:

• @safe std.uni.CodepointInterval[] std.array.array!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals).array(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.save()

Uses:

• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldPostBlit()

pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.opAssign(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)

Uses:

• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldDtor()

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.popFront()

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• @safe std.uni.CodepointInterval[] std.array.array!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals).array(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8popFrontMFNeZv

const(pure nothrow @trusted bool function(uint)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.opIndex

Uses:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm
• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice

pure ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.subChar(dchar)

Uses:

• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.skipUpTo(uint, ulong)
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.__cpctor

Used by:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• pure @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()

Uses:

• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldPostBlit()

pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.dropUpTo(uint, ulong)

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)
• pure nothrow @property @safe bool std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.empty()
• _d_arrayliteralTX
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• pure nothrow @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange std.range.assumeSorted!("a<=b", std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).assumeSorted(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• std.range.SortedRange.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z.SortedRange.lowerBound.VE3std5range12SearchPolicy2TkZ.lowerBound.MFNaNbNfkZS3std5range145__T11SortedRangeTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z11SortedRange
• pure nothrow @property @safe ulong std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.length()

pure @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()

Uses:

• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)
• _d_arrayliteralTX
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, int[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, int[])
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])
• const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.__cpctor
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.opAssign(std.uni.InversionList!(std.uni.GcPolicy).InversionList)

Uses:

• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldDtor()

@trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.sanitize()

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice()
• ref @safe std.uni.CodepointInterval std.uni.CodepointInterval.__ctor(uint, uint)
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• ref @property @safe uint std.uni.CodepointInterval.a()
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.__ctor(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• const(@trusted std.uni.CodepointInterval function(ulong)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndex
• ref @property @safe uint std.uni.CodepointInterval.b()
• pure nothrow @safe uint std.algorithm.max!(uint, uint).max(uint, uint)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)
• std.algorithm.sort.VAyaa9_612e61203c20622e61VE3std9algorithm12SwapStrategy2TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZ.sort.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsZS3std5range247__T11SortedRangeTS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList127__T9IntervalsTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ9IntervalsVAyaa9_612e61203c20622e61Z11SortedRange
• const(pure nothrow @property @trusted ulong function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.length
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.skipUpTo(uint, ulong)

Used by:

• pure ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.subChar(dchar)

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)
• _d_arrayliteralTX
• pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• pure nothrow @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange std.range.assumeSorted!("a<=b", std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).assumeSorted(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex
• std.range.SortedRange.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z.SortedRange.lowerBound.VE3std5range12SearchPolicy2TkZ.lowerBound.MFNaNbNfkZS3std5range145__T11SortedRangeTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z11SortedRange
• pure nothrow @property @safe ulong std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.length()

@trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))

Uses:

• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.front
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__fieldDtor()
• pure nothrow @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.byInterval()
• ref @property @safe uint std.uni.CodepointInterval.a()
• const(pure nothrow @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.__cpctor
• ref @property @safe uint std.uni.CodepointInterval.b()
• const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.empty
• uint std.format.formattedWrite!(void delegate(const(char)[]), char, uint, uint).formattedWrite(void delegate(const(char)[]), const(char[]), uint, uint)
• pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).Intervals.popFront()

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__postblit()

Used by:

• const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__cpctor

Uses:

• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)
• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.empty

@trusted bool std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__xopEquals(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array), ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals

const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals

Used by:

• @trusted bool std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__xopEquals(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array), ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))

Uses:

• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.empty

const(nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals

Uses:

• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()
• _d_assert_msg
• std.uni.__array
• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.empty

@trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opIndexAssign(uint, ulong)

Uses:

• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount
• @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.dupThisReference(uint)
• pure nothrow @safe void std.uni.write24(ubyte*, uint, ulong)

@trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.dupThisReference(uint)

Used by:

• @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opIndexAssign(uint, ulong)

Uses:

• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)
• @trusted ubyte[] std.uni.ReallocPolicy.alloc!(ubyte).alloc(ulong)

nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.freeThisReference()

Used by:

• @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length(ulong)

Uses:

• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount
• _d_arrayliteralTX
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)
• nothrow @trusted void std.uni.ReallocPolicy.destroy!(ubyte).destroy(ref ubyte[])

const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.empty

Used by:

• const(nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals
• const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__postblit()
• @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length(ulong)

nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()

Used by:

• const(nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals
• nothrow ref @trusted std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opAssign(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)

Uses:

• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount
• nothrow @trusted void std.uni.ReallocPolicy.destroy!(ubyte).destroy(ref ubyte[])
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)
• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.empty

@property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length(ulong)

Uses:

• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount
• pure nothrow @safe immutable(ulong) std.algorithm.min!(immutable(ulong), ulong).min(immutable(ulong), ulong)
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])
• @trusted ubyte[] std.uni.ReallocPolicy.alloc!(ubyte).alloc(ulong)
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)
• const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.empty
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.freeThisReference()
• @trusted ubyte[] std.uni.ReallocPolicy.realloc!(ubyte).realloc(ubyte[], ulong)

const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice()
• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)

const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opIndex

Uses:

• pure nothrow @safe uint std.uni.read24(const(ubyte*), ulong)

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice()

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice(ulong, ulong)
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice(ulong, ulong)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice()

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array*)

const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice

Uses:

• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed function(ulong, ulong)) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length

const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed function(ulong, ulong)) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice

Used by:

• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)*)

const(pure nothrow @trusted void function(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__cpctor

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__postblit()

nothrow ref @trusted std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opAssign(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)

Uses:

• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()

pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)

Used by:

• @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.dupThisReference(uint)
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__postblit()
• @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length(ulong)
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.freeThisReference()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length
• pure nothrow @safe void std.uni.write24(ubyte*, uint, ulong)

const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount

Used by:

• @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opIndexAssign(uint, ulong)
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__postblit()
• @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length(ulong)
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.freeThisReference()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length
• pure nothrow @safe uint std.uni.read24(const(ubyte*), ulong)

std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

Used by:

• const(pure nothrow @trusted bool function(uint)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.opIndex

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opSlice(ulong, ulong)
• pure nothrow @safe bool std.uni.isPowerOf2(ulong)
• pure nothrow @safe ulong std.uni.floorPowerOf2(ulong)
• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opIndex
• pure nothrow @safe ulong std.uni.ceilPowerOf2(ulong)
• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.length
• std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm
• pure nothrow @safe bool std.functional.binaryFun!("a<=b").binaryFun!(uint, uint).binaryFun(uint, uint)
• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opDollar

std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

Used by:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.simpleWrite(bool, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(bool, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(bool, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(bool, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSliceAssign(bool, ulong, ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(bool, ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.simpleWrite(bool, ulong)

std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function(inout(ulong)*))

Used by:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function())

std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

Used by:

• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex
• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.simpleWrite(uint, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexAssign(uint, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function(inout(ulong)*))

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())
• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(0uL).ptrinout(pure nothrow @property @safe inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function())
• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))

Used by:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))
• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex
• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.simpleWrite(uint, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl) function(inout(ulong)*))

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl) function())
• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

Used by:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))
• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie.opIndex!().opIndex

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.simpleWrite(uint, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function(inout(ulong)*))

Used by:

• std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function())
• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))

Used by:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))
• const(pure nothrow @trusted ushort function(dchar)) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().opIndex

const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)).opEquals

Used by:

• @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.length
• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

@trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)).opEquals

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

Used by:

• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(bool, 1).BitPacked)
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(bool, 1).BitPacked)
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(bool, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(bool, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(bool, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSliceAssign(bool, ulong, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSliceAssign(bool, ulong, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong, ulong)

Uses:

• pure nothrow @safe ulong std.uni.replicateBits!(64uL, 1uL).replicateBits(ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(bool, ulong)

pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSlice(ulong, ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()
• const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.empty
• const(pure nothrow @property @safe std.uni.BitPacked!(bool, 1).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.front
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function(inout(ulong)*))

const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.length

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSlice()
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)).opEquals

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

Used by:

• const(pure nothrow @safe std.uni.BitPacked!(bool, 1).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe std.uni.BitPacked!(bool, 1).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.back
• const(pure nothrow @property @safe std.uni.BitPacked!(bool, 1).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed.front
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)).opEquals

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(bool, 1).BitPacked function(ulong))

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSlice()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.length
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSlice(ulong, ulong)

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.zeros(ulong, ulong)
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSlice()

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl*)

const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl)).opEquals

Used by:

• @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl))

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))
• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.length

@trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl)).opEquals

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(uint, 8uL).BitPacked)
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(uint, 8uL).BitPacked)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong, ulong)

Uses:

• pure nothrow @safe ulong std.uni.replicateBits!(8uL, 8uL).replicateBits(ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSlice(ulong, ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()
• const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.empty
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 8uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.front
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl) function(inout(ulong)*))

const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.length

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSlice()
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl)).opEquals

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))

Used by:

• const(pure nothrow @safe std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 8uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.back
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl)).opEquals
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 8uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed.front

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 8uL).BitPacked function(ulong))

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSlice()

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSlice(ulong, ulong)
• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.length

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSlice(ulong, ulong)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.opSlice()
• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl*)

pure nothrow @safe uint std.uni.read24(const(ubyte*), ulong)

Used by:

• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex
• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opIndex
• const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount

Uses:

• pure nothrow @trusted uint std.uni.unalignedRead24(const(ubyte*), ulong)

const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals

Used by:

• @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.length
• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

@trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

Used by:

• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(uint, 13uL).BitPacked)
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(uint, 13uL).BitPacked)
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)
• pure nothrow @safe ulong std.uni.replicateBits!(4uL, 16uL).replicateBits(ulong)

pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 13uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()
• const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.empty
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl) function(inout(ulong)*))

const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.length

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice()
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

Used by:

• const(pure nothrow @safe std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 13uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 13uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 13uL).BitPacked function(ulong))

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.length
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice()
• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl*)

const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals

Used by:

• @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl))

Uses:

• std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))
• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.length

@trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl))

Uses:

• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Used by:

• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back(std.uni.BitPacked!(uint, 15uL).BitPacked)
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front(std.uni.BitPacked!(uint, 15uL).BitPacked)
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(uint, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

Used by:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong, ulong)

Uses:

• pure nothrow @safe ulong std.uni.replicateBits!(4uL, 16uL).replicateBits(ulong)
• pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, ulong)

pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.empty
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 15uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front
• pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.popFront()
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function(inout(ulong)*))

const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.length

Used by:

• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice()

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))

Used by:

• const(pure nothrow @safe std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 15uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.back
• const(pure nothrow @trusted bool function(ref const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl))) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(const(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)).opEquals
• const(pure nothrow @property @safe std.uni.BitPacked!(uint, 15uL).BitPacked function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed.front

Uses:

• std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 15uL).BitPacked function(ulong))

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice()

Uses:

• const(pure nothrow @property @trusted ulong function()) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.length
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)
• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSlice()

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl*)

std.uni.__array

Used by:

• const(nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals
• const(pure nothrow @property @safe const(int) function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.front
• const(pure nothrow @safe const(int) function(ulong)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndex
• pure nothrow @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndexAssign(int, ulong)
• const(pure nothrow @property @safe const(int) function()) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.back
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.back(int)
• @trusted immutable(char)[] std.uni.InversionList!(std.uni.GcPolicy).InversionList.toSourceCode(immutable(char)[]).pure @safe immutable(char)[] linearScope!(std.uni.CodepointInterval[]).linearScope(std.uni.CodepointInterval[], immutable(char)[])
• pure nothrow @property @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.front(int)
• const(pure nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

Uses:

• _d_array_bounds

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

Used by:

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

Uses:

• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)

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

Used by:

• pure @safe long std.string.indexOf!(char).indexOf(const(char[]), dchar, std.string.CaseSensitive).@safe int __foreachbody6(ref long, ref dchar)
• pure long std.string.indexOf!(char, char).indexOf(const(char)[], const(char)[], std.string.CaseSensitive).pure nothrow @safe bool __lambda4!(dchar, dchar).__lambda4(dchar, dchar)
• pure @safe long std.string.indexOf!(char).indexOf(const(char[]), dchar, std.string.CaseSensitive)

Uses:

• pure nothrow @trusted ushort std.uni.toLowerIndex(dchar)
• pure nothrow @trusted dchar std.uni.toLowerTab(ulong)

pure nothrow @safe void std.uni.write24(ubyte*, uint, ulong)

Used by:

• @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opIndexAssign(uint, ulong)
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.refCount(uint)
• pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)

Uses:

• pure nothrow @trusted void std.uni.unalignedWrite24(ubyte*, uint, ulong)

bool std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)).opEquals

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed))
• @trusted bool std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.__xopEquals(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals), ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals))
• bool std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.__xopEquals(ref const(std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange), ref const(std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange))
• bool std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.__xopEquals(ref const(std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange), ref const(std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange))
• bool std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange.__xopEquals(ref const(std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange), ref const(std.range.SortedRange!(std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals, "a.a < b.a").SortedRange))
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result11__xopEqualsFKxS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultKxS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZb

Uses:

• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.length

pure @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndexAssign(uint, ulong)

Used by:

• std.algorithm.copy.TAiTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.front(std.uni.CodepointInterval)
• @property @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.back(std.uni.CodepointInterval)
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndexAssign(std.uni.CodepointInterval, ulong)
• std.algorithm.copy.TAkTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.algorithm.copy.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result13opIndexAssignMFNaNfkmZv

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)

pure @property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.back(uint)

Used by:

• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result5frontMFNaNdNfkZv

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.back

Used by:

• pure nothrow @property @safe uint std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.back()
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result5frontMFNaNbNdNfZk
• pure nothrow @safe uint std.range.moveBack!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).moveBack(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• pure nothrow @property @safe uint std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.back()

Uses:

• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed) function())

Used by:

• pure nothrow @property @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.save()
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result4saveMFNaNbNdNfZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• pure nothrow @property @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.save()

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.empty

Used by:

• pure nothrow @property @safe bool std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.empty()
• pure nothrow @property @safe bool std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.empty()
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result5emptyMFNaNbNdNfZb

pure @property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.front(uint)

Used by:

• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result4backMFNaNdNfkZv

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.front

Used by:

• pure nothrow @property @safe uint std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.front()
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result4backMFNaNbNdNfZk
• pure nothrow @property @safe uint std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.front()
• pure nothrow @safe uint std.range.moveFront!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).moveFront(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)

Uses:

• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.length

Used by:

• std.algorithm.copy.TAiTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result10retroIndexMFNaNbNfmZm
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result6lengthMFNaNbNdNfZm
• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opDollar
• pure nothrow ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.__ctor(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• std.algorithm.copy.TAkTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.algorithm.copy.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result7opSliceMFNaNbNfmmZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• const(pure nothrow @property @trusted ulong function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.length
• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)).opEquals
• pure nothrow @property @safe ulong std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.length()
• std.range.SortedRange.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa5_61203c2062Z.SortedRange.getTransitionIndex.VE3std5range12SearchPolicy2S1773std5range147__T11SortedRangeTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa5_61203c2062Z11SortedRange3geqTiZ.getTransitionIndex.MFNaNbNfiZm
• pure nothrow @property @safe ulong std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.length()
• std.range.SortedRange.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z.SortedRange.getTransitionIndex.VE3std5range12SearchPolicy2S1753std5range145__T11SortedRangeTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z11SortedRange3geqTkZ.getTransitionIndex.MFNaNbNfkZm

const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndex

Used by:

• pure nothrow @safe uint std.range.moveAt!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, ulong).moveAt(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, ulong)
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.front
• const(@property @trusted std.uni.CodepointInterval function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.back
• const(@trusted std.uni.CodepointInterval function(ulong)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.Intervals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).Intervals.opIndex
• std.algorithm.copy.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• pure nothrow @safe uint std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.opIndex(ulong)
• pure nothrow @safe uint std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.opIndex(ulong)
• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)).opEquals
• std.range.SortedRange.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa5_61203c2062Z.SortedRange.getTransitionIndex.VE3std5range12SearchPolicy2S1773std5range147__T11SortedRangeTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa5_61203c2062Z11SortedRange3geqTiZ.getTransitionIndex.MFNaNbNfiZm
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result7opIndexMFNaNbNfmZk
• std.range.SortedRange.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z.SortedRange.getTransitionIndex.VE3std5range12SearchPolicy2S1753std5range145__T11SortedRangeTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedVAyaa4_613c3d62Z11SortedRange3geqTkZ.getTransitionIndex.MFNaNbNfkZm

Uses:

• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opSlice()

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opSlice(ulong, ulong)

Used by:

• std.algorithm.copy.TAiTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.algorithm.copy.TAkTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.algorithm.copy.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFNaNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• pure nothrow @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.opSlice(ulong, ulong)
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result7opSliceMFNaNbNfmmZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• pure nothrow @safe std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.popBack()

Used by:

• pure nothrow @safe void std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.popBack()
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result8popFrontMFNaNbNfZv
• pure nothrow @safe void std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opDollar

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.length

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.popFront()

Used by:

• pure nothrow @safe void std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a < b").SortedRange.popFront()
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result7popBackMFNaNbNfZv
• pure nothrow @safe void std.range.SortedRange!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, "a<=b").SortedRange.popFront()

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array*)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)*)

Used by:

• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed function(ulong, ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice

bool std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed))) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed)).opEquals

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed))) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed))

Uses:

• const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opIndex
• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.length

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.back

Uses:

• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.empty

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.front

Uses:

• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.length

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed))) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed)).opEquals
• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm
• std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm
• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opDollar

const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opIndex

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed))) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed)).opEquals
• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm
• std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

Uses:

• const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndex

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opSlice()

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opSlice(ulong, ulong)

Used by:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

pure nothrow @safe void std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.opDollar

Used by:

• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.length

pure nothrow @safe void std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.popFront()

pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, int[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, int[])

Used by:

• pure @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)
• pure @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.algorithm.copy!(int[], std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).copy(int[], std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• pure @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.algorithm.copy!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).copy(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• std.algorithm.copy.TS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultTS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZ.copy.FNaNfS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

pure @trusted ulong std.uni.genericReplace!(void, std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, uint[]).genericReplace(ref std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array, ulong, ulong, uint[])

Used by:

• pure @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.dropUpTo(uint, ulong)
• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.skipUpTo(uint, ulong)

Uses:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice(ulong, ulong)
• pure @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.algorithm.copy!(uint[], std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).copy(uint[], std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• pure @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.algorithm.copy!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed).copy(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)
• const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• std.algorithm.copy.TS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultTS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZ.copy.FNaNfS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Used by:

• bool std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed))

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.length
• const(pure nothrow @safe ushort function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndexAssign(ushort, ulong)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexAssign(ushort, ulong)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.back(ushort)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexAssign(ushort, ulong)

const(pure nothrow @property @safe ushort function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.back

Uses:

• std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))

std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.empty

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.front(ushort)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexAssign(ushort, ulong)

const(pure nothrow @property @safe ushort function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.front

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

Uses:

• std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.length

Used by:

• const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opDollar
• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

const(pure nothrow @safe ushort function(ulong)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opIndex

Used by:

• const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed)).opEquals

Uses:

• std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opIndexinout(pure nothrow @trusted ushort function(ulong))

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opDollar

Uses:

• const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.length

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.popFront()

Used by:

• pure nothrow @trusted bool std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.zeros(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl*)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSlice(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array*)

Used by:

• pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice(ulong, ulong)

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).sliceOverIndexed(ulong, ulong, const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)*)

Used by:

• const(pure nothrow @trusted std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed function(ulong, ulong)) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice

pure nothrow @trusted ubyte[] std.uni.GcPolicy.alloc!(ubyte).alloc(ulong)

Used by:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.dupThisReference(uint)
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

Uses:

• _d_newarrayT

pure nothrow @trusted ubyte[] std.uni.GcPolicy.realloc!(ubyte).realloc(ubyte[], ulong)

Used by:

• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

Uses:

• _d_arraysetlengthT

pure nothrow @trusted void std.uni.GcPolicy.destroy!(ubyte[]).destroy(ref ubyte[])

Used by:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.freeThisReference()

void std.uni.__assert(int)

Used by:

• const(pure nothrow @safe const(int) function(ulong)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndex
• pure nothrow @safe void std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndexAssign(int, ulong)

Uses:

• _d_assertm

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

Used by:

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

Uses:

• _d_newclass
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _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

pure nothrow @safe 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).nothrow std.utf.UTFException exception(immutable(char)[])
• pure @safe void std.utf.encode(ref char[], dchar)
• pure @safe void std.utf.encode(ref wchar[], dchar)
• pure @safe ulong std.utf.encode(ref char[4], dchar)
• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*).void formatArg(char)

Uses:

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

pure @safe 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, 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, char[]).decodeImpl(ref char[], ref ulong).pure @safe std.utf.UTFException exception!(char[]).exception(char[], immutable(char)[])
• 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:

• pure @safe immutable(char)[] std.string.format!(char, ulong).format(const(char[]), ulong)
• _d_arraycatT
• pure nothrow @safe Exception object.Exception.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)

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

Uses:

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

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

Used by:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• pure dchar std.utf.decodeImpl!(true, const(char[])).decodeImpl(ref const(char[]), ref ulong)
• pure @trusted dchar std.utf.decode!(immutable(char)[]).decode(ref immutable(char)[], ref ulong)
• pure @trusted dchar std.utf.decode!(const(char)[]).decode(ref const(char)[], ref ulong)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• pure dchar std.utf.decodeImpl!(true, immutable(char)[]).decodeImpl(ref immutable(char)[], ref ulong)
• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*).void formatArg(char)

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

Used by:

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

Uses:

• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• void std.utf.__assert(int)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• _d_assert_msg
• std.utf.__array

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

Used by:

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

Uses:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• void std.utf.__assert(int)
• _d_assert_msg
• std.utf.__array

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

Used by:

• pure @property @safe dchar std.array.front!(immutable(char)).front(immutable(char)[])
• pure @property @safe dchar std.array.back!(immutable(char)).back(immutable(char)[])
• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*)

Uses:

• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• void std.utf.__assert(int)
• _d_assert_msg
• pure dchar std.utf.decodeImpl!(true, immutable(char)[]).decodeImpl(ref immutable(char)[], ref ulong)
• std.utf.__array

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

Used by:

• pure @trusted immutable(wchar)[] std.utf.toUTF16(const(char[]))
• pure @trusted immutable(dchar)[] std.utf.toUTF32(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 @trusted immutable(char)[] std.utf.toUTF8(const(wchar[]))

Uses:

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

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

Used by:

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

Uses:

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

void std.utf.__unittest_fail(int)

Uses:

• _d_unittestm

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

Used by:

• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*).void formatArg(char).void putstr(const(char[]))

Uses:

• pure @safe uint std.utf.stride!(const(char)[]).stride(ref const(char)[], ulong)
• _d_newclass
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _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 __foreachbody2(ref ulong, ref dchar)

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

Used by:

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

Uses:

• _d_assert_msg
• _d_newclass
• std.utf.__array
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, immutable(char)[], ulong, object.Throwable)
• _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:

• void std.utf.__assert(int)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException outOfBounds()
• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• _d_throwc
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong).std.utf.UTFException invalidUTF()

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

• void std.utf.__assert(int)
• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• 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()
• _d_throwc

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

Used by:

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

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

Used by:

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

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

Uses:

• _d_newclass
• std.utf.__array
• pure @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], ulong, 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:

• void std.utf.__assert(int)
• pure dchar std.utf.decodeImpl!(true, immutable(char)[]).decodeImpl(ref immutable(char)[], ref ulong).std.utf.UTFException invalidUTF()
• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• pure dchar std.utf.decodeImpl!(true, immutable(char)[]).decodeImpl(ref immutable(char)[], ref ulong).std.utf.UTFException outOfBounds()
• _d_throwc

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

Used by:

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

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

Used by:

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

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

Uses:

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

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

Used by:

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

Uses:

• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• 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()
• _d_throwc

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

Used by:

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

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

Used by:

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

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

Uses:

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

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:

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

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

Used by:

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

Uses:

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

pure nothrow @safe bool std.utf.canSearchInCodeUnits!(char).canSearchInCodeUnits(dchar)

Used by:

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

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

Used by:

• pure @trusted immutable(char)[] std.utf.toUTF8(const(wchar[]))
• ulong std.stdio.readlnImpl(shared(core.stdc.stdio._IO_FILE)*, ref char[], dchar)
• pure @trusted immutable(char)[] std.utf.toUTF8(const(dchar[]))

Uses:

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

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

Used by:

• pure @trusted immutable(wchar)[] std.utf.toUTF16(const(char[]))

Uses:

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

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

Used by:

• pure @safe void std.array.Appender!(const(char)[]).Appender.put!(dchar).put(dchar)
• pure @safe immutable(char)[] std.algorithm.find!("a == b", immutable(char)[], char).find(immutable(char)[], char)
• pure @safe void std.array.Appender!(immutable(char)[]).Appender.put!(dchar).put(dchar)
• pure @safe void std.array.Appender!(immutable(char)[]).Appender.put!(const(dchar)).put(const(dchar))

Uses:

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

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

Used by:

• void std.stream.Stream.doFormatCallback(dchar)
• void std.stdio.File.LockingTextWriter.put!(dchar).put(dchar)
• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*).void formatArg(char)

pure @trusted immutable(char)[] std.utf.toUTF8(const(wchar[]))

Used by:

• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*)
• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*).void formatArg(char)

Uses:

• _d_arraysetlengthiT
• pure @trusted dchar std.utf.decode!(const(wchar[])).decode(ref const(wchar[]), ref ulong)
• pure @safe void std.utf.encode(ref char[], dchar)
• pure nothrow immutable(char)[] std.exception.assumeUnique!(char).assumeUnique(ref char[])

pure @trusted immutable(char)[] std.utf.toUTF8(const(dchar[]))

Used by:

• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*)
• void std.format.doFormat(void delegate(dchar), TypeInfo[], void*).void formatArg(char)

Uses:

• _d_arraysetlengthiT
• pure @safe void std.utf.encode(ref char[], dchar)
• pure nothrow immutable(char)[] std.exception.assumeUnique!(char).assumeUnique(ref char[])

std.utf.__array

Used by:

• pure @trusted dchar std.utf.decode!(char[]).decode(ref char[], ref ulong)
• pure @trusted dchar std.utf.decode!(immutable(char)[]).decode(ref immutable(char)[], ref ulong)
• 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 @trusted dchar std.utf.decode!(const(char)[]).decode(ref const(char)[], ref 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 @safe uint std.utf.stride!(const(char)[]).stride(ref const(char)[], ulong)
• pure @safe void std.utf.encode(ref char[], dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])
• pure @safe uint std.utf.strideBack!(immutable(char)[]).strideBack(ref immutable(char)[], ulong)
• pure nothrow @safe std.utf.UTFException std.utf.UTFException.setSequence(uint[]...)
• pure dchar std.utf.decodeImpl!(true, const(char[])).decodeImpl(ref const(char[]), ref ulong).pure @safe std.utf.UTFException exception!(const(char)[]).exception(const(char)[], immutable(char)[])

Uses:

• _d_array_bounds

pure @trusted immutable(wchar)[] std.utf.toUTF16(const(char[]))

Used by:

• int std.stream.Stream.vreadf(TypeInfo[], void*)

Uses:

• _d_arraysetlengthiT
• pure @trusted dchar std.utf.decode!(const(char[])).decode(ref const(char[]), ref ulong)
• _d_arrayappendcTX
• pure @safe void std.utf.encode(ref wchar[], dchar)
• pure nothrow immutable(wchar)[] std.exception.assumeUnique!(wchar).assumeUnique(ref wchar[])

pure @trusted immutable(dchar)[] std.utf.toUTF32(const(char[]))

Used by:

• int std.stream.Stream.vreadf(TypeInfo[], void*)

Uses:

• _d_arraysetlengthiT
• pure nothrow immutable(dchar)[] std.exception.assumeUnique!(dchar).assumeUnique(dchar[])
• pure @trusted dchar std.utf.decode!(const(char[])).decode(ref const(char[]), ref ulong)

void std.utf.__assert(int)

Used by:

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

Uses:

• _d_assertm

pure @safe 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:

• pure @safe 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:

• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(int).to(int)
• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(char).to(char)
• pure nothrow @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(immutable(char)[]).to(immutable(char)[])
• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(void*).to(void*)
• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(ubyte).to(ubyte)
• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(bool).to(bool)
• _d_arrayappendT
• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(const(char)[]).to(const(char)[])

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

Used by:

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

Uses:

• pure nothrow @safe const(char)[] std.conv.toImpl!(const(char)[], const(char)[]).toImpl(const(char)[])

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

Used by:

• immutable(char)[] std.stream.TArrayStream!(ubyte[]).TArrayStream.toString()
• immutable(char)[] std.stream.TArrayStream!(std.mmfile.MmFile).TArrayStream.toString()

Uses:

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

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

Used by:

• void std.socket.Protocol.populate(core.sys.posix.netdb.protoent*)
• @trusted std.file.FileException std.file.FileException.__ctor(const(char[]), uint, immutable(char)[], ulong)
• void std.socket.InternetHost.populate(core.sys.posix.netdb.hostent*)
• const(immutable(char)[] function()) std.socket.InternetAddress.toAddrString
• immutable(char)[] std.socket.InternetAddress.addrToString(uint)
• @property immutable(char)[] std.socket.Socket.hostName()
• void std.socket.Service.populate(core.sys.posix.netdb.servent*)

Uses:

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

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

Used by:

• pure @safe 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)[])

Uses:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], void*).toImpl(void*)

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

Used by:

• 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)[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], const(char)[], immutable(char)[], const(char)[]).textImpl(const(char)[], immutable(char)[], const(char)[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], const(char)[], immutable(char)[]).textImpl(immutable(char)[], const(char)[], immutable(char)[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], const(char)[]).textImpl(immutable(char)[], const(char)[])
• pure @safe 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)[])

Uses:

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

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

Used by:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], std.socket.SocketOption).toImpl(std.socket.SocketOption)
• 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)[])
• pure nothrow @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], immutable(char)[], immutable(char)[]).textImpl(immutable(char)[], immutable(char)[], immutable(char)[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], char).textImpl(immutable(char)[], char)
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], const(char)[], immutable(char)[], const(char)[]).textImpl(const(char)[], immutable(char)[], const(char)[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], const(char)[], immutable(char)[]).textImpl(immutable(char)[], const(char)[], immutable(char)[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], const(char)[]).textImpl(immutable(char)[], const(char)[])
• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], dchar, immutable(char)[]).textImpl(immutable(char)[], dchar, immutable(char)[])
• pure @safe 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)[])

Uses:

• pure nothrow @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], immutable(char)[]).toImpl(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)
• std.socket.AddressInfo[] std.socket.getAddressInfoImpl(const(char[]), const(char[]), core.sys.posix.netdb.addrinfo*)
• immutable(char)[] std.socket.formatGaiError(int)
• const(nothrow @property immutable(char)[] function()) std.datetime.LocalTime.dstName
• @trusted immutable(char)[][immutable(char)[]] std.process.environment.toAA()

Uses:

• pure immutable(char)[] std.conv.toImpl!(immutable(char)[], const(char)*).toImpl(const(char)*)

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

Used by:

• const(@property immutable(char)[] function()) std.socket.UnixAddress.path

Uses:

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

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

Used by:

• void std.socket.Socket.getOption(std.socket.SocketOptionLevel, std.socket.SocketOption, out core.time.Duration).pure @safe object.Throwable __dgliteral4()
• void std.socket.Socket.setOption(std.socket.SocketOptionLevel, std.socket.SocketOption, core.time.Duration).pure @safe object.Throwable __dgliteral4()

Uses:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], std.socket.SocketOption).toImpl(std.socket.SocketOption)

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

Used by:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], char).textImpl(immutable(char)[], char)
• pure @safe 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)[])

Uses:

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

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

Used by:

• pure @safe 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)[])

Uses:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], bool).toImpl(bool)

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

Used by:

• pure @safe 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)[])

Uses:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte)

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

Used by:

• pure @safe 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)[])

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

• pure @safe immutable(char)[] std.conv.textImpl!(immutable(char)[], immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[]).textImpl(immutable(char)[], uint, immutable(char)[], ulong, immutable(char)[])
• void std.format.formatNth!(std.stdio.File.LockingTextWriter, char, ubyte[]).formatNth(std.stdio.File.LockingTextWriter, ref std.format.FormatSpec!(char).FormatSpec, ulong, ubyte[]).pure @safe immutable(char)[] gencode!(1uL).gencode()
• void std.format.formatNth!(std.stdio.File.LockingTextWriter, char, double).formatNth(std.stdio.File.LockingTextWriter, ref std.format.FormatSpec!(char).FormatSpec, ulong, double).pure @safe immutable(char)[] gencode!(1uL).gencode()
• void std.format.formatNth!(std.stdio.File.LockingTextWriter, char, std.datetime.SysTime).formatNth(std.stdio.File.LockingTextWriter, ref std.format.FormatSpec!(char).FormatSpec, ulong, std.datetime.SysTime).pure @safe immutable(char)[] gencode!(1uL).gencode()

Uses:

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

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

Used by:

• const(immutable(char)[] function()) std.socket.InternetAddress.toPortString
• std.socket.Internet6Address std.socket.Internet6Address.__ctor(const(char[]), ushort)

Uses:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort)

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

Used by:

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

Uses:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], dchar).toImpl(dchar)

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

Used by:

• pure @safe std.conv.ConvException std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• pure @safe std.conv.ConvException std.conv.convError!(const(char)[], uint).convError(const(char)[], immutable(char)[], ulong)
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).pure nothrow @safe object.Throwable __dgliteral4()
• pure @safe std.conv.ConvException std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)

Uses:

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

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

Used by:

• pure @safe 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.stdio.File.LockingTextWriter, ubyte[], char).formatRange(ref std.stdio.File.LockingTextWriter, ref ubyte[], ref std.format.FormatSpec!(char).FormatSpec)

Uses:

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

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

Used by:

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

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

Used by:

• 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 nothrow @safe object.Throwable __dgliteral2()

Uses:

• pure nothrow @safe 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)

Uses:

• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass
• _d_throwc
• pure @safe int std.conv.toImpl!(int, long).toImpl(long).pure nothrow @trusted int __lambda2!(long).__lambda2(ref long)

pure @safe int std.conv.toImpl!(int, long).toImpl(long).pure nothrow @trusted int __lambda2!(long).__lambda2(ref long)

Used by:

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

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

Used by:

• pure @safe int std.conv.to!(int).to!(ulong).to(ulong)

Uses:

• pure nothrow @safe 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).pure nothrow @trusted int __lambda2!(ulong).__lambda2(ref ulong)

pure @safe int std.conv.toImpl!(int, ulong).toImpl(ulong).pure nothrow @trusted int __lambda2!(ulong).__lambda2(ref ulong)

Used by:

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

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

Used by:

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

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

Used by:

• pure nothrow @safe long std.conv.to!(long).to!(long).to(long)

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

Used by:

• pure @safe long std.conv.to!(long).to!(ulong).to(ulong)

Uses:

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

pure @safe long std.conv.toImpl!(long, ulong).toImpl(ulong).pure nothrow @safe object.Throwable __dgliteral2()

Uses:

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

pure nothrow @safe ubyte std.conv.unsigned!(ubyte).unsigned(ubyte)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(2uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(3uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(4uL, 10, true).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(3uL, 10).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL).toStringRadixConvert(uint)

pure nothrow @safe uint std.conv.unsigned!(int).unsigned(int)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(32uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(13uL, 10, true).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 10).toStringRadixConvert(uint)

pure nothrow @safe uint std.conv.unsigned!(uint).unsigned(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(32uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 10).toStringRadixConvert(uint)

pure nothrow @safe ulong std.conv.unsigned!(ulong).unsigned(ulong)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(25uL, 10, true).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(16uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(64uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(48uL).toStringRadixConvert(uint)

pure nothrow @safe ushort std.conv.unsigned!(ushort).unsigned(ushort)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(16uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL, 10).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(4uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL).toStringRadixConvert(uint)

void std.conv.__unittest_fail(int)

Uses:

• _d_unittestm

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

Used by:

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

Uses:

• pure @safe uint std.conv.parse!(uint, const(char)[]).parse(ref const(char)[])
• pure @safe std.conv.ConvException std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure @safe ubyte std.conv.parse!(ubyte, const(char)[]).parse(ref const(char)[]).nothrow @trusted ubyte __lambda2()
• _d_newclass
• _d_throwc

pure @safe ubyte std.conv.parse!(ubyte, const(char)[]).parse(ref const(char)[]).nothrow @trusted ubyte __lambda2()

Used by:

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

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

Used by:

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

Uses:

• pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure @property @safe dchar std.array.front!(const(char)).front(const(char)[])
• pure nothrow @trusted void std.array.popFront!(const(char)).popFront(ref const(char)[])
• _d_newclass
• _d_throwc
• pure @safe std.conv.ConvException std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)

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

Used by:

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

Uses:

• pure nothrow @property @safe bool std.array.empty!(char).empty(const(char[]))
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• pure @safe std.conv.ConvException std.conv.convError!(const(char)[], uint).convError(const(char)[], immutable(char)[], ulong)
• pure @property @safe dchar std.array.front!(const(char)).front(const(char)[])
• pure nothrow @trusted void std.array.popFront!(const(char)).popFront(ref const(char)[])
• _d_newclass
• _d_throwc

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

Used by:

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

Uses:

• std.array.Appender!(immutable(char)[]).Appender.datainout(pure nothrow @property @trusted immutable(char)[] function())
• pure @safe 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)
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()

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

Used by:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], bool).toImpl(bool)

Uses:

• std.array.Appender!(immutable(char)[]).Appender.datainout(pure nothrow @property @trusted immutable(char)[] function())
• pure @safe 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 @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()

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

Used by:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], dchar).toImpl(dchar)

Uses:

• std.array.Appender!(immutable(char)[]).Appender.datainout(pure nothrow @property @trusted immutable(char)[] function())
• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, dchar, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, dchar, ref std.format.FormatSpec!(char).FormatSpec)
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()

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

Used by:

• pure @safe ubyte std.conv.to!(ubyte).to!(const(uint)).to(const(uint))

Uses:

• pure @safe ubyte std.conv.toImpl!(ubyte, const(uint)).toImpl(const(uint)).pure nothrow @trusted ubyte __lambda2!(const(uint)).__lambda2(ref const(uint))
• pure nothrow @safe std.conv.ConvOverflowException std.conv.ConvOverflowException.__ctor(immutable(char)[], immutable(char)[], ulong)
• _d_newclass
• _d_throwc

pure @safe ubyte std.conv.toImpl!(ubyte, const(uint)).toImpl(const(uint)).pure nothrow @trusted ubyte __lambda2!(const(uint)).__lambda2(ref const(uint))

Used by:

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

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

Used by:

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

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

Used by:

• pure @safe int std.conv.to!(int).to!(const(uint)).to(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 nothrow @safe object.Throwable __dgliteral2()

Uses:

• pure nothrow @safe 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))

Used by:

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

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

Used by:

• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, 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)[] __dgliteral13()
• uint std.format.formattedWrite!(std.stdio.File.LockingTextWriter, char, std.datetime.SysTime).formattedWrite(std.stdio.File.LockingTextWriter, const(char[]), std.datetime.SysTime).pure @safe immutable(char)[] __dgliteral7()
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp().pure @safe const(char)[] __dgliteral1()
• uint std.format.formattedWrite!(void delegate(const(char)[]), char, uint, uint).formattedWrite(void delegate(const(char)[]), const(char[]), uint, uint).pure @safe immutable(char)[] __dgliteral10()
• uint std.format.formattedWrite!(std.stdio.File.LockingTextWriter, char, double).formattedWrite(std.stdio.File.LockingTextWriter, const(char[]), double).pure @safe immutable(char)[] __dgliteral7()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], uint, immutable(char)[]).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), immutable(char)[], uint, immutable(char)[]).pure @safe immutable(char)[] __dgliteral13()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), uint).pure @safe immutable(char)[] __dgliteral7()
• pure @safe 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)[] __dgliteral10()
• pure @safe 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)[] __dgliteral13()
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp()
• uint std.format.formattedWrite!(std.stdio.File.LockingTextWriter, char, ubyte[]).formattedWrite(std.stdio.File.LockingTextWriter, const(char[]), ubyte[]).pure @safe immutable(char)[] __dgliteral7()
• pure @safe 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)[] __dgliteral10()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, ulong).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), ulong).pure @safe immutable(char)[] __dgliteral7()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, immutable(char)[], uint, uint).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), immutable(char)[], uint, uint).pure @safe immutable(char)[] __dgliteral13()
• pure @safe void std.format.FormatSpec!(char).FormatSpec.fillUp().pure @safe immutable(char)[] __dgliteral3()
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, int).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), int).pure @safe immutable(char)[] __dgliteral7()
• pure @safe 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)[] __dgliteral13()
• pure @safe 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)[] __dgliteral7()
• pure @safe 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)[] __dgliteral10()
• pure @safe 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)[] __dgliteral13()

Uses:

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

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

Used by:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], void*).toImpl(void*)

Uses:

• std.array.Appender!(immutable(char)[]).Appender.datainout(pure nothrow @property @trusted immutable(char)[] function())
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• pure @safe 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 @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], char).toImpl(char)

Used by:

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

Uses:

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

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

Used by:

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

Uses:

• pure @safe immutable(char)[] std.conv.toStr!(immutable(char)[], bool).toStr(bool)

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase)

Used by:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte)

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(2uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(3uL, 8).toStringRadixConvert(uint)
• void std.conv.__assert(int)
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(3uL, 10).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL).toStringRadixConvert(uint)

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

Uses:

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

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ubyte std.conv.unsigned!(ubyte).unsigned(ubyte)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(3uL, 8).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ubyte std.conv.unsigned!(ubyte).unsigned(ubyte)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 2).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ubyte std.conv.unsigned!(ubyte).unsigned(ubyte)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(2uL, 16).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ubyte std.conv.unsigned!(ubyte).unsigned(ubyte)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(3uL, 10).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ubyte std.conv.unsigned!(ubyte).unsigned(ubyte)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(4uL, 10, true).toStringRadixConvert(uint)

Uses:

• pure nothrow @safe ubyte std.conv.unsigned!(ubyte).unsigned(ubyte)
• std.conv.__array
• _adDupT

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

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ubyte).toImpl(ubyte, uint, std.ascii.LetterCase)

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(32uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(13uL, 10, true).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL).toStringRadixConvert(uint)
• void std.conv.__assert(int)
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 10).toStringRadixConvert(uint)

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

Uses:

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

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(int).unsigned(int)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 8).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(int).unsigned(int)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(32uL, 2).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(int).unsigned(int)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 16).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(int).unsigned(int)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 10).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(int).unsigned(int)
• std.conv.__array
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(13uL, 10, true).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(int).unsigned(int)
• std.conv.__array
• _adDupT

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

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], int).toImpl(int, uint, std.ascii.LetterCase)

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase)

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(32uL, 2).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL).toStringRadixConvert(uint)
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 10).toStringRadixConvert(uint)

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

Uses:

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

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(uint).unsigned(uint)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 8).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(uint).unsigned(uint)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(32uL, 2).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(uint).unsigned(uint)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(8uL, 16).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(uint).unsigned(uint)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL, 10).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe uint std.conv.unsigned!(uint).unsigned(uint)
• _adDupT

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

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], uint).toImpl(uint, uint, std.ascii.LetterCase)

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase)

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(16uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(64uL, 2).toStringRadixConvert(uint)
• void std.conv.__assert(int)
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(48uL).toStringRadixConvert(uint)

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

Uses:

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

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(48uL).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase)

Uses:

• std.conv.__array
• pure nothrow @safe ulong std.conv.unsigned!(ulong).unsigned(ulong)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 8).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase)

Uses:

• std.conv.__array
• pure nothrow @safe ulong std.conv.unsigned!(ulong).unsigned(ulong)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(64uL, 2).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase)

Uses:

• std.conv.__array
• pure nothrow @safe ulong std.conv.unsigned!(ulong).unsigned(ulong)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(16uL, 16).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase)

Uses:

• std.conv.__array
• pure nothrow @safe ulong std.conv.unsigned!(ulong).unsigned(ulong)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase)

Uses:

• std.conv.__array
• pure nothrow @safe ulong std.conv.unsigned!(ulong).unsigned(ulong)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(25uL, 10, true).toStringRadixConvert(uint)

Uses:

• std.conv.__array
• pure nothrow @safe ulong std.conv.unsigned!(ulong).unsigned(ulong)
• _adDupT

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

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase)

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase)

Used by:

• pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort)

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(16uL, 2).toStringRadixConvert(uint)
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL, 10).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(4uL, 16).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL, 8).toStringRadixConvert(uint)
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL).toStringRadixConvert(uint)

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

Uses:

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

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(12uL).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ushort std.conv.unsigned!(ushort).unsigned(ushort)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL, 8).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ushort std.conv.unsigned!(ushort).unsigned(ushort)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(16uL, 2).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ushort std.conv.unsigned!(ushort).unsigned(ushort)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(4uL, 16).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ushort std.conv.unsigned!(ushort).unsigned(ushort)
• _adDupT

pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(6uL, 10).toStringRadixConvert(uint)

Used by:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase)

Uses:

• pure nothrow @safe ushort std.conv.unsigned!(ushort).unsigned(ushort)
• _adDupT

pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort)

Used by:

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

Uses:

• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ushort).toImpl(ushort, uint, std.ascii.LetterCase)

pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], dchar).toImpl(dchar)

Used by:

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

Uses:

• pure @safe immutable(char)[] std.conv.toStr!(immutable(char)[], dchar).toStr(dchar)

pure @safe immutable(char)[] std.conv.toStr!(immutable(char)[], const(byte)*).toStr(const(byte)*)

Used by:

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

Uses:

• pure @safe void std.format.formatValue!(std.array.Appender!(immutable(char)[]).Appender, const(byte)*, char).formatValue(std.array.Appender!(immutable(char)[]).Appender, const(byte)*, ref std.format.FormatSpec!(char).FormatSpec)
• std.array.Appender!(immutable(char)[]).Appender.datainout(pure nothrow @property @trusted immutable(char)[] function())
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()

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

Used by:

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

Uses:

• _adDupT

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

Used by:

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

Uses:

• strlen@plt
• _adDupT

pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], void*).toImpl(void*)

Used by:

• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(void*).to(void*)

Uses:

• pure @safe immutable(char)[] std.conv.toStr!(immutable(char)[], void*).toStr(void*)

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

Used by:

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

Uses:

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

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

Used by:

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

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

Used by:

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

Uses:

• _adDupT

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

Used by:

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

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

Used by:

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

Uses:

• strlen@plt
• _adDupT

pure @safe immutable(char)[] std.conv.toImpl!(immutable(char)[], const(byte)*).toImpl(const(byte)*)

Used by:

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

Uses:

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

pure @safe std.conv.ConvException std.conv.convError!(const(char)[], ubyte).convError(const(char)[], immutable(char)[], ulong)

Used by:

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

Uses:

• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

pure @safe std.conv.ConvException std.conv.convError!(const(char)[], int).convError(const(char)[], immutable(char)[], ulong)

Used by:

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

Uses:

• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)

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

Used by:

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

Uses:

• pure @safe immutable(char)[] std.conv.convError_unexpected!(const(char)[]).convError_unexpected(const(char)[])
• pure nothrow @safe immutable(char)[] std.conv.text!(immutable(char)[], immutable(char)[], immutable(char)[]).text(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_newclass
• pure nothrow @safe std.conv.ConvException std.conv.ConvException.__ctor(immutable(char)[], immutable(char)[], ulong)