GraphViz .dot file

Jump to D main()

TypeInfo_Ah.__init

Used by:

• pure nothrow @safe void std.array.Appender!(ubyte[]).Appender.put!(ubyte).put(ubyte)
• pure nothrow @safe void std.array.Appender!(ubyte[]).Appender.ensureAddable(ulong).nothrow @trusted core.memory.BlkInfo_ __lambda5()
• pure nothrow @safe void std.array.Appender!(ubyte[]).Appender.reserve(ulong)
• pure nothrow @safe void std.array.Appender!(ubyte[]).Appender.ensureAddable(ulong)
• pure nothrow @safe void std.array.Appender!(ubyte[]).Appender.put!(ubyte[]).put(ubyte[])

TypeInfo_Axa.__init

Used by:

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

TypeInfo_Aya.__init

Used by:

• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong).nothrow @trusted core.memory.BlkInfo_ __lambda5()
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.reserve(ulong)
• pure @safe void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, dchar).put(ref std.array.Appender!(immutable(char)[]).Appender, dchar)
• pure @safe void std.array.Appender!(immutable(char)[]).Appender.put!(dchar).put(dchar)
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.put!(char).put(char)
• pure nothrow @safe void std.range.put!(std.array.Appender!(immutable(char)[]).Appender, char[]).put(ref std.array.Appender!(immutable(char)[]).Appender, char[])
• pure @safe uint std.format.formattedWrite!(std.array.Appender!(immutable(char)[]).Appender, char, const(uint), const(uint)).formattedWrite(std.array.Appender!(immutable(char)[]).Appender, const(char[]), const(uint), const(uint))
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.ensureAddable(ulong)
• 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 void std.array.Appender!(immutable(char)[]).Appender.put!(char[]).put(char[])
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.put!(const(char)).put(const(char))
• pure nothrow @safe void std.array.Appender!(immutable(char)[]).Appender.put!(immutable(char)[]).put(immutable(char)[])

TypeInfo_AAya.__init

Used by:

• immutable(char)[][] std.array.split!(immutable(char)[], immutable(char)[]).split(immutable(char)[], immutable(char)[])
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong)
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.put!(immutable(char)[]).put(immutable(char)[])
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.ensureAddable(ulong).nothrow @trusted core.memory.BlkInfo_ __lambda5()
• pure nothrow @safe void std.array.Appender!(immutable(char)[][]).Appender.reserve(ulong)

TypeInfo_S3std5stdio4File.__init

Used by:

• void object.destroy!(std.stdio.File).destroy(ref std.stdio.File)
• @property bool std.stdio.LockingTextReader.empty()

TypeInfo_AS3std4file8DirEntry.__init

Used by:

• pure nothrow @safe void std.array.Appender!(std.file.DirEntry[]).Appender.ensureAddable(ulong).nothrow @trusted core.memory.BlkInfo_ __lambda5()
• ref std.file.DirIteratorImpl std.file.DirIteratorImpl.__ctor(immutable(char)[], std.file.SpanMode, bool)
• void std.file.DirIteratorImpl.popFront()
• pure nothrow @safe void std.array.Appender!(std.file.DirEntry[]).Appender.reserve(ulong)
• pure nothrow @safe void std.array.Appender!(std.file.DirEntry[]).Appender.ensureAddable(ulong)
• pure nothrow @safe void std.array.Appender!(std.file.DirEntry[]).Appender.put!(std.file.DirEntry).put(std.file.DirEntry)

void* gc.gc.sentinel_add(void*)

void* gc.gc.sentinel_sub(void*)

void gc.gc.sentinel_init(void*, ulong)

void gc.gc.sentinel_Invariant(const(void*))

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

Uses:

• onInvalidMemoryOperationError

void gc.gc.GC.initialize()

Uses:

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

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

Uses:

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

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

ulong gc.gc.GC.fullCollect()

Uses:

• _Unwind_Resume@plt
• ulong gc.gc.Gcx.fullcollect()
• gc.gc.GCMutex gc.gc.GC.gcLock

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

Uses:

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

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

Uses:

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

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

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

Uses:

• memset@plt
• onInvalidMemoryOperationError

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

Used by:

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

Uses:

• abort@plt
• malloc@plt
• free@plt
• int gc.os.os_mem_unmap(void*, ulong)
• onOutOfMemoryError
• ulong gc.gc.Gcx.fullcollect()
• void gc.bits.GCBits.alloc(ulong)
• memset@plt
• void gc.bits.GCBits.Dtor()
• onInvalidMemoryOperationError
• calloc@plt
• void* gc.os.os_mem_map(ulong)
• realloc@plt
• memmove@plt
• gc.gc.Pool.allocPages.MFmZm.part.2

byte[72] gc.gc.GC.mutexStorage

Used by:

• void gc.gc.GC.initialize()

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

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

Used by:

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

Uses:

• ulong gc.bits.GCBits.test(ulong)
• memset@plt
• void gc.bits.GCBits.alloc(ulong)
• onInvalidMemoryOperationError
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• memcpy@plt
• gc.gc.GCMutex gc.gc.GC.gcLock

ulong gc.gc.GC.reserveNoSync(ulong)

Uses:

• malloc@plt
• free@plt
• int gc.os.os_mem_unmap(void*, ulong)
• void gc.bits.GCBits.alloc(ulong)
• memset@plt
• void gc.bits.GCBits.Dtor()
• onOutOfMemoryError
• onInvalidMemoryOperationError
• calloc@plt
• void* gc.os.os_mem_map(ulong)
• realloc@plt
• memmove@plt

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

void gc.gc.GC.fullCollectNoStack()

Uses:

• _Unwind_Resume@plt
• ulong gc.gc.Gcx.fullcollect()
• gc.gc.GCMutex gc.gc.GC.gcLock

void gc.gc.GC.Dtor()

Uses:

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

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

Uses:

• _Unwind_Resume@plt
• onInvalidMemoryOperationError
• gc.gc.GCMutex gc.gc.GC.gcLock

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

• _Unwind_Resume@plt
• 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:

• _Unwind_Resume@plt
• memset@plt
• onInvalidMemoryOperationError
• 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*)
• void gc.gc.GC.minimize()
• ulong gc.gc.GC.extend(void*, ulong, ulong)
• void gc.gc.GC.addRange(void*, ulong)
• void gc.gc.GC.removeRoot(void*)
• void gc.gc.GC.addRoot(void*)
• 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()
• void gc.gc.GC.removeRange(void*)
• gc.gc.BlkInfo gc.gc.GC.query(void*)
• void gc.gc.GC.fullCollectNoStack()
• uint gc.gc.GC.getAttr(void*)
• void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)
• void* gc.gc.GC.calloc(ulong, uint, ulong*)

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

Uses:

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

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

Uses:

• 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
• _Unwind_Resume@plt
• onOutOfMemoryError
• gc.gc.GCMutex gc.gc.GC.gcLock
• memcpy@plt

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

Uses:

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

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

Used by:

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

Uses:

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

void gc.gc.GC.disable()

Uses:

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

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

Uses:

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

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

Used by:

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

Uses:

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

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

Uses:

• _Unwind_Resume@plt
• 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:

• malloc@plt
• free@plt
• int gc.os.os_mem_unmap(void*, ulong)
• _Unwind_Resume@plt
• void gc.bits.GCBits.alloc(ulong)
• memset@plt
• void gc.bits.GCBits.Dtor()
• onOutOfMemoryError
• calloc@plt
• void* gc.os.os_mem_map(ulong)
• realloc@plt
• memmove@plt
• 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()
• _Unwind_Resume@plt
• gc.gc.GCMutex gc.gc.GC.gcLock

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

Used by:

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

Uses:

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

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

Uses:

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

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

Uses:

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

void gc.gc.GC.minimize()

Uses:

• free@plt
• int gc.os.os_mem_unmap(void*, ulong)
• _Unwind_Resume@plt
• void gc.bits.GCBits.Dtor()
• 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*)

Uses:

• abort@plt
• memmove@plt

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

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*)
• ulong gc.gc.GC.fullCollect()
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)

Uses:

• ulong* gc.bits.GCBits.base()
• ulong gc.bits.GCBits.test(ulong)
• thread_processGCMarks
• void gc.gc.Gcx.mark(void*, void*, int)
• thread_suspendAll
• void gc.bits.GCBits.zero()
• void gc.bits.GCBits.set(ulong)
• void gc.bits.GCBits.copy(gc.bits.GCBits*)
• ulong gc.bits.GCBits.testClear(ulong)
• onInvalidMemoryOperationError
• ulong gc.bits.GCBits.testSet(ulong)
• thread_resumeAll
• rt_finalize2
• thread_scanAll

void gc.gc.Gcx.log_collect()

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

Uses:

• memmove@plt

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

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

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

void gc.gc.Gcx.Dtor()

Uses:

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

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

Uses:

• ulong gc.bits.GCBits.test(ulong)
• void gc.gc.Gcx.mark(void*, void*, int)
• ulong gc.bits.GCBits.testSet(ulong)

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

Used by:

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

Uses:

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

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)

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

Uses:

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

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

Uses:

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

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

Uses:

• malloc@plt
• free@plt
• int gc.os.os_mem_unmap(void*, ulong)
• void gc.bits.GCBits.alloc(ulong)
• memset@plt
• onOutOfMemoryError
• void gc.bits.GCBits.Dtor()
• calloc@plt
• void* gc.os.os_mem_map(ulong)
• realloc@plt
• memmove@plt

ulong gc.gc.Gcx.reserve(ulong)

Uses:

• malloc@plt
• free@plt
• int gc.os.os_mem_unmap(void*, ulong)
• void gc.bits.GCBits.alloc(ulong)
• memset@plt
• void gc.bits.GCBits.Dtor()
• onOutOfMemoryError
• calloc@plt
• void* gc.os.os_mem_map(ulong)
• realloc@plt
• memmove@plt

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

Uses:

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

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

Uses:

• abort@plt
• free@plt
• int gc.os.os_mem_unmap(void*, ulong)
• malloc@plt
• ulong gc.gc.Gcx.fullcollect()
• void gc.bits.GCBits.Dtor()
• memset@plt
• void gc.bits.GCBits.alloc(ulong)
• onOutOfMemoryError
• calloc@plt
• void* gc.os.os_mem_map(ulong)
• realloc@plt
• memmove@plt
• gc.gc.Pool.allocPages.MFmZm.part.2

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

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

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

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

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

Uses:

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

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

void gc.gc.Gcx.log_init()

void gc.gc.Gcx.minimize()

Uses:

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

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)

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

ulong gc.gc.Pool.allocPages(ulong)

gc.gc.Pool.allocPages.MFmZm.part.2

Used by:

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

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

Uses:

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

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

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

void gc.gc.Pool.updateOffsets(ulong)

void gc.gc.Pool.Dtor()

Uses:

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

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)

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

Uses:

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

gc.gc.GCMutex.__Class

Used by:

• void gc.gc.GC.initialize()

void gc.gc.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.3654

void* gc.os.os_mem_map(ulong)

Used by:

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

Uses:

• mmap64@plt

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

Used by:

• ulong gc.gc.Gcx.reserve(ulong)
• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)
• ulong gc.gc.GC.reserve(ulong)
• void gc.gc.Gcx.minimize()
• void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)
• void gc.gc.Pool.Dtor()
• void gc.gc.GC.minimize()
• ulong gc.gc.GC.reserveNoSync(ulong)
• void gc.gc.Gcx.Dtor()
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• void gc.gc.GC.Dtor()

Uses:

• munmap@plt

void gc.os.__modinit()

Uses:

• __mod_ref.2064
• _Dmodule_ref

const(void function()) gc.bits.GCBits.__invariant

const(void function()) gc.bits.GCBits.__invariant1

void gc.bits.GCBits.set(ulong)

Used by:

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

void gc.bits.GCBits.Dtor()

Used by:

• ulong gc.gc.Gcx.reserve(ulong)
• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)
• ulong gc.gc.GC.reserve(ulong)
• void gc.gc.Gcx.minimize()
• void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)
• void gc.gc.Pool.Dtor()
• void gc.gc.GC.minimize()
• ulong gc.gc.GC.reserveNoSync(ulong)
• void gc.gc.Gcx.Dtor()
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• void gc.gc.GC.Dtor()

Uses:

• free@plt

ulong* gc.bits.GCBits.base()

Used by:

• ulong gc.gc.Gcx.fullcollect()

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

Used by:

• ulong gc.gc.Gcx.fullcollect()

Uses:

• memcpy@plt

ulong gc.bits.GCBits.test(ulong)

Used by:

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

void gc.bits.GCBits.zero()

Used by:

• ulong gc.gc.Gcx.fullcollect()

Uses:

• memset@plt

void gc.bits.GCBits.alloc(ulong)

Used by:

• uint gc.gc.GC.setAttr(void*, uint).uint go()
• ulong gc.gc.Gcx.reserve(ulong)
• gc.gc.Pool* gc.gc.Gcx.newPool(ulong, bool)
• void gc.gc.Pool.initialize(ulong, bool)
• ulong gc.gc.GC.reserve(ulong)
• void* gc.gc.Gcx.bigAlloc(ulong, gc.gc.Pool**, ulong*)
• ulong gc.gc.GC.reserveNoSync(ulong)
• void* gc.gc.GC.mallocNoSync(ulong, uint, ulong*)
• void* gc.gc.GC.reallocNoSync(void*, ulong, uint, ulong*)
• void gc.gc.Gcx.setBits(gc.gc.Pool*, ulong, uint)

Uses:

• onOutOfMemoryError
• calloc@plt

void gc.bits.GCBits.clear(ulong)

ulong gc.bits.GCBits.testSet(ulong)

Used by:

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

ulong gc.bits.GCBits.testClear(ulong)

Used by:

• ulong gc.gc.Gcx.fullcollect()

void gc.bits.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2157

extern (C) void gc.proxy.gc_clrProxy().int __foreachbody1(ref gc.gc.Range)

Uses:

• gc.proxy.Proxy* gc.proxy.proxy

extern (C) void gc.proxy.gc_clrProxy().int __foreachbody2(ref void*)

Uses:

• gc.proxy.Proxy* gc.proxy.proxy

extern (C) void gc.proxy.gc_setProxy(gc.proxy.Proxy*).int __foreachbody2(ref void*)

Uses:

• gc.proxy.Proxy* gc.proxy.proxy

extern (C) void gc.proxy.gc_setProxy(gc.proxy.Proxy*).int __foreachbody3(ref gc.gc.Range)

Uses:

• gc.proxy.Proxy* gc.proxy.proxy

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_clrProxy
• gc_free
• gc_realloc
• gc_addrOf
• gc_removeRange
• gc_init
• gc_setProxy
• gc_collect
• gc_minimize
• gc_term
• gc_stats
• gc_getAttr
• gc_removeRoot
• gc_addRoot
• gc_addRange

gc.proxy.Proxy* gc.proxy.proxy

Used by:

• extern (C) void gc.proxy.gc_clrProxy().int __foreachbody1(ref gc.gc.Range)
• gc_qalloc
• gc_clrAttr
• extern (C) void gc.proxy.gc_setProxy(gc.proxy.Proxy*).int __foreachbody3(ref gc.gc.Range)
• gc_reserve
• extern (C) void gc.proxy.gc_setProxy(gc.proxy.Proxy*).int __foreachbody2(ref void*)
• gc_query
• gc_enable
• gc_extend
• gc_malloc
• gc_sizeOf
• extern (C) void gc.proxy.gc_clrProxy().int __foreachbody2(ref void*)
• gc_calloc
• gc_disable
• gc_setAttr
• gc_clrProxy
• gc_free
• gc_realloc
• gc_addrOf
• gc_removeRange
• gc_setProxy
• gc_collect
• gc_minimize
• gc_stats
• gc_getAttr
• gc_removeRoot
• gc_addRoot
• gc_addRange

gc.proxy.Proxy gc.proxy.pthis

Used by:

• void gc.proxy.initProxy()

void gc.proxy.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2636

void gc.proxy.initProxy()

Used by:

• gc_init

Uses:

• gc.proxy.Proxy gc.proxy.pthis

pure nothrow @safe ulong rt.aaA.aligntsize(const(ulong))

pure nothrow @trusted rt.aaA.Entry*[] rt.aaA.newBuckets(const(ulong))

Uses:

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

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

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

void rt.aaA.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2771

void rt.adi.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2281

void rt.deh.__modinit()

Uses:

• __mod_ref.2123
• _Dmodule_ref

immutable(int[]) rt.util.utf.UTF8stride

Used by:

• _adReverseChar

ulong rt.util.utf.toUCSindex(const(char[]), ulong)

Uses:

• onUnicodeError

ulong rt.util.utf.toUCSindex(const(wchar[]), ulong)

Uses:

• onUnicodeError

ulong rt.util.utf.toUCSindex(const(dchar[]), ulong)

ulong rt.util.utf.toUTFindex(const(char[]), ulong)

Uses:

• onUnicodeError

ulong rt.util.utf.toUTFindex(const(wchar[]), ulong)

ulong rt.util.utf.toUTFindex(const(dchar[]), ulong)

bool rt.util.utf.isValidDchar(dchar)

void rt.util.utf.validate!(immutable(char)[]).validate(const(immutable(char)[]))

Uses:

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

void rt.util.utf.validate!(immutable(wchar)[]).validate(const(immutable(wchar)[]))

Uses:

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

void rt.util.utf.validate!(immutable(dchar)[]).validate(const(immutable(dchar)[]))

Uses:

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

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

Used by:

• _aApplycd1
• _aApplycw1
• _aApplycd2
• _aApplycw2
• immutable(wchar)[] rt.util.utf.toUTF16(const(char[]))
• immutable(dchar)[] rt.util.utf.toUTF32(const(char[]))
• const(wchar)* rt.util.utf.toUTF16z(const(char[]))
• void rt.util.utf.validate!(immutable(char)[]).validate(const(immutable(char)[]))

Uses:

• onUnicodeError

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

Used by:

• _aApplywd1
• _aApplywc1
• _aApplywd2
• _aApplywc2
• immutable(dchar)[] rt.util.utf.toUTF32(const(wchar[]))
• void rt.util.utf.validate!(immutable(wchar)[]).validate(const(immutable(wchar)[]))

Uses:

• onUnicodeError

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

Used by:

• void rt.util.utf.validate!(immutable(dchar)[]).validate(const(immutable(dchar)[]))

Uses:

• onUnicodeError

void rt.util.utf.encode(ref char[], dchar)

Used by:

• immutable(char)[] rt.util.utf.toUTF8(const(wchar[])).int __foreachbody2(ref dchar)
• immutable(char)[] rt.util.utf.toUTF8(const(dchar[]))

Uses:

• abort@plt
• _d_arrayappendcTX
• _d_arrayappendT

void rt.util.utf.encode(ref wchar[], dchar)

Used by:

• immutable(wchar)[] rt.util.utf.toUTF16(const(dchar[]))
• immutable(wchar)[] rt.util.utf.toUTF16(const(char[]))
• const(wchar)* rt.util.utf.toUTF16z(const(char[]))

Uses:

• _d_arrayappendcTX
• _d_arrayappendT

void rt.util.utf.encode(ref dchar[], dchar)

Uses:

• _d_arrayappendcTX

uint rt.util.utf.stride(const(char[]), ulong)

uint rt.util.utf.stride(const(wchar[]), ulong)

uint rt.util.utf.stride(const(dchar[]), ulong)

immutable(char)[] rt.util.utf.toUTF8(immutable(char)[])

char[] rt.util.utf.toUTF8(out char[4], dchar)

Used by:

• _aApplyRdc1
• _aApplyRwc2
• _aApplywc1
• _aApplyRdc2
• _aApplydc1
• _aApplywc2
• _adSortChar
• _aApplydc2
• _aApplyRwc1

Uses:

• abort@plt

immutable(char)[] rt.util.utf.toUTF8(const(wchar[]))

Uses:

• _d_arraysetlengthiT
• _aApplywd1

immutable(char)[] rt.util.utf.toUTF8(const(wchar[])).int __foreachbody2(ref dchar)

Uses:

• void rt.util.utf.encode(ref char[], dchar)

immutable(char)[] rt.util.utf.toUTF8(const(dchar[]))

Uses:

• _d_arraysetlengthiT
• void rt.util.utf.encode(ref char[], dchar)

immutable(wchar)[] rt.util.utf.toUTF16(immutable(wchar)[])

wchar[] rt.util.utf.toUTF16(wchar[2], dchar)

Used by:

• _adSortWchar

immutable(wchar)[] rt.util.utf.toUTF16(const(char[]))

Uses:

• _d_arraysetlengthiT
• void rt.util.utf.encode(ref wchar[], dchar)
• _d_arrayappendcTX
• dchar rt.util.utf.decode(const(char[]), ref ulong)

immutable(wchar)[] rt.util.utf.toUTF16(const(dchar[]))

Uses:

• _d_arraysetlengthiT
• void rt.util.utf.encode(ref wchar[], dchar)

immutable(dchar)[] rt.util.utf.toUTF32(immutable(dchar)[])

immutable(dchar)[] rt.util.utf.toUTF32(const(char[]))

Used by:

• _adSortChar

Uses:

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

immutable(dchar)[] rt.util.utf.toUTF32(const(wchar[]))

Used by:

• _adSortWchar

Uses:

• _d_arraysetlengthiT
• dchar rt.util.utf.decode(const(wchar[]), ref ulong)

const(wchar)* rt.util.utf.toUTF16z(const(char[]))

Uses:

• _d_arraysetlengthiT
• void rt.util.utf.encode(ref wchar[], dchar)
• _d_arrayappendcTX
• dchar rt.util.utf.decode(const(char[]), ref ulong)

void rt.util.utf.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2665

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

Used by:

• const(pure nothrow @safe ulong function(const(void*))) object.TypeInfo_Struct.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ashort.TypeInfo_As.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_ulong.TypeInfo_m.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Along.TypeInfo_Al.getHash
• const(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*))) object.TypeInfo_Array.getHash
• _aaGetHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Ag.TypeInfo_Ag.getHash
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Aint.TypeInfo_Ai.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_long.TypeInfo_l.getHash
• const(pure nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_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
• const(nothrow @trusted ulong function(const(void*))) rt.typeinfo.ti_Afloat.TypeInfo_Af.getHash

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

void rt.util.hash.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2011

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

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

Used by:

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

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

Used by:

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

Uses:

• memcmp@plt

void rt.util.string.__modinit()

Uses:

• __mod_ref.2020
• _Dmodule_ref

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

Used by:

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

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• pure nothrow @trusted char[] rt.util.string.uintToString(char[], ulong)

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

Used by:

• void rt.dmain2.printThrowable(object.Throwable).void printMsgLine(object.Throwable)
• void rt.dmain2.printThrowable(object.Throwable).void printInfoBlock(object.Throwable)
• void rt.dmain2.printThrowable(object.Throwable)
• rt.util.console.Console rt.util.console.Console.opCall(ulong)
• void rt.dmain2.printThrowable(object.Throwable).void printLocLine(object.Throwable)
• void rt.dmain2.printThrowable(object.Throwable).void printInfoBlock(object.Throwable).int __foreachbody2(ref const(char[]))

Uses:

• write@plt

void rt.util.console.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2143

void rt.cast_.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2128

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

Uses:

• _adEq2

void rt.minfo.ModuleGroup.runTlsCtors()

Uses:

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

void rt.minfo.ModuleGroup.runTlsCtors().pure nothrow void function()* __lambda1!(object.ModuleInfo*).__lambda1(object.ModuleInfo*)

Uses:

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

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

Used by:

• void rt.minfo.ModuleGroup.runTlsCtors()
• rt_moduleTlsCtor

Uses:

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

void rt.minfo.ModuleGroup.runTlsDtors()

Uses:

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

void rt.minfo.ModuleGroup.runTlsDtors().pure nothrow void function()* __lambda1!(object.ModuleInfo*).__lambda1(object.ModuleInfo*)

Uses:

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

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

Used by:

• rt_moduleTlsDtor
• void rt.minfo.ModuleGroup.runTlsDtors()

Uses:

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

void rt.minfo.ModuleGroup.free()

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

Uses:

• void rt.minfo.ModuleGroup.runCtors().pure void __T14runModuleFuncsS452rt5minfo11ModuleGroup8runCtorsMFZv9__lambda1Z.runModuleFuncs(object.ModuleInfo*[])
• pure nothrow @property uint object.ModuleInfo.flags()
• pure nothrow @property void object.ModuleInfo.flags(uint)
• void rt.minfo.ModuleGroup.runCtors().pure void __T14runModuleFuncsS452rt5minfo11ModuleGroup8runCtorsMFZv9__lambda2Z.runModuleFuncs(object.ModuleInfo*[])

void rt.minfo.ModuleGroup.runCtors().pure nothrow void function()* __lambda1!(object.ModuleInfo*).__lambda1(object.ModuleInfo*)

Uses:

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

void rt.minfo.ModuleGroup.runCtors().pure nothrow void function()* __lambda2!(object.ModuleInfo*).__lambda2(object.ModuleInfo*)

Uses:

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

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

Used by:

• rt_moduleCtor
• void rt.minfo.ModuleGroup.runCtors()

Uses:

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

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

Used by:

• rt_moduleCtor
• void rt.minfo.ModuleGroup.runCtors()

Uses:

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

void rt.minfo.ModuleGroup.runDtors()

Uses:

• void rt.minfo.ModuleGroup.runDtors().pure void __T17runModuleFuncsRevS452rt5minfo11ModuleGroup8runDtorsMFZv9__lambda1Z.runModuleFuncsRev(object.ModuleInfo*[])
• pure nothrow @property uint object.ModuleInfo.flags()
• pure nothrow @property void object.ModuleInfo.flags(uint)

void rt.minfo.ModuleGroup.runDtors().pure nothrow void function()* __lambda1!(object.ModuleInfo*).__lambda1(object.ModuleInfo*)

Uses:

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

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

Used by:

• void rt.minfo.ModuleGroup.runDtors()
• rt_moduleDtor

Uses:

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

void rt.minfo.ModuleGroup.sortCtors()

Uses:

• free@plt
• abort@plt
• _Unwind_Resume@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:

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

Uses:

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

rt.minfo.ModuleGroup.sortCtors.MFZv8StackRec11__xopEqualsFKxS2rt5minfo11ModuleGroup9sortCtorsMFZv8StackRecKxS2rt5minfo11ModuleGroup9sortCtorsMFZv8StackRecZb

Uses:

• _adEq2

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

rt.minfo.ModuleGroup rt.minfo._moduleGroup

Used by:

• int rt.minfo.moduleinfos_apply(scope int delegate(ref object.ModuleInfo*))
• rt_moduleDtor
• rt_moduleCtor
• rt_moduleTlsDtor
• rt_moduleTlsCtor

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

Used by:

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

Uses:

• rt.minfo.ModuleGroup rt.minfo._moduleGroup

void rt.minfo.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2551

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

void rt.qsort.__modinit()

Uses:

• __mod_ref.2039
• _Dmodule_ref

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

Used by:

• thread_processGCMarks

Uses:

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

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

Used by:

• thread_attachThis
• thread_entryPoint

Uses:

• malloc@plt

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

Used by:

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

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

Used by:

• void core.thread.Thread.__dtor()

Uses:

• free@plt

void rt.tlsgc.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2131

void rt.aApply.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2278

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
• rt_term
• extern (C) int rt.dmain2._d_run_main(int, char**, extern (C) int function(char[][])*).void tryExec(scope void delegate())
• 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:

• _Unwind_Resume@plt
• _d_dynamic_cast
• void rt.dmain2.printThrowable(object.Throwable)

void rt.dmain2.printThrowable(object.Throwable)

Used by:

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

Uses:

• rt.util.console.Console rt.util.console.Console.opCall(const(char[]))
• void rt.dmain2.printThrowable(object.Throwable).void printMsgLine(object.Throwable)
• void rt.dmain2.printThrowable(object.Throwable).void printInfoBlock(object.Throwable)
• _d_dynamic_cast
• void rt.dmain2.printThrowable(object.Throwable).void printLocLine(object.Throwable)

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

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

Used by:

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

Uses:

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

void rt.dmain2.printThrowable(object.Throwable).void printInfoBlock(object.Throwable).int __foreachbody2(ref const(char[]))

Uses:

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

rt.dmain2.CArgs rt.dmain2._cArgs

Used by:

• rt_cArgs
• _d_run_main

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

Used by:

• rt_args
• _d_run_main

void rt.dmain2.__modinit()

Uses:

• __mod_ref.2406
• _Dmodule_ref

void rt.memory.initStaticDataGC()

Used by:

• rt_init

Uses:

• nothrow void core.memory.GC.addRange(const(void*), ulong)

void rt.memory.__modinit()

Uses:

• __mod_ref.1999
• _Dmodule_ref

void rt.aApplyR.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2264

void rt.switch_.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2070

void rt.arraycat.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2137

pure nothrow @safe ulong rt.lifetime.__arrayPad(ulong)

nothrow @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()

Used by:

• nothrow rt.lifetime.BlkInfo* rt.lifetime.__getBlkInfo(void*)
• nothrow void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)

Uses:

• malloc@plt

ulong rt.lifetime.newCapacity(ulong, ulong)

pure nothrow void* rt.lifetime.__arrayStart(rt.lifetime.BlkInfo)

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

Used by:

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

Uses:

• _d_dynamic_cast

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

Used by:

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

Uses:

• nothrow @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()

void rt.lifetime._staticDtor1()

Uses:

• free@plt

bool function(Object)* rt.lifetime.collectHandler

Used by:

• rt_setCollectHandler
• rt_getCollectHandler
• rt_finalize2

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

Used by:

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

nothrow void rt.lifetime.__insertBlkInfoCache(rt.lifetime.BlkInfo, rt.lifetime.BlkInfo*)

Used by:

• _d_arraysetlengthiT
• _d_arraysetcapacity
• _d_arrayappendcTX
• _d_arraysetlengthT

Uses:

• nothrow @property rt.lifetime.BlkInfo* rt.lifetime.__blkcache()

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

Used by:

• _d_arraysetlengthiT
• _d_arrayliteralTX
• _d_arrayshrinkfit
• _d_arraysetcapacity
• _d_newarrayT
• _d_arraycatT
• _d_arraycatnT
• void[] rt.lifetime._d_newarrayOpT!(_d_newarrayT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*).void[] foo(const(TypeInfo), ulong*, ulong)
• _d_newarrayiT
• _d_arrayappendcTX
• void[] rt.lifetime._d_newarrayOpT!(_d_newarrayiT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*).void[] foo(const(TypeInfo), ulong*, ulong)
• _d_arraysetlengthT
• _adDupT

Uses:

• _d_monitorenter
• _d_monitorexit

void[] rt.lifetime._d_newarrayOpT!(_d_newarrayT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*)

Uses:

• void[] rt.lifetime._d_newarrayOpT!(_d_newarrayT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*).void[] foo(const(TypeInfo), ulong*, ulong)

void[] rt.lifetime._d_newarrayOpT!(_d_newarrayT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*).void[] foo(const(TypeInfo), ulong*, ulong)

Used by:

• _d_newarraymTX
• void[] rt.lifetime._d_newarrayOpT!(_d_newarrayT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*)

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• _d_newarrayT
• gc_qalloc

void[] rt.lifetime._d_newarrayOpT!(_d_newarrayiT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*)

Uses:

• void[] rt.lifetime._d_newarrayOpT!(_d_newarrayiT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*).void[] foo(const(TypeInfo), ulong*, ulong)

void[] rt.lifetime._d_newarrayOpT!(_d_newarrayiT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*).void[] foo(const(TypeInfo), ulong*, ulong)

Used by:

• void[] rt.lifetime._d_newarrayOpT!(_d_newarrayiT)._d_newarrayOpT(const(TypeInfo), ulong, ulong*)
• _d_newarraymiTX

Uses:

• bool rt.lifetime.__setArrayAllocLength(ref rt.lifetime.BlkInfo, ulong, bool, ulong)
• _d_newarrayiT
• gc_qalloc

void rt.lifetime.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2958

rt.monitor_.Monitor* rt.monitor_.getMonitor(Object)

void rt.monitor_.setMonitor(Object, rt.monitor_.Monitor*)

int rt.monitor_.inited

Used by:

• _STI_monitor_staticctor
• _STD_monitor_staticdtor

bool rt.monitor_.Monitor.__xopEquals(ref const(rt.monitor_.Monitor), ref const(rt.monitor_.Monitor))

Uses:

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

void rt.monitor_.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2331

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

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)

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

void rt.typeinfo.ti_cdouble.__modinit()

Uses:

• __mod_ref.2138
• _Dmodule_ref

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

void rt.typeinfo.ti_idouble.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2095

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

void rt.typeinfo.ti_C.__modinit()

Uses:

• __mod_ref.2112
• _Dmodule_ref

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

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

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

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

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

Uses:

• bool object.TypeInfo.opEquals(Object)

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

Uses:

• const(immutable(char)[] function()) object.TypeInfo.toString

void rt.typeinfo.ti_AC.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2160

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

void rt.typeinfo.ti_Ag.__modinit()

Uses:

• __mod_ref.2505
• _Dmodule_ref

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

void rt.typeinfo.ti_int.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2106

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

void rt.typeinfo.ti_Aint.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2270

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

void rt.typeinfo.ti_byte.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2106

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

void rt.typeinfo.ti_char.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2110

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

void rt.typeinfo.ti_long.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2111

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

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)

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

void rt.typeinfo.ti_real.__modinit()

Uses:

• __mod_ref.2130
• _Dmodule_ref

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

void rt.typeinfo.ti_uint.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2106

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

Uses:

• abort@plt

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

void rt.typeinfo.ti_void.__modinit()

Uses:

• __mod_ref.2109
• _Dmodule_ref

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

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

Uses:

• memcmp@plt

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

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

Uses:

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

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

Uses:

• bool object.TypeInfo.opEquals(Object)

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

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

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

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

void rt.typeinfo.ti_Along.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2213

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

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)

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

void rt.typeinfo.ti_creal.__modinit()

Uses:

• __mod_ref.2138
• _Dmodule_ref

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

void rt.typeinfo.ti_dchar.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2117

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)

Used by:

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

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

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

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

Used by:

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

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

void rt.typeinfo.ti_float.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2125

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

void rt.typeinfo.ti_ireal.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2095

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

void rt.typeinfo.ti_short.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2106

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

void rt.typeinfo.ti_ubyte.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2153

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

void rt.typeinfo.ti_ulong.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2111

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

void rt.typeinfo.ti_wchar.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2117

rt.typeinfo.ti_Afloat.TypeInfo_Af.nextinout(pure nothrow @property inout(TypeInfo) function())

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

• bool object.TypeInfo.opEquals(Object)

const(immutable(char)[] function()) rt.typeinfo.ti_Afloat.TypeInfo_Af.toString

rt.typeinfo.ti_Afloat.TypeInfo_Ao.nextinout(pure nothrow @property inout(TypeInfo) function())

const(immutable(char)[] function()) rt.typeinfo.ti_Afloat.TypeInfo_Ao.toString

void rt.typeinfo.ti_Afloat.__modinit()

Uses:

• __mod_ref.2215
• _Dmodule_ref

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

void rt.typeinfo.ti_Ashort.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2270

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

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)

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

void rt.typeinfo.ti_cfloat.__modinit()

Uses:

• __mod_ref.2138
• _Dmodule_ref

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

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)

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

void rt.typeinfo.ti_double.__modinit()

Uses:

• __mod_ref.2130
• _Dmodule_ref

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

void rt.typeinfo.ti_ifloat.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2094

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.typeinfo.ti_ushort.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2106

void rt.arraycast.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2111

rt.critical_.critsec_t* rt.critical_.dcs_list

Used by:

• _STD_critical_term
• _STI_critical_init
• _d_criticalenter

void rt.critical_.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2220

TypeInfo_S3std4file15DirIteratorImpl.__init

Used by:

• ref std.file.DirIterator std.file.DirIterator.opAssign(std.file.DirIterator)
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult250__T6filterS235_D3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult1fMFS3std4file8DirEntryZbZ35__T6filterTS3std4file11DirIteratorZ6filterMFS3std4file11DirIteratorZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult
• std.typecons.RefCounted.TS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.opAssign.MFS3std4file15DirIteratorImplZv
• void object.destroy!(std.file.DirIteratorImpl).destroy(ref std.file.DirIteratorImpl)
• void std.file.DirIterator.__fieldDtor()
• void std.file.rmdirRecurse(ref std.file.DirEntry)
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult11__fieldDtorMFZv
• std.typecons.RefCounted.TS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.__dtor.MFZv
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult8opAssignMFNcS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResultZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult
• std.typecons.RefCounted.TS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z.RefCounted.opAssign.MFS3std8typecons86__T10RefCountedTS3std4file15DirIteratorImplVE3std8typecons24RefCountedAutoInitialize0Z10RefCountedZv
• void std.algorithm.move!(std.file.DirIteratorImpl).move(ref std.file.DirIteratorImpl, ref std.file.DirIteratorImpl)
• std.file.dirEntries.FAyaAyaE3std4file8SpanModebZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult6__ctorMFNcS3std4file11DirIteratorZS3std4file10dirEntriesFAyaAyaE3std4file8SpanModebZ93__T12FilterResultS48_D3std4file10dirEntries1fMFS3std4file8DirEntryZbTS3std4file11DirIteratorZ12FilterResult

TypeInfo_AS3std3uni17CodepointInterval.__init

Used by:

• pure nothrow @safe void std.array.Appender!(std.uni.CodepointInterval[]).Appender.ensureAddable(ulong).nothrow @trusted core.memory.BlkInfo_ __lambda5()
• pure nothrow @safe void std.array.Appender!(std.uni.CodepointInterval[]).Appender.ensureAddable(ulong)

void gcc.deh.__gdc_terminate()

Uses:

• abort@plt

ubyte* gcc.deh.parse_lsda_header(gcc.unwind.generic._Unwind_Context*, ubyte*, gcc.deh.lsda_header_info*)

Used by:

• uint gcc.deh.__gdc_personality_impl(int, int, bool, gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*)

Uses:

• ubyte* gcc.unwind.pe.read_encoded_value(gcc.unwind.generic._Unwind_Context*, ubyte, ubyte*, ulong*)
• _Unwind_GetRegionStart@plt
• ubyte* gcc.unwind.pe.read_uleb128(ubyte*, ulong*)

bool gcc.deh.d_exception_header.__xopEquals(ref const(gcc.deh.d_exception_header), ref const(gcc.deh.d_exception_header))

Uses:

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

TypeInfo_Class gcc.deh.get_classinfo_entry(gcc.deh.lsda_header_info*, ulong)

Used by:

• uint gcc.deh.__gdc_personality_impl(int, int, bool, gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*)

Uses:

• uint gcc.unwind.pe.size_of_encoded_value(ubyte)
• ubyte* gcc.unwind.pe.read_encoded_value_with_base(ubyte, ulong, ubyte*, ulong*)

void gcc.deh.save_caught_exception(gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*, int, ubyte*, ulong, ubyte*)

uint gcc.deh.__gdc_personality_impl(int, int, bool, gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*)

Used by:

• __gdc_personality_v0

Uses:

• ubyte* gcc.deh.parse_lsda_header(gcc.unwind.generic._Unwind_Context*, ubyte*, gcc.deh.lsda_header_info*)
• _Unwind_GetIPInfo@plt
• ubyte* gcc.unwind.pe.read_encoded_value(gcc.unwind.generic._Unwind_Context*, ubyte, ubyte*, ulong*)
• _d_isbaseof
• abort@plt
• _Unwind_SetGR@plt
• _Unwind_SetIP@plt
• TypeInfo_Class gcc.deh.get_classinfo_entry(gcc.deh.lsda_header_info*, ulong)
• ubyte* gcc.unwind.pe.read_sleb128(ubyte*, long*)
• _Unwind_GetLanguageSpecificData@plt
• ulong gcc.unwind.pe.base_of_encoded_value(ubyte, gcc.unwind.generic._Unwind_Context*)
• ubyte* gcc.unwind.pe.read_uleb128(ubyte*, ulong*)

void gcc.deh.restore_caught_exception(gcc.unwind.generic._Unwind_Exception*, ref int, ref ubyte*, ref ulong)

gcc.deh.d_exception_header* gcc.deh.get_exception_header_from_ue(gcc.unwind.generic._Unwind_Exception*)

void gcc.deh.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2368

ubyte* gcc.unwind.pe.read_sleb128(ubyte*, long*)

Used by:

• uint gcc.deh.__gdc_personality_impl(int, int, bool, gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*)
• ubyte* gcc.unwind.pe.read_encoded_value_with_base(ubyte, ulong, ubyte*, ulong*)

ubyte* gcc.unwind.pe.read_uleb128(ubyte*, ulong*)

Used by:

• ubyte* gcc.deh.parse_lsda_header(gcc.unwind.generic._Unwind_Context*, ubyte*, gcc.deh.lsda_header_info*)
• uint gcc.deh.__gdc_personality_impl(int, int, bool, gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*)

ubyte* gcc.unwind.pe.read_encoded_value(gcc.unwind.generic._Unwind_Context*, ubyte, ubyte*, ulong*)

Used by:

• ubyte* gcc.deh.parse_lsda_header(gcc.unwind.generic._Unwind_Context*, ubyte*, gcc.deh.lsda_header_info*)
• uint gcc.deh.__gdc_personality_impl(int, int, bool, gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*)

Uses:

• ulong gcc.unwind.pe.base_of_encoded_value(ubyte, gcc.unwind.generic._Unwind_Context*)
• ubyte* gcc.unwind.pe.read_encoded_value_with_base(ubyte, ulong, ubyte*, ulong*)

ulong gcc.unwind.pe.base_of_encoded_value(ubyte, gcc.unwind.generic._Unwind_Context*)

Used by:

• ubyte* gcc.unwind.pe.read_encoded_value(gcc.unwind.generic._Unwind_Context*, ubyte, ubyte*, ulong*)
• uint gcc.deh.__gdc_personality_impl(int, int, bool, gcc.unwind.generic._Unwind_Exception*, gcc.unwind.generic._Unwind_Context*)

Uses:

• abort@plt
• _Unwind_GetDataRelBase@plt
• _Unwind_GetTextRelBase@plt
• _Unwind_GetRegionStart@plt

uint gcc.unwind.pe.size_of_encoded_value(ubyte)

Used by:

• TypeInfo_Class gcc.deh.get_classinfo_entry(gcc.deh.lsda_header_info*, ulong)

Uses:

• abort@plt

ubyte* gcc.unwind.pe.read_encoded_value_with_base(ubyte, ulong, ubyte*, ulong*)

Used by:

• ubyte* gcc.unwind.pe.read_encoded_value(gcc.unwind.generic._Unwind_Context*, ubyte, ubyte*, ulong*)
• TypeInfo_Class gcc.deh.get_classinfo_entry(gcc.deh.lsda_header_info*, ulong)

Uses:

• abort@plt
• ubyte* gcc.unwind.pe.read_sleb128(ubyte*, long*)

void gcc.unwind.pe.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2180

pure nothrow bool gcc.atomics.__sync_bool_compare_and_swap!(ulong).__sync_bool_compare_and_swap(shared(ulong)*, const(ulong), const(ulong))

gcc.builtins.__va_list_tag.__init

Used by:

• _d_arraycatnT

void gcc.builtins.__modinit()

Uses:

• __mod_ref.2064
• _Dmodule_ref

void gcc.gthreads.posix.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2182

char[] gcc.backtrace.formatLine(const(gcc.backtrace.SymbolInfo), ref char[512])

Used by:

• const(int function(scope int delegate(ref ulong, ref const(char[])))) gcc.backtrace.LibBacktrace.opApply.int __lambda2(ref ulong, ref gcc.backtrace.SymbolOrError)

Uses:

• snprintf@plt
• strlen@plt
• char[] core.demangle.demangle(const(char)[], char[])

void gcc.backtrace.LibBacktrace.initLibBacktrace()

Uses:

• backtrace_create_state

gcc.backtrace.LibBacktrace gcc.backtrace.LibBacktrace.__ctor(int)

Used by:

• object.Throwable.TraceInfo core.runtime.defaultTraceHandler(void*)
• extern (C) bool core.runtime.runModuleUnitTests().extern (C) void unittestSegvHandler(int, core.sys.posix.signal.siginfo_t*, void*)

Uses:

• backtrace_simple
• backtrace_create_state

gcc.backtrace.LibBacktrace.__Class

Used by:

• extern (C) bool core.runtime.runModuleUnitTests().extern (C) void unittestSegvHandler(int, core.sys.posix.signal.siginfo_t*, void*)

const(int function(int delegate(ref ulong, ref gcc.backtrace.SymbolOrError))) gcc.backtrace.LibBacktrace.opApply

Uses:

• backtrace_syminfo
• backtrace_pcinfo

const(int function(scope int delegate(ref ulong, ref const(char[])))) gcc.backtrace.LibBacktrace.opApply

Used by:

• _DT1184_D3gcc9backtrace12LibBacktrace7opApplyMxFMDFKmKxAaZiZi

Uses:

• _d_allocmemory

const(int function(scope int delegate(ref ulong, ref const(char[])))) gcc.backtrace.LibBacktrace.opApply.int __lambda2(ref ulong, ref gcc.backtrace.SymbolOrError)

Uses:

• snprintf@plt
• char[] gcc.backtrace.formatLine(const(gcc.backtrace.SymbolInfo), ref char[512])

const(int function(scope int delegate(ref const(char[])))) gcc.backtrace.LibBacktrace.opApply

Used by:

• _DT1184_D3gcc9backtrace12LibBacktrace7opApplyMxFMDFKxAaZiZi

const(int function(scope int delegate(ref const(char[])))) gcc.backtrace.LibBacktrace.opApply.int __lambda2!(ulong).__lambda2(ref ulong, ref const(char[]))

const(immutable(char)[] function()) gcc.backtrace.LibBacktrace.toString

Used by:

• _DT1184_D3gcc9backtrace12LibBacktrace8toStringMxFZAya

const(immutable(char)[] function()) gcc.backtrace.LibBacktrace.toString.@safe int __foreachbody1(ref ulong, ref const(char[]))

Uses:

• _d_arraycatT
• _d_arrayappendT

void gcc.backtrace.SymbolCallbackInfo.reset()

void gcc.backtrace.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.2582

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

pure nothrow @safe uint std.functional.unaryFun!("a[1]").unaryFun!(std.uni.CodepointInterval).unaryFun(std.uni.CodepointInterval)

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

pure nothrow @safe immutable(dchar) std.functional.unaryFun!("a.rhs").unaryFun!(immutable(std.internal.unicode_tables.CompEntry)).unaryFun(immutable(std.internal.unicode_tables.CompEntry))

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

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

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

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

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

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

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

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

Uses:

• _adCmp2

pure nothrow @safe immutable(char[]) std.functional.unaryFun!("a.name").unaryFun!(immutable(std.internal.unicode_tables.UnicodeProperty)).unaryFun(immutable(std.internal.unicode_tables.UnicodeProperty))

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

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

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

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:

• std.algorithm.splitter.TAyaTaZ.splitter.FAyaaZS3std9algorithm19__T8splitterTAyaTaZ8splitterFAyaaZ6Result6Result11lastIndexOfFAyaaZm
• std.algorithm.find.VAyaa6_61203d3d2062TS3std5range14__T5retroTAyaZ5retroFAyaZ11__T6ResultZ6ResultTaZ.find.FNaNfS3std5range14__T5retroTAyaZ5retroFAyaZ11__T6ResultZ6ResultaZS3std5range14__T5retroTAyaZ5retroFAyaZ11__T6ResultZ6Result
• std.algorithm.splitter.TAyaTaZ.splitter.FAyaaZS3std9algorithm19__T8splitterTAyaTaZ8splitterFAyaaZ6Result6Result4backMFNdZAya

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

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

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

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

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

Uses:

• memcmp@plt

pure nothrow @safe bool std.functional.unaryFun!("a[0] > 0x80").unaryFun!(std.uni.CodepointInterval).unaryFun(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)

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

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

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

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

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

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

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

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

void std.functional.__modinit()

Uses:

• _Dmodule_ref
• __mod_ref.6511

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).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, ubyte).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, ubyte).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(ubyte, 8uL).PackedPtrImpl) function())

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.slice!(2uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(ubyte)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(0uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(ubyte)
• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(1uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(2uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(2uL).length

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).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, ubyte).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, ubyte).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.__ctor

Uses:

• _d_arraycopy

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

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.slice!(2uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(ushort)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(0uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(ushort)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(1uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(2uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(2uL).length

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.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.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.__ctor

Uses:

• _d_arraycopy

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.slice!(2uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.__ctor(ushort)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(0uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.__ctor(ushort)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(1uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(2uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(2uL).length

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).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, 16uL).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, 16uL).BitPacked, ushort).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.__ctor

Uses:

• _d_arraycopy

pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(char).toCaseInPlaceAlloc(ref char[], ulong, ulong)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, char).toCaseInPlace(ref char[])

Uses:

• pure nothrow @trusted ushort std.uni.toLowerIndex(dchar)
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toLowerTable()
• _d_newarrayiT
• pure @trusted ulong std.uni.encodeTo(char[], ulong, dchar)
• pure ulong std.uni.toCaseLength!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseLength!(char).toCaseLength(const(char[]))
• memcpy@plt

pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(wchar).toCaseInPlaceAlloc(ref wchar[], ulong, ulong)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])

Uses:

• pure nothrow @trusted ushort std.uni.toLowerIndex(dchar)
• _d_throw
• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toLowerTable()
• _d_newarrayiT
• pure @trusted ulong std.uni.encodeTo(wchar[], ulong, dchar)
• pure ulong std.uni.toCaseLength!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseLength!(wchar).toCaseLength(const(wchar[]))
• memcpy@plt
• pure dchar std.utf.decodeImpl!(true, wchar[]).decodeImpl(ref wchar[], ref ulong).std.utf.UTFException exception(immutable(char)[])

pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(dchar).toCaseInPlaceAlloc(ref dchar[], ulong, ulong)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])

Uses:

• pure nothrow @trusted ushort std.uni.toLowerIndex(dchar)
• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• pure nothrow @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw
• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toLowerTable()
• _d_newarrayiT
• _d_newclass
• pure ulong std.uni.toCaseLength!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseLength!(dchar).toCaseLength(const(dchar[]))
• memcpy@plt

pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(char).toCaseInPlaceAlloc(ref char[], ulong, ulong)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, char).toCaseInPlace(ref char[])

Uses:

• pure ulong std.uni.toCaseLength!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseLength!(char).toCaseLength(const(char[]))
• pure dchar std.utf.decodeImpl!(true, char[]).decodeImpl(ref char[], ref ulong)
• _d_newarrayiT
• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toUpperTable()
• pure @trusted ulong std.uni.encodeTo(char[], ulong, dchar)
• memcpy@plt
• pure nothrow @trusted ushort std.uni.toUpperIndex(dchar)

pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(wchar).toCaseInPlaceAlloc(ref wchar[], ulong, ulong)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])

Uses:

• pure ulong std.uni.toCaseLength!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseLength!(wchar).toCaseLength(const(wchar[]))
• _d_throw
• _d_newarrayiT
• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toUpperTable()
• pure @trusted ulong std.uni.encodeTo(wchar[], ulong, dchar)
• memcpy@plt
• pure nothrow @trusted ushort std.uni.toUpperIndex(dchar)
• pure dchar std.utf.decodeImpl!(true, wchar[]).decodeImpl(ref wchar[], ref ulong).std.utf.UTFException exception(immutable(char)[])

pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(dchar).toCaseInPlaceAlloc(ref dchar[], ulong, ulong)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])

Uses:

• pure ulong std.uni.toCaseLength!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseLength!(dchar).toCaseLength(const(dchar[]))
• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• pure nothrow @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw
• _d_newarrayiT
• _d_newclass
• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toUpperTable()
• memcpy@plt
• pure nothrow @trusted ushort std.uni.toUpperIndex(dchar)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).mapTrieIndex!(int).mapTrieIndex(int)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).mapTrieIndex!(dchar).mapTrieIndex(dchar)

pure nothrow ref @trusted std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray)

const(pure nothrow ref @trusted const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__ctor!().__ctor

Used by:

• pure nothrow const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) std.uni.asTrie!(ushort, 12, 9).asTrie(const(std.internal.unicode_tables.TrieEntry!(ushort, 12, 9).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__xopEquals(ref const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie), ref const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie))

Uses:

• memcmp@plt

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

pure nothrow @safe void std.uni.compressTo(uint, ref ubyte[])

Uses:

• _d_arrayappendcTX

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

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

Uses:

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

pure nothrow bool std.uni.isUniLower(dchar)

Uses:

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

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

Uses:

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

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.nfkcQCTrie()

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.nfkdQCTrie()

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!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie) std.uni.numberTrie()

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

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.symbolTrie()

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

Used by:

• pure @trusted const(char)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, const(char)[]).toCase(const(char)[]).@safe int __foreachbody2(ref ulong, ref dchar).@safe int __foreachbody3(ref dchar)

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

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

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

Uses:

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

pure nothrow @trusted ulong std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37

@trusted bool std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(1uL, ushort).addValue(ushort, ulong)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37

std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37

Used by:

• pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putValue(dchar, ushort)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putAt(ulong, ushort)
• pure nothrow @trusted std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.build()
• pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(1uL, ushort).addValue(ushort, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ushort)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSliceAssign(ushort, ulong, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Uses:

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

pure nothrow @trusted std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putAt(ulong, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37

pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.__ctor(ushort)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)
• _d_newarrayT
• _d_arraysetlengthT

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)
• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putValue(dchar, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putValue(dchar, ushort).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

@safe bool std.uni.findSetName!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))

Uses:

• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))

@trusted dchar std.uni.composeJamo(dchar, dchar, dchar)

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:

• 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 @safe bool std.uni.isSurrogate(dchar)

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

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

Uses:

• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toTitleTable()
• pure nothrow @trusted ushort std.uni.toTitleIndex(dchar)

@safe bool std.uni.findSetName!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))

Used by:

• @safe bool std.uni.unicode.findAny(immutable(char)[])

Uses:

• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))

@safe bool std.uni.findSetName!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))

Used by:

• @safe bool std.uni.unicode.findAny(immutable(char)[])

Uses:

• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))

Used by:

• @safe bool std.uni.unicode.findAny(immutable(char)[])
• @safe bool std.uni.findSetName!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))

Uses:

• @property @safe immutable(std.internal.unicode_tables.UnicodeProperty)[] std.internal.unicode_tables.blocks.tab()
• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(const(char)[], immutable(char)[]).__lambda2(const(char)[], immutable(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(immutable(char)[], const(char)[]).__lambda2(immutable(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange11__xopEqualsFKxS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRangeKxS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRangeZb

Uses:

• _adEq2

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.geq!(immutable(char)[], const(char)[]).geq(immutable(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange47__T10lowerBoundVE3std5range12SearchPolicy2TAxaZ10lowerBoundMFNaAxaZS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.back()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange4saveMFNaNbNdNfZS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange576__T18getTransitionIndexVE3std5range12SearchPolicy2S5173std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange3geqTAxaZ18getTransitionIndexMFNaAxaZm

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.empty()

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.internal.unicode_tables.UnicodeProperty).empty(const(std.internal.unicode_tables.UnicodeProperty[]))

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.front()

Uses:

• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.front.MFNaNbNdNfZyAa.part.23

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange6__ctorMFNaNbNcNfS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe ulong __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.length()

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.opIndex(ulong)

Uses:

• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange7opSliceMFNaNbNfmmZS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

Uses:

• _d_array_bounds
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe void __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.popBack()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange7releaseMFNaNbZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe void __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.popFront()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T12assumeSortedS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2TS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZ12assumeSortedMFNaNbNfS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))

Used by:

• @safe bool std.uni.findSetName!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24
• @property @safe immutable(std.internal.unicode_tables.UnicodeProperty)[] std.internal.unicode_tables.scripts.tab()
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(const(char)[], immutable(char)[]).__lambda2(const(char)[], immutable(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(immutable(char)[], const(char)[]).__lambda2(immutable(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange11__xopEqualsFKxS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRangeKxS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRangeZb

Uses:

• _adEq2

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.geq!(immutable(char)[], const(char)[]).geq(immutable(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange47__T10lowerBoundVE3std5range12SearchPolicy2TAxaZ10lowerBoundMFNaAxaZS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.back()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange4saveMFNaNbNdNfZS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange578__T18getTransitionIndexVE3std5range12SearchPolicy2S5193std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange3geqTAxaZ18getTransitionIndexMFNaAxaZm

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.empty()

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.internal.unicode_tables.UnicodeProperty).empty(const(std.internal.unicode_tables.UnicodeProperty[]))

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.front()

Uses:

• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.front.MFNaNbNdNfZyAa.part.23

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange6__ctorMFNaNbNcNfS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe ulong __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.length()

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.opIndex(ulong)

Uses:

• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange7opSliceMFNaNbNfmmZS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

Uses:

• _d_array_bounds
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe void __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.popBack()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange7releaseMFNaNbZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe void __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.popFront()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T12assumeSortedS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2TS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZ12assumeSortedMFNaNbNfS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))

Used by:

• @safe bool std.uni.findSetName!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))

Uses:

• @property @safe immutable(std.internal.unicode_tables.UnicodeProperty)[] std.internal.unicode_tables.uniProps.tab()
• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(const(char)[], immutable(char)[]).__lambda2(const(char)[], immutable(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(immutable(char)[], const(char)[]).__lambda2(immutable(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange11__xopEqualsFKxS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRangeKxS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRangeZb

Uses:

• _adEq2

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.geq!(immutable(char)[], const(char)[]).geq(immutable(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange47__T10lowerBoundVE3std5range12SearchPolicy2TAxaZ10lowerBoundMFNaAxaZS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.back()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange4saveMFNaNbNdNfZS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange580__T18getTransitionIndexVE3std5range12SearchPolicy2S5213std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange3geqTAxaZ18getTransitionIndexMFNaAxaZm

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.empty()

Uses:

• pure nothrow @property @safe bool std.array.empty!(std.internal.unicode_tables.UnicodeProperty).empty(const(std.internal.unicode_tables.UnicodeProperty[]))

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.front()

Uses:

• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.front.MFNaNbNdNfZyAa.part.23

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange6__ctorMFNaNbNcNfS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @property @safe ulong __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.length()

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe immutable(char[]) __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.opIndex(ulong)

Uses:

• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opIndex.MFNaNbNfmZyAa.part.24

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange7opSliceMFNaNbNfmmZS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

Uses:

• _d_array_bounds
• std.algorithm.MapResult.S593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ.MapResult.opSlice.MFNaNbNfmmZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult.part.22

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe void __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.popBack()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange7releaseMFNaNbZS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResult

@trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure nothrow @safe void __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.popFront()

Uses:

• _d_array_bounds

std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl346__T12assumeSortedS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2TS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZ12assumeSortedMFNaNbNfS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultZS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange

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

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)

const(pure nothrow @safe bool function(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!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).SliceOverIndexed).opEquals

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

const(pure nothrow @safe bool function(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!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl).SliceOverIndexed).opEquals

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

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

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

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)

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

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

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

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

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 void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(3uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

const(pure nothrow @safe bool function(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!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed).opEquals

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

const(pure nothrow @safe bool function(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!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed).opEquals

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl)

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

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl)

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 void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)

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

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl)

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 void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)
• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

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

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @safe ulong std.uni.ceilPowerOf2(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.fullCaseTrie()

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

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

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(dchar).toCaseInPlaceAlloc(ref dchar[], ulong, ulong)
• pure @trusted immutable(char)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, immutable(char)[]).toCase(immutable(char)[]).int __foreachbody2(ref ulong, ref dchar).@safe int __foreachbody3(ref dchar)
• pure @trusted immutable(wchar)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, immutable(wchar)[]).toCase(immutable(wchar)[]).int __foreachbody2(ref ulong, ref dchar).@safe int __foreachbody3(ref dchar)
• pure ulong std.uni.toCaseLength!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseLength!(wchar).toCaseLength(const(wchar[]))
• pure @trusted immutable(wchar)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, immutable(wchar)[]).toCase(immutable(wchar)[]).int __foreachbody2(ref ulong, ref dchar)
• pure ulong std.uni.toCaseLength!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseLength!(char).toCaseLength(const(char[]))
• pure @trusted immutable(dchar)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, immutable(dchar)[]).toCase(immutable(dchar)[])
• pure ulong std.uni.toCaseLength!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseLength!(dchar).toCaseLength(const(dchar[]))
• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(char).toCaseInPlaceAlloc(ref char[], ulong, ulong)
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(wchar).toCaseInPlaceAlloc(ref wchar[], ulong, ulong)
• pure @trusted const(char)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, const(char)[]).toCase(const(char)[]).@safe int __foreachbody2(ref ulong, ref dchar).@safe int __foreachbody3(ref dchar)
• pure nothrow @safe dchar std.uni.toLower(dchar)
• pure @trusted immutable(char)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, immutable(char)[]).toCase(immutable(char)[]).int __foreachbody2(ref ulong, ref dchar)
• pure @trusted const(char)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, const(char)[]).toCase(const(char)[]).@safe int __foreachbody2(ref ulong, ref dchar)
• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, char).toCaseInPlace(ref char[])

Uses:

• 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 @trusted ushort std.uni.toTitleIndex(dchar)

Used by:

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

Uses:

• 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 @trusted ushort std.uni.toUpperIndex(dchar)

Used by:

• pure @trusted immutable(char)[] std.uni.toCase!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, immutable(char)[]).toCase(immutable(char)[]).int __foreachbody2(ref ulong, ref dchar).@safe int __foreachbody3(ref dchar)
• pure @trusted immutable(wchar)[] std.uni.toCase!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, immutable(wchar)[]).toCase(immutable(wchar)[]).int __foreachbody2(ref ulong, ref dchar).@safe int __foreachbody3(ref dchar)
• pure ulong std.uni.toCaseLength!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseLength!(char).toCaseLength(const(char[]))
• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, char).toCaseInPlace(ref char[])
• pure ulong std.uni.toCaseLength!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseLength!(wchar).toCaseLength(const(wchar[]))
• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])
• pure ulong std.uni.toCaseLength!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseLength!(dchar).toCaseLength(const(dchar[]))
• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])
• pure nothrow @safe dchar std.uni.toUpper(dchar)
• pure @trusted immutable(dchar)[] std.uni.toCase!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, immutable(dchar)[]).toCase(immutable(dchar)[])
• pure @trusted immutable(char)[] std.uni.toCase!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, immutable(char)[]).toCase(immutable(char)[]).int __foreachbody2(ref ulong, ref dchar)
• pure @trusted immutable(wchar)[] std.uni.toCase!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, immutable(wchar)[]).toCase(immutable(wchar)[]).int __foreachbody2(ref ulong, ref dchar)
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(char).toCaseInPlaceAlloc(ref char[], ulong, ulong)
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(wchar).toCaseInPlaceAlloc(ref wchar[], ulong, ulong)
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(dchar).toCaseInPlaceAlloc(ref dchar[], ulong, ulong)

Uses:

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

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

Uses:

• free@plt

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

Uses:

• free@plt
• 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)

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

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

Uses:

• 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 @safe bool std.uni.isSurrogateHi(dchar)

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

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!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) std.uni.lowerCaseTrie()

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!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) std.uni.upperCaseTrie()

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).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, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedPtrImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).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())

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(2uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.__ctor(bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).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, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).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, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor

Uses:

• _d_arraycopy

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

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

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(2uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.__ctor(bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length

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.raw_ptr!(1uL).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!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor

Uses:

• _d_arraycopy

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).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, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(1uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedPtrImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).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())

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(2uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.__ctor(bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length

std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).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, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).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, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(2uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor

Uses:

• _d_arraycopy

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).mapTrieIndex!(int).mapTrieIndex(int)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).mapTrieIndex!(dchar).mapTrieIndex(dchar)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).mapTrieIndex!(int).mapTrieIndex(int)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).mapTrieIndex!(dchar).mapTrieIndex(dchar)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).mapTrieIndex!(int).mapTrieIndex(int)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).mapTrieIndex!(dchar).mapTrieIndex(dchar)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).mapTrieIndex!(int).mapTrieIndex(int)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).mapTrieIndex!(dchar).mapTrieIndex(dchar)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).mapTrieIndex!(int).mapTrieIndex(int)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).mapTrieIndex!(dchar).mapTrieIndex(dchar)

@trusted ubyte std.uni.combiningClass(dchar)

pure @safe uint std.uni.decompressFrom(const(ubyte)[], ref ulong)

Used by:

• std.range.roundRobin.TS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ.roundRobin.FNaNbNfS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6Result6Result8popFrontMFZv
• std.algorithm.copy.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.uni.DecompressedIntervals.popFront.MFNeZv.part.18
• @trusted void std.uni.DecompressedIntervals.popFront()
• ref @trusted std.uni.DecompressedIntervals std.uni.DecompressedIntervals.__ctor(const(ubyte)[])
• std.algorithm.MapResult.S553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ.MapResult.popFront.MFNfZv
• std.range.walkLength.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZ.walkLength.FS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZm
• std.uni.Uint24Array.TS3std3uni8GcPolicyZ.Uint24Array.__ctor.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZ.__ctor.MFNcNeS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24Array
• std.range.put.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZ.put.FKS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZv
• @safe std.uni.DecompressedIntervals std.uni.decompressIntervals(const(ubyte)[])
• std.algorithm.MapResult.S553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ.MapResult.popFront.MFNfZv

Uses:

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

pure @safe uint std.uni.decompressFrom(const(ubyte)[], ref ulong).pure nothrow @safe const(char)[] __dgliteral3()

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

Uses:

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

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.simpleCaseTrie()

pure @safe void std.uni.toLowerInPlace(ref char[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, char).toCaseInPlace(ref char[])

pure @safe void std.uni.toLowerInPlace(ref wchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])

pure @safe void std.uni.toLowerInPlace(ref dchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])

pure @safe void std.uni.toUpperInPlace(ref char[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, char).toCaseInPlace(ref char[])

pure @safe void std.uni.toUpperInPlace(ref wchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])

pure @safe void std.uni.toUpperInPlace(ref dchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])

pure nothrow ref @trusted std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray)

const(pure nothrow ref @trusted const(std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__ctor!().__ctor

Used by:

• pure nothrow const(std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) std.uni.asTrie!(ubyte, 8, 7, 6).asTrie(const(std.internal.unicode_tables.TrieEntry!(ubyte, 8, 7, 6).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__xopEquals(ref const(std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie), ref const(std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie))

Uses:

• memcmp@plt

const(pure nothrow @trusted ubyte function(dchar)) std.uni.Trie!(ubyte, 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 ref @trusted std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray)

const(pure nothrow ref @trusted const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie.__ctor!().__ctor

Used by:

• pure nothrow const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie) std.uni.asTrie!(ushort, 8, 8, 5).asTrie(const(std.internal.unicode_tables.TrieEntry!(ushort, 8, 8, 5).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie.__xopEquals(ref const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie), ref const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie))

Uses:

• memcmp@plt

pure nothrow ref @trusted 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.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray)

const(pure nothrow ref @trusted const(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) function(const(ulong)[], const(ulong)[], const(ulong)[])) 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.__ctor!().__ctor

Used by:

• pure nothrow const(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.asTrie!(ushort, 8, 7, 6).asTrie(const(std.internal.unicode_tables.TrieEntry!(ushort, 8, 7, 6).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool 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.__xopEquals(ref const(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), ref const(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))

Uses:

• memcmp@plt

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)
• pure @trusted int std.uni.sicmp!(const(dchar)[], const(dchar)[]).sicmp(const(dchar)[], const(dchar)[])
• pure @trusted int std.uni.fullCasedCmp!(const(char)[]).fullCasedCmp(dchar, dchar, ref const(char)[])
• pure @trusted int std.uni.fullCasedCmp!(const(wchar)[]).fullCasedCmp(dchar, dchar, ref const(wchar)[])
• pure nothrow @trusted int std.uni.fullCasedCmp!(const(dchar)[]).fullCasedCmp(dchar, dchar, ref const(dchar)[])
• pure nothrow @trusted ushort std.uni.toTitleIndex(dchar)
• pure @trusted int std.uni.sicmp!(const(char)[], const(char)[]).sicmp(const(char)[], const(char)[]).@safe int __foreachbody3(ref dchar)
• pure @trusted int std.uni.sicmp!(const(wchar)[], const(wchar)[]).sicmp(const(wchar)[], const(wchar)[]).@safe int __foreachbody3(ref dchar)
• pure nothrow @trusted ushort std.uni.toUpperIndex(dchar)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

@trusted bool std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

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*)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 14uL).BitPacked).addValue(std.uni.BitPacked!(uint, 14uL).BitPacked, ulong)
• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 14uL).BitPacked).addValue(std.uni.BitPacked!(uint, 14uL).BitPacked, ulong)

Uses:

• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl*)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

pure nothrow @trusted ulong std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(2uL, bool).addValue(bool, ulong)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(2uL, bool).addValue(bool, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)
• pure nothrow @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.build()
• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putValue(dchar, bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putAt(ulong, bool)
• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)

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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl)

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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 14uL).BitPacked).addValue(std.uni.BitPacked!(uint, 14uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putAt(ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• _d_newarrayT
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• _d_arraysetlengthT

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putValue(dchar, bool)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.putValue(dchar, bool).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

@trusted bool std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

Uses:

• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 13uL).BitPacked).addValue(std.uni.BitPacked!(uint, 13uL).BitPacked, 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*)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 13uL).BitPacked).addValue(std.uni.BitPacked!(uint, 13uL).BitPacked, 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*)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

pure nothrow @trusted ulong std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(2uL, bool).addValue(bool, ulong)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

Used by:

• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putValue(dchar, bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putAt(ulong, bool)
• pure nothrow @trusted 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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.build()
• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(2uL, bool).addValue(bool, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)

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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)

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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 13uL).BitPacked).addValue(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted 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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putAt(ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• _d_newarrayT
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• _d_arraysetlengthT

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putValue(dchar, bool)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.putValue(dchar, bool).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

@trusted bool std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

Uses:

• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(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*)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl*)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)

pure nothrow @trusted ulong std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(2uL, bool).addValue(bool, ulong)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(2uL, bool).addValue(bool, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)
• pure nothrow @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.build()
• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putValue(dchar, bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putAt(ulong, bool)
• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)

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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl)

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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putAt(ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• _d_newarrayT
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• _d_arraysetlengthT

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putValue(dchar, bool)

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.putValue(dchar, bool).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ubyte)

Uses:

• std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36

@trusted bool std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(1uL).length(ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, 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*)

pure nothrow @trusted ulong std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, ubyte).addValue(ubyte, ulong)

Uses:

• std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36

std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, ubyte).addValue(ubyte, ulong)
• pure @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, ubyte)
• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putAt(ulong, ubyte)
• pure @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ubyte)
• pure nothrow @trusted std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.build()
• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ubyte)

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

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.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl)

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.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36

pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putAt(ulong, ubyte)

Uses:

• std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36

pure nothrow ref @trusted std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(ubyte)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(1uL).length(ulong)
• _d_newarrayT
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(0uL).length(ulong)
• _d_arraysetlengthT

pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)
• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(2uL).length(ulong)

pure @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ubyte)

Uses:

• std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ubyte).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, ubyte)

Uses:

• std.uni.TrieBuilder.ThTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2ThZ.addValue.MFNaNbNehmZv.part.36
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, ubyte).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49

@trusted bool std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 16uL).BitPacked).addValue(std.uni.BitPacked!(uint, 16uL).BitPacked, ulong)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl*)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

pure nothrow @trusted ulong std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(2uL, ushort).addValue(ushort, ulong)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49

std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ushort)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(2uL, ushort).addValue(ushort, ulong)
• pure nothrow @trusted std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.build()
• pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putValue(dchar, ushort)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putAt(ulong, ushort)
• pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSliceAssign(ushort, ulong, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl)

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.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 16uL).BitPacked).addValue(std.uni.BitPacked!(uint, 16uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putAt(ulong, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49

pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.__ctor(ushort)

Uses:

• _d_newarrayT
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)
• _d_arraysetlengthT

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49

Uses:

• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(2uL).length(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*)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 16uL).BitPacked).addValue(std.uni.BitPacked!(uint, 16uL).BitPacked, ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putValue(dchar, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.putValue(dchar, ushort).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29

@trusted bool std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, 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*)

pure nothrow @trusted ulong std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, ushort).addValue(ushort, ulong)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29

std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, ushort).addValue(ushort, ulong)
• pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, ushort)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putAt(ulong, ushort)
• pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort)
• pure nothrow @trusted 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.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.build()
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, ushort)

Uses:

• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opSliceAssign(ushort, ulong, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

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.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

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.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted 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.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putAt(ulong, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29

pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(ushort)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)
• _d_newarrayT
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)
• _d_arraysetlengthT

pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29

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.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)
• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(2uL).length(ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, ushort).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, ushort)

Uses:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, ushort).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

@trusted std.uni.Grapheme std.uni.decomposeHangul(dchar)

Uses:

• ref @trusted std.uni.Grapheme std.uni.Grapheme.opOpAssign!("~").opOpAssign(dchar)

@trusted void std.uni.hangulRecompose(dchar[])

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.punctuationTrie()

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

pure @trusted const(char)[] std.uni.toLower!(const(char)[]).toLower(const(char)[])

Uses:

• _aApplycd2

pure @trusted immutable(char)[] std.uni.toLower!(immutable(char)[]).toLower(immutable(char)[])

Uses:

• _aApplycd2

pure @trusted immutable(wchar)[] std.uni.toLower!(immutable(wchar)[]).toLower(immutable(wchar)[])

Uses:

• _aApplywd2

pure @trusted immutable(dchar)[] std.uni.toLower!(immutable(dchar)[]).toLower(immutable(dchar)[])

Uses:

• pure @trusted immutable(dchar)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, immutable(dchar)[]).toCase(immutable(dchar)[])

pure @trusted immutable(char)[] std.uni.toUpper!(immutable(char)[]).toUpper(immutable(char)[])

Uses:

• _aApplycd2

pure @trusted immutable(wchar)[] std.uni.toUpper!(immutable(wchar)[]).toUpper(immutable(wchar)[])

Uses:

• _aApplywd2

pure @trusted immutable(dchar)[] std.uni.toUpper!(immutable(dchar)[]).toUpper(immutable(dchar)[])

Uses:

• pure @trusted immutable(dchar)[] std.uni.toCase!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, immutable(dchar)[]).toCase(immutable(dchar)[])

pure nothrow @safe ulong std.uni.spaceFor!(1uL).spaceFor(ulong)

pure nothrow @safe ulong std.uni.spaceFor!(7uL).spaceFor(ulong)

pure nothrow @safe ulong std.uni.spaceFor!(8uL).spaceFor(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.canonMappingTrie()

pure nothrow @property @safe immutable(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) std.uni.nonCharacterTrie()

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

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.toTitleIndexTrie()

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.toUpperIndexTrie()

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

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

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

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

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

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

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

pure @trusted int std.uni.icmp!(const(char)[], const(char)[]).icmp(const(char)[], const(char)[])

Used by:

• pure @safe int std.uni.icmp(const(char)[], const(char)[])

Uses:

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

pure @trusted int std.uni.icmp!(const(wchar)[], const(wchar)[]).icmp(const(wchar)[], const(wchar)[])

Used by:

• pure @safe int std.uni.icmp(const(wchar)[], const(wchar)[])

Uses:

• pure dchar std.utf.decodeImpl!(true, const(wchar)[]).decodeImpl(ref const(wchar)[], ref ulong).std.utf.UTFException exception(immutable(char)[])
• _d_throw
• pure @trusted int std.uni.fullCasedCmp!(const(wchar)[]).fullCasedCmp(dchar, dchar, ref const(wchar)[])

pure nothrow @trusted int std.uni.icmp!(const(dchar)[], const(dchar)[]).icmp(const(dchar)[], const(dchar)[])

Uses:

• pure nothrow @trusted int std.uni.fullCasedCmp!(const(dchar)[]).fullCasedCmp(dchar, dchar, ref const(dchar)[])

pure nothrow @safe ulong std.uni.spaceFor!(11uL).spaceFor(ulong)

pure nothrow @safe ulong std.uni.spaceFor!(12uL).spaceFor(ulong)

pure nothrow @safe ulong std.uni.spaceFor!(13uL).spaceFor(ulong)

pure nothrow @safe ulong std.uni.spaceFor!(14uL).spaceFor(ulong)

pure nothrow @safe ulong std.uni.spaceFor!(15uL).spaceFor(ulong)

pure nothrow @safe ulong std.uni.spaceFor!(16uL).spaceFor(ulong)

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

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

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

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(2uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.ptr!(3uL).ptrinout(pure nothrow @property inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl) function())

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(2uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.slice!(3uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(3uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(3uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(3uL).length

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).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, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(1uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).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, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.raw_ptr!(3uL).raw_ptrinout(pure nothrow @property inout(ulong)* function())

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.__ctor

Uses:

• _d_arraycopy

pure @trusted int std.uni.sicmp!(const(char)[], const(char)[]).sicmp(const(char)[], const(char)[])

Uses:

• _aApplycd1

pure @trusted int std.uni.sicmp!(const(char)[], const(char)[]).sicmp(const(char)[], const(char)[]).@safe int __foreachbody3(ref dchar)

Uses:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• _d_array_bounds
• 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 @property @safe immutable(std.internal.unicode_tables.SimpleCaseEntry[]) std.internal.unicode_tables.simpleCaseTable()

pure @trusted int std.uni.sicmp!(const(wchar)[], const(wchar)[]).sicmp(const(wchar)[], const(wchar)[])

Uses:

• _aApplywd1

pure @trusted int std.uni.sicmp!(const(wchar)[], const(wchar)[]).sicmp(const(wchar)[], const(wchar)[]).@safe int __foreachbody3(ref dchar)

Uses:

• pure dchar std.utf.decodeImpl!(true, const(wchar)[]).decodeImpl(ref const(wchar)[], ref ulong)
• _d_array_bounds
• 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 @property @safe immutable(std.internal.unicode_tables.SimpleCaseEntry[]) std.internal.unicode_tables.simpleCaseTable()

pure @trusted int std.uni.sicmp!(const(dchar)[], const(dchar)[]).sicmp(const(dchar)[], const(dchar)[])

Used by:

• pure @safe int std.uni.sicmp(const(dchar)[], const(dchar)[])

Uses:

• pure nothrow @safe bool std.utf.isValidDchar(dchar)
• pure nothrow @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw
• _d_newclass
• 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 @property @safe immutable(std.internal.unicode_tables.SimpleCaseEntry[]) std.internal.unicode_tables.simpleCaseTable()

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

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.graphemeExtendTrie()

pure nothrow ref @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray)

const(pure nothrow ref @trusted const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie.__ctor!().__ctor

Used by:

• pure nothrow const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie) std.uni.asTrie!(bool, 8, 6, 7).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 8, 6, 7).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie.__xopEquals(ref const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie), ref const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie))

Uses:

• memcmp@plt

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!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie.opIndex!().opIndex

Uses:

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

pure nothrow ref @trusted 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.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.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray)

const(pure nothrow ref @trusted const(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) function(const(ulong)[], const(ulong)[], const(ulong)[])) 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.__ctor!().__ctor

Used by:

• pure nothrow const(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.asTrie!(bool, 8, 5, 8).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 8, 5, 8).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool 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.__xopEquals(ref const(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), ref const(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))

Uses:

• memcmp@plt

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.isAlpha(dchar)
• pure nothrow @safe bool std.uni.isMark(dchar)
• pure nothrow @safe bool std.uni.isGraphical(dchar)
• pure nothrow @safe bool std.uni.isPunctuation(dchar)
• pure nothrow @safe bool std.uni.isSymbol(dchar)

Uses:

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

pure nothrow ref @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray)

const(pure nothrow ref @trusted const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__ctor!().__ctor

Used by:

• pure nothrow const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) std.uni.asTrie!(bool, 8, 4, 9).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 8, 4, 9).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__xopEquals(ref const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie), ref const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie))

Uses:

• memcmp@plt

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!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.opIndex!().opIndex

Used by:

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

Uses:

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

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).mapTrieIndex!(int).mapTrieIndex(int)

pure nothrow ulong std.uni.mapTrieIndex!(std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).mapTrieIndex!(dchar).mapTrieIndex(dchar)

pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])

Used by:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, ubyte).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 14uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 13uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 16uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 12uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)

Uses:

• _d_array_bounds

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

@safe std.uni.DecompressedIntervals std.uni.decompressIntervals(const(ubyte)[])

Used by:

• std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.asSet(const(ubyte)[])

Uses:

• pure @safe uint std.uni.decompressFrom(const(ubyte)[], ref ulong)

@trusted int std.uni.hangulSyllableIndex(dchar)

bool std.uni.isRegionalIndicator(dchar)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46

@trusted bool std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__xopEquals(ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder), ref const(std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder))

Uses:

• _adEq2
• memcmp@plt

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(3uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Used by:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, 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*)
• pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(3uL).length(ulong)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 11uL).BitPacked).addValue(std.uni.BitPacked!(uint, 11uL).BitPacked, ulong)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).sliceOverIndexed(ulong, ulong, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl*)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 7uL).BitPacked).addValue(std.uni.BitPacked!(uint, 7uL).BitPacked, ulong)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

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*)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 11uL).BitPacked).addValue(std.uni.BitPacked!(uint, 11uL).BitPacked, ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(3uL, bool).addValue(bool, ulong)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46

std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(3uL, bool).addValue(bool, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRangeAt(ulong, ulong, bool)
• pure nothrow @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.build()
• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, bool)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putAt(ulong, bool)
• pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)

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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(3uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

pure nothrow @trusted ulong std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.deduceMaxIndex!(std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).deduceMaxIndex()

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 7uL).BitPacked).addValue(std.uni.BitPacked!(uint, 7uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 11uL).BitPacked).addValue(std.uni.BitPacked!(uint, 11uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl)

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(3uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl)

Uses:

• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl)
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(uint, ulong, ulong)

pure nothrow @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.build()

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46

pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putAt(ulong, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46

pure nothrow ref @trusted std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.__ctor(bool)

Uses:

• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(1uL).length(ulong)
• _d_newarrayT
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(0uL).length(ulong)
• pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray.length!(2uL).length(ulong)
• _d_arraysetlengthT

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putRange(dchar, dchar, bool).pure nothrow @safe const(char)[] __dgliteral4()

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, bool)

Uses:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46
• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy const(char)[], immutable(char)[], ulong)

pure @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.putValue(dchar, bool).pure @safe const(char)[] __dgliteral3()

Uses:

• pure @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• _d_arrayappendT
• pure @trusted immutable(char)[] std.conv.toImpl!(immutable(char)[], ulong).toImpl(ulong, uint, std.ascii.LetterCase).immutable(char)[] toStringRadixConvert!(24uL, 10).toStringRadixConvert(uint)

std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

Used by:

• const(pure nothrow @trusted bool function(uint)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.opIndex
• std.uni.sharMethod.S333std3uni23switchUniformLowerBoundZ.sharMethod.VAyaa4_613c3d62TS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.sharMethod.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

pure nothrow const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) std.uni.asTrie!(ushort, 12, 9).asTrie(const(std.internal.unicode_tables.TrieEntry!(ushort, 12, 9).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__ctor!().__ctor

pure nothrow int std.uni.sliceBits!(0uL, 5uL).sliceBits.opCall!(int).opCall(int)

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

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

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

pure nothrow int std.uni.sliceBits!(0uL, 7uL).sliceBits.opCall!(int).opCall(int)

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

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

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

pure nothrow int std.uni.sliceBits!(0uL, 9uL).sliceBits.opCall!(int).opCall(int)

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

@trusted bool std.uni.DecompressedIntervals.__xopEquals(ref const(std.uni.DecompressedIntervals), ref const(std.uni.DecompressedIntervals))

Uses:

• memcmp@plt

@property @trusted std.uni.DecompressedIntervals std.uni.DecompressedIntervals.save()

const(@property @trusted bool function()) std.uni.DecompressedIntervals.empty

@property @trusted std.uni.CodepointInterval std.uni.DecompressedIntervals.front()

ref @trusted std.uni.DecompressedIntervals std.uni.DecompressedIntervals.__ctor(const(ubyte)[])

Uses:

• pure @safe uint std.uni.decompressFrom(const(ubyte)[], ref ulong)

@trusted void std.uni.DecompressedIntervals.popFront()

Uses:

• pure @safe uint std.uni.decompressFrom(const(ubyte)[], ref ulong)

std.uni.DecompressedIntervals.popFront.MFNeZv.part.18

Used by:

• std.algorithm.copy.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed

Uses:

• pure @safe uint std.uni.decompressFrom(const(ubyte)[], ref ulong)

pure nothrow @safe void std.uni.copyBackwards!(ulong).copyBackwards(ulong[], ulong[])

Uses:

• std.uni.copyBackwards.TmZ.copyBackwards.FNaNbNfAmAmZv.part.26
• _d_array_bounds

std.uni.copyBackwards.TmZ.copyBackwards.FNaNbNfAmAmZv.part.26

Used by:

• pure nothrow @safe void std.uni.copyBackwards!(ulong).copyBackwards(ulong[], ulong[])

Uses:

• _d_array_bounds

pure nothrow int std.uni.sliceBits!(5uL, 13uL).sliceBits.opCall!(int).opCall(int)

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

pure nothrow int std.uni.sliceBits!(6uL, 10uL).sliceBits.opCall!(int).opCall(int)

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

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

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

pure nothrow int std.uni.sliceBits!(7uL, 13uL).sliceBits.opCall!(int).opCall(int)

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

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

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

pure nothrow int std.uni.sliceBits!(9uL, 13uL).sliceBits.opCall!(int).opCall(int)

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

pure nothrow int std.uni.sliceBits!(9uL, 21uL).sliceBits.opCall!(int).opCall(int)

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

pure @trusted int std.uni.fullCasedCmp!(const(char)[]).fullCasedCmp(dchar, dchar, ref const(char)[])

Used by:

• pure @trusted int std.uni.icmp!(const(char)[], const(char)[]).icmp(const(char)[], const(char)[])

Uses:

• 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 @property @safe immutable(std.internal.unicode_tables.FullCaseEntry[]) std.internal.unicode_tables.fullCaseTable()
• pure @safe bool std.algorithm.skipOver!("a == b", const(char)[], immutable(dchar)[]).skipOver(ref const(char)[], immutable(dchar)[])

pure @trusted int std.uni.fullCasedCmp!(const(wchar)[]).fullCasedCmp(dchar, dchar, ref const(wchar)[])

Used by:

• pure @trusted int std.uni.icmp!(const(wchar)[], const(wchar)[]).icmp(const(wchar)[], const(wchar)[])

Uses:

• 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 @property @safe immutable(std.internal.unicode_tables.FullCaseEntry[]) std.internal.unicode_tables.fullCaseTable()
• pure @safe bool std.algorithm.skipOver!("a == b", const(wchar)[], immutable(dchar)[]).skipOver(ref const(wchar)[], immutable(dchar)[])

pure nothrow @trusted int std.uni.fullCasedCmp!(const(dchar)[]).fullCasedCmp(dchar, dchar, ref const(dchar)[])

Used by:

• pure @safe int std.uni.icmp(const(dchar)[], const(dchar)[])
• pure nothrow @trusted int std.uni.icmp!(const(dchar)[], const(dchar)[]).icmp(const(dchar)[], const(dchar)[])

Uses:

• 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 @property @safe immutable(std.internal.unicode_tables.FullCaseEntry[]) std.internal.unicode_tables.fullCaseTable()
• pure nothrow @safe bool std.algorithm.skipOver!("a == b", const(dchar)[], immutable(dchar)[]).skipOver(ref const(dchar)[], immutable(dchar)[])

pure @trusted void std.uni.toLowerInPlace!(char).toLowerInPlace(ref char[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, char).toCaseInPlace(ref char[])

pure @trusted void std.uni.toLowerInPlace!(wchar).toLowerInPlace(ref wchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])

pure @trusted void std.uni.toLowerInPlace!(dchar).toLowerInPlace(ref dchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])

pure @trusted void std.uni.toUpperInPlace!(char).toUpperInPlace(ref char[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, char).toCaseInPlace(ref char[])

pure @trusted void std.uni.toUpperInPlace!(wchar).toUpperInPlace(ref wchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])

pure @trusted void std.uni.toUpperInPlace!(dchar).toUpperInPlace(ref dchar[])

Uses:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, dchar).toCaseInPlace(ref dchar[])

pure nothrow const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) std.uni.asTrie!(bool, 8, 4, 9).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 8, 4, 9).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.__ctor!().__ctor

pure nothrow const(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.asTrie!(bool, 8, 5, 8).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 8, 5, 8).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(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) function(const(ulong)[], const(ulong)[], const(ulong)[])) 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.__ctor!().__ctor

pure nothrow const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie) std.uni.asTrie!(bool, 8, 6, 7).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 8, 6, 7).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie.__ctor!().__ctor

pure nothrow const(std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) std.uni.asTrie!(ubyte, 8, 7, 6).asTrie(const(std.internal.unicode_tables.TrieEntry!(ubyte, 8, 7, 6).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(ubyte, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__ctor!().__ctor

pure nothrow const(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.asTrie!(ushort, 8, 7, 6).asTrie(const(std.internal.unicode_tables.TrieEntry!(ushort, 8, 7, 6).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(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) function(const(ulong)[], const(ulong)[], const(ulong)[])) 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.__ctor!().__ctor

pure nothrow const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie) std.uni.asTrie!(ushort, 8, 8, 5).asTrie(const(std.internal.unicode_tables.TrieEntry!(ushort, 8, 8, 5).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(ushort, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).Trie.__ctor!().__ctor

pure nothrow int std.uni.sliceBits!(10uL, 14uL).sliceBits.opCall!(int).opCall(int)

pure nothrow uint std.uni.sliceBits!(10uL, 14uL).sliceBits.opCall!(dchar).opCall(dchar)

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

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

pure nothrow int std.uni.sliceBits!(14uL, 21uL).sliceBits.opCall!(int).opCall(int)

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

pure nothrow ref @trusted std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__ctor!().__ctor(std.uni.MultiArray!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 11uL).BitPacked, std.uni.BitPacked!(uint, 15uL).BitPacked, std.uni.BitPacked!(bool, 1).BitPacked).MultiArray)

const(pure nothrow ref @trusted const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__ctor!().__ctor

Used by:

• pure nothrow const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) std.uni.asTrie!(bool, 7, 4, 4, 6).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 7, 4, 4, 6).TrieEntry))

Uses:

• _d_arraycopy

@trusted bool std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__xopEquals(ref const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie), ref const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie))

Uses:

• memcmp@plt

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

Used by:

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

Uses:

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

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl) std.uni.packedArrayView!(ubyte).packedArrayView(inout(ulong)*, ulong)

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

immutable(char)[] std.uni.genUnrolledSwitchSearch(ulong)

Uses:

• pure @safe immutable(char)[] std.conv.to!(immutable(char)[]).to!(ulong).to(ulong)
• 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 @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 nothrow immutable(char)[] std.array.replace!(immutable(char), immutable(char)[], immutable(char)[]).replace(immutable(char)[], immutable(char)[], immutable(char)[])
• _d_arrayappendT

pure nothrow @trusted bool std.uni.equalS!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).SliceOverIndexed).equalS(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).SliceOverIndexed)

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

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

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

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

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

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

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

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

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

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

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

Uses:

• std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.0

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

Uses:

• _d_array_bounds

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

Uses:

• _d_array_bounds

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

Uses:

• _d_array_bounds

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

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

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

Uses:

• _d_array_bounds

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

Uses:

• _d_array_bounds

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

Uses:

• std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.0

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

Uses:

• std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.0

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

Uses:

• std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.0

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.0

Used by:

• const(pure nothrow @safe const(int) function(ulong)) std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.opIndex
• 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
• bool std.uni.SliceOverIndexed!(int[]).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(int[]).SliceOverIndexed))
• 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_array_bounds

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.1

Uses:

• _d_array_bounds

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.12

Uses:

• _d_array_bounds

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.2

Uses:

• _d_array_bounds

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.8

Uses:

• _d_array_bounds

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

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

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

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

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

pure nothrow const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) std.uni.asTrie!(bool, 7, 4, 4, 6).asTrie(const(std.internal.unicode_tables.TrieEntry!(bool, 7, 4, 4, 6).TrieEntry))

Uses:

• const(pure nothrow ref @trusted const(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.__ctor!().__ctor

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

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

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

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

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

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

pure bool std.uni.propertyNameLess!(char, char).propertyNameLess(const(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[]))

Used by:

• @safe bool std.uni.unicode.findAny(immutable(char)[])

Uses:

• _d_arrayliteralTX
• pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[])).pure @safe immutable(char)[][] __T4findS803std3uni28__T20isPrettyPropertyNameTaZ20isPrettyPropertyNameFNaNfxAaZb9__lambda2TAAyaZ.find(immutable(char)[][])
• pure nothrow @property @safe bool std.array.empty!(immutable(char)[]).empty(const(immutable(char)[][]))

pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[])).@safe bool __lambda2!(immutable(char)[]).__lambda2(immutable(char)[])

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[])).pure @safe immutable(char)[][] __T4findS803std3uni28__T20isPrettyPropertyNameTaZ20isPrettyPropertyNameFNaNfxAaZb9__lambda2TAAyaZ.find(immutable(char)[][])

Used by:

• pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[]))

Uses:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• _d_array_bounds
• pure nothrow @property @safe bool std.array.empty!(immutable(char)[]).empty(const(immutable(char)[][]))

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

Used by:

• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.geq!(immutable(char)[], const(char)[]).geq(immutable(char)[], const(char)[])
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))
• pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[])).@safe bool __lambda2!(immutable(char)[]).__lambda2(immutable(char)[])
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(immutable(char)[], const(char)[]).__lambda2(immutable(char)[], const(char)[])
• std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange578__T18getTransitionIndexVE3std5range12SearchPolicy2S5193std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange3geqTAxaZ18getTransitionIndexMFNaAxaZm
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(immutable(char)[], const(char)[]).__lambda2(immutable(char)[], const(char)[])
• pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[])).pure @safe immutable(char)[][] __T4findS803std3uni28__T20isPrettyPropertyNameTaZ20isPrettyPropertyNameFNaNfxAaZb9__lambda2TAAyaZ.find(immutable(char)[][])
• std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange580__T18getTransitionIndexVE3std5range12SearchPolicy2S5213std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange3geqTAxaZ18getTransitionIndexMFNaAxaZm
• std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange47__T10lowerBoundVE3std5range12SearchPolicy2TAxaZ10lowerBoundMFNaAxaZS3std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange
• std.uni.findUnicodeSet.S98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange47__T10lowerBoundVE3std5range12SearchPolicy2TAxaZ10lowerBoundMFNaAxaZS3std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ344__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(const(char)[], immutable(char)[]).__lambda2(const(char)[], immutable(char)[])
• @safe bool std.uni.unicode.findAny(immutable(char)[])
• std.uni.findUnicodeSet.S99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange47__T10lowerBoundVE3std5range12SearchPolicy2TAxaZ10lowerBoundMFNaAxaZS3std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ345__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1693std3uni124__T14findUnicodeSetS99_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange
• pure bool std.uni.propertyNameLess!(char, char).propertyNameLess(const(char)[], const(char)[])
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(const(char)[], immutable(char)[]).__lambda2(const(char)[], immutable(char)[])
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(const(char)[], immutable(char)[]).__lambda2(const(char)[], immutable(char)[])
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __lambda2!(immutable(char)[], const(char)[]).__lambda2(immutable(char)[], const(char)[])
• std.uni.findUnicodeSet.S97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ.findUnicodeSet.FNexAaZl343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange576__T18getTransitionIndexVE3std5range12SearchPolicy2S5173std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFxAaZ343__T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z11SortedRange3geqTAxaZ18getTransitionIndexMFNaAxaZm
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1683std3uni123__T14findUnicodeSetS98_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.geq!(immutable(char)[], const(char)[]).geq(immutable(char)[], const(char)[])
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[])).pure bool __T11SortedRangeTS3std9algorithm126__T9MapResultS593std10functional32__T8unaryFunVAyaa6_612e6e616d65Z8unaryFunTAyS3std8internal14unicode_tables15UnicodePropertyZ9MapResultS1673std3uni122__T14findUnicodeSetS97_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodePropertyTaZ14findUnicodeSetFNexAaZl9__lambda2Z.SortedRange.geq!(immutable(char)[], const(char)[]).geq(immutable(char)[], const(char)[])

Uses:

• std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi97__T6filterS833std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNaNeAxaAxaZi9__lambda6Z196__T6filterTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ6filterMFNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult
• std.algorithm.cmp.VAyaa5_61203c2062TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZ.cmp.FNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZi
• std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi97__T6filterS833std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNaNeAxaAxaZi9__lambda4Z196__T6filterTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ6filterMFNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResult11__xopEqualsFKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZb

Uses:

• memcmp@plt

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ.MapResult.back()

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure @safe uint std.utf.strideBack!(const(char)[]).strideBack(ref const(char)[], ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResult4saveMFNaNbNdNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResult

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @property @safe bool __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ.MapResult.empty()

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ.MapResult.front()

Used by:

• std.algorithm.cmp.VAyaa5_61203c2062TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZ.cmp.FNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZi

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResult6__ctorMFNaNbNcNfAxaZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResult

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @safe void __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ.MapResult.popBack()

Uses:

• pure @safe uint std.utf.strideBack!(const(char)[]).strideBack(ref const(char)[], ulong)
• std.array.popBack.TxaZ.popBack.FNaNfKAxaZv.part.21

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe void __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ.MapResult.popFront()

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResult11__xopEqualsFKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZb

Uses:

• memcmp@plt

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ.MapResult.back()

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure @safe uint std.utf.strideBack!(const(char)[]).strideBack(ref const(char)[], ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResult4saveMFNaNbNdNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResult

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @property @safe bool __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ.MapResult.empty()

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ.MapResult.front()

Used by:

• std.algorithm.cmp.VAyaa5_61203c2062TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZ.cmp.FNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZi

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResult6__ctorMFNaNbNcNfAxaZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResult

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @safe void __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ.MapResult.popBack()

Uses:

• pure @safe uint std.utf.strideBack!(const(char)[]).strideBack(ref const(char)[], ulong)
• std.array.popBack.TxaZ.popBack.FNaNfKAxaZv.part.21

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe void __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ.MapResult.popFront()

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe dchar __lambda3!(dchar).__lambda3(dchar)

Uses:

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

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe bool __lambda4!(dchar).__lambda4(dchar)

Uses:

• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe dchar __lambda5!(dchar).__lambda5(dchar)

Uses:

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

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe bool __lambda6!(dchar).__lambda6(dchar)

Uses:

• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult11__xopEqualsFKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultZb

Uses:

• memcmp@plt

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult4saveMFNaNdNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @property @safe bool __T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ.FilterResult.empty()

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ.FilterResult.front()

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult6__ctorMFNaNcNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult7opSliceMFNaNbNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @safe void __T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ.FilterResult.popFront()

Used by:

• std.algorithm.cmp.VAyaa5_61203c2062TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZ.cmp.FNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResultS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZi

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult11__xopEqualsFKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResultZb

Uses:

• memcmp@plt

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult4saveMFNaNdNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @property @safe bool __T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ.FilterResult.empty()

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ.FilterResult.front()

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult6__ctorMFNaNcNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult7opSliceMFNaNbNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @safe void __T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ.FilterResult.popFront()

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)
• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi94__T3mapS833std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNaNeAxaAxaZi9__lambda3Z12__T3mapTAxaZ3mapMFNaNbNfAxaZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResult

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi94__T3mapS833std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNaNeAxaAxaZi9__lambda5Z12__T3mapTAxaZ3mapMFNaNbNfAxaZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResult

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi97__T6filterS833std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNaNeAxaAxaZi9__lambda4Z196__T6filterTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ6filterMFNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult

Used by:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

Uses:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi97__T6filterS833std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNaNeAxaAxaZi9__lambda6Z196__T6filterTS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ6filterMFNaNfS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult

Used by:

• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])

Uses:

• pure dchar std.utf.decodeImpl!(true, const(char)[]).decodeImpl(ref const(char)[], ref ulong)
• pure nothrow @safe bool std.ascii.isUpper(dchar)
• pure nothrow @safe bool std.internal.unicode_tables.isWhiteGen(dchar)

pure nothrow @property ulong std.uni.sumOfIntegerTuple!(12, 9).sumOfIntegerTuple()

@trusted bool std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl.__xopEquals(ref const(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl), ref const(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl))

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

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

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

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

const(pure nothrow @trusted bool function(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl)) std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl.opEquals!(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).opEquals

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

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

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl.opSlice()

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl).SliceOverIndexed std.uni.PackedArrayViewImpl!(ubyte, 8uL).PackedArrayViewImpl.opSlice(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))

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)

Used by:

• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.29
• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni21__T9sliceBitsVm9Vm21Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm1TtZ.addValue.MFNaNbNetmZv.part.37
• std.uni.TrieBuilder.TtTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm5Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm5Z9sliceBitsZ.TrieBuilder.addValue.Vm2TtZ.addValue.MFNaNbNetmZv.part.49

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

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

const(pure nothrow @trusted bool function(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)) std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.opEquals!(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

std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl.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()

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 bool std.uni.equalS!(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).equalS(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)

pure nothrow @trusted bool std.uni.equalS!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed).equalS(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)

pure nothrow @trusted bool std.uni.equalS!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed).equalS(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)

pure nothrow @trusted bool std.uni.equalS!(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).equalS(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)

pure nothrow @trusted bool std.uni.equalS!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed).equalS(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)

pure nothrow @trusted bool std.uni.equalS!(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).equalS(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)

pure nothrow @trusted bool std.uni.equalS!(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed).equalS(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed, std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl).SliceOverIndexed)

pure nothrow @property ulong std.uni.sumOfIntegerTuple!(8, 4, 9).sumOfIntegerTuple()

pure nothrow @property ulong std.uni.sumOfIntegerTuple!(8, 5, 8).sumOfIntegerTuple()

pure nothrow @property ulong std.uni.sumOfIntegerTuple!(8, 6, 7).sumOfIntegerTuple()

pure nothrow @property ulong std.uni.sumOfIntegerTuple!(8, 7, 6).sumOfIntegerTuple()

pure nothrow @property ulong std.uni.sumOfIntegerTuple!(8, 8, 5).sumOfIntegerTuple()

pure nothrow @property ulong std.uni.sumOfIntegerTuple!(7, 4, 4, 6).sumOfIntegerTuple()

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()

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()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• std.array.array.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZ.array.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZAS3std3uni17CodepointInterval

@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:

• memcmp@plt

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:

• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange11__xopEqualsFNeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZb

Uses:

• memcmp@plt

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
• _Unwind_Resume@plt
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• memcmp@plt

pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)

Used by:

• std.algorithm.copy.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.range.retro.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.retro.FNaNbNfS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11__T6ResultZ6Result13opIndexAssignMFNaNfkmZv
• pure ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.subChar(dchar)
• std.range.put.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZ.put.FKS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZv
• 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[])
• std.range.put.TS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultTkZ.put.FNaNfKS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultkZv
• std.algorithm.copy.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• pure 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)
• pure @safe void std.range.put!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, uint).put(ref std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, uint)
• pure 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)
• std.algorithm.copy.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.algorithm.copy.TAiTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• pure @safe void std.range.put!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, int).put(ref std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed, int)
• pure 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 @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])
• std.algorithm.copy.TS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultTS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZ.copy.FNaS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11genericImplFS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• std.algorithm.copy.TAkTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed

Uses:

• _d_newarrayT
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])

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 @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• 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)

Uses:

• _d_newarrayT
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.freeThisReference()

std.uni.Uint24Array.TS3std3uni8GcPolicyZ.Uint24Array.__ctor.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZ.__ctor.MFNcNeS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24Array

Used by:

• ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.__ctor!(std.uni.DecompressedIntervals).__ctor(std.uni.DecompressedIntervals)

Uses:

• abort@plt
• std.algorithm.copy.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• pure @safe uint std.uni.decompressFrom(const(ubyte)[], ref ulong)
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty

Used by:

• 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.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals6__ctorMFNcS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals
• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))
• const(pure nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals
• std.array.array.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZ.array.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZAS3std3uni17CodepointInterval

pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

Used by:

• 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[])
• std.uni.Uint24Array.TS3std3uni8GcPolicyZ.Uint24Array.__ctor.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZ.__ctor.MFNcNeS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24Array
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

Uses:

• _d_newarrayT
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])
• _d_arraysetlengthT

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 @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opSlice()

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 @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 @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 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.Uint24Array!(std.uni.GcPolicy).Uint24Array std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opAssign(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)

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

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals

Used by:

• @property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__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:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals11__fieldDtorMFNeZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals11__xopEqualsFKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZb

Uses:

• memcmp@plt

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals15__fieldPostBlitMFNeZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals4backMxFNdZS3std3uni17CodepointInterval

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals4saveMFNdZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals5emptyMxFNdZb

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals5frontMxFNdZS3std3uni17CodepointInterval

Used by:

• @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals6__ctorMFNcS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals7popBackMFZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals8__cpctorMxFNeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals8opAssignMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals8popFrontMFZv

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldDtor()

@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:

• memcmp@plt

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:

• _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[])
• 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)
• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange11__fieldDtorMFNeZv

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__fieldPostBlitMFNeZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange5emptyMxFNdNeZb

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange5frontMxFNdNeZw

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange6__ctorMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionListZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8__cpctorMxFNeKxS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZv

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8opAssignMFNcNeS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRangeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange

std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byCodepoint.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList11byCodepointMFNdZ14CodepointRange14CodepointRange8popFrontMFNeZv

@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 @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)[])
• @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 @safe bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals
• @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 nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• std.array.array.TS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZ.array.FS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9IntervalsZAS3std3uni17CodepointInterval
• _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
• 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)
• _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 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 bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• 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 nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• _d_arrayappendT

@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)[]).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)[])

@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 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)
• _d_arraycatT
• 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 bool std.exception.enforce!(bool).enforce(bool, lazy object.Throwable)
• pure @safe immutable(char)[] std.string.format!(char, immutable(char)[], immutable(char)[]).format(const(char[]), immutable(char)[], immutable(char)[])
• pure nothrow @safe std.array.Appender!(immutable(char)[]).Appender std.array.appender!(immutable(char)[], immutable(char)).appender()
• _d_arrayappendT
• pure @safe immutable(char)[] std.string.format!(char, immutable(char)[], uint).format(const(char[]), immutable(char)[], uint)

pure nothrow @trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.__fieldPostBlit()

ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.__ctor!(std.uni.DecompressedIntervals).__ctor(std.uni.DecompressedIntervals)

Used by:

• std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.asSet(const(ubyte)[])

Uses:

• std.uni.Uint24Array.TS3std3uni8GcPolicyZ.Uint24Array.__ctor.TS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZ.__ctor.MFNcNeS3std5range284__T10roundRobinTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultTS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ10roundRobinFS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b305dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultS3std9algorithm105__T9MapResultS553std10functional28__T8unaryFunVAyaa4_615b315dZ8unaryFunTS3std3uni21DecompressedIntervalsZ9MapResultZ6ResultZS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24Array

const(pure nothrow @property @trusted bool function()) std.uni.InversionList!(std.uni.GcPolicy).InversionList.empty

@property @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.length()

Uses:

• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals

const(pure nothrow @trusted bool function(uint)) std.uni.InversionList!(std.uni.GcPolicy).InversionList.opIndex

Uses:

• std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

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 @trusted void function(ref const(std.uni.InversionList!(std.uni.GcPolicy).InversionList))) std.uni.InversionList!(std.uni.GcPolicy).InversionList.__cpctor

pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.dropUpTo(uint, ulong)

Uses:

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

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)
• 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[])
• _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 nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()

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)

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:

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

@trusted void std.uni.InversionList!(std.uni.GcPolicy).InversionList.toString(scope void delegate(const(char)[]))

Uses:

• _Unwind_Resume@plt
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals
• std.uni.InversionList.TS3std3uni8GcPolicyZ.InversionList.byInterval.MFNdNeZS3std3uni38__T13InversionListTS3std3uni8GcPolicyZ13InversionList10byIntervalMFNdZ9Intervals9Intervals5frontMxFNdZS3std3uni17CodepointInterval
• pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__postblit()
• uint std.format.formattedWrite!(void delegate(const(char)[]), char, uint, uint).formattedWrite(void delegate(const(char)[]), const(char[]), uint, uint)

bool std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed))

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.opIndexAssign(dchar, ulong)

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.back(dchar)

const(pure nothrow @property @safe dchar function()) std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.back

std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed) function())

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

pure nothrow @property @safe void std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.front(dchar)

const(pure nothrow @property @safe dchar function()) std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.front

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

const(pure nothrow @safe dchar function(ulong)) std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.opIndex

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.opSlice()

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.popBack()

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

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

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.opDollar

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed.popFront()

pure nothrow @safe std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed std.uni.sliceOverIndexed!(std.uni.Grapheme).sliceOverIndexed(ulong, ulong, std.uni.Grapheme*)

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__postblit()

@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:

• memcmp@plt

const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals

Uses:

• memcmp@plt

const(nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opEquals!().opEquals

Uses:

• _Unwind_Resume@plt
• nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__dtor()
• memcmp@plt
• 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:

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

@trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.dupThisReference(uint)

Uses:

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

nothrow @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.freeThisReference()

Uses:

• free@plt

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

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

Uses:

• free@plt

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

Uses:

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

const(pure nothrow @property @trusted ulong function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.length

const(pure nothrow @trusted uint function(ulong)) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opIndex

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.opSlice()

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 @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 @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 @trusted void function(ref const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.__cpctor

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:

• free@plt

pure nothrow @property @trusted void std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount(uint)

const(pure nothrow @property @trusted uint function()) std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array.refCount

bool std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed))

const(pure nothrow @property @safe dchar function()) std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.back

std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed) function())

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

const(pure nothrow @property @safe dchar function()) std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.front

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

const(pure nothrow @safe dchar function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.opIndex

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.opSlice()

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.popBack()

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

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

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.opDollar

pure nothrow @safe void std.uni.SliceOverIndexed!(const(std.uni.Grapheme)).SliceOverIndexed.popFront()

pure @safe int std.uni.icmp(const(char)[], const(char)[])

Uses:

• pure @trusted int std.uni.icmp!(const(char)[], const(char)[]).icmp(const(char)[], const(char)[])

pure @safe int std.uni.icmp(const(wchar)[], const(wchar)[])

Uses:

• pure @trusted int std.uni.icmp!(const(wchar)[], const(wchar)[]).icmp(const(wchar)[], const(wchar)[])

pure @safe int std.uni.icmp(const(dchar)[], const(dchar)[])

Uses:

• pure nothrow @trusted int std.uni.fullCasedCmp!(const(dchar)[]).fullCasedCmp(dchar, dchar, ref const(dchar)[])

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

Uses:

• std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

pure nothrow @safe std.uni.BitPacked!(uint, 7uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 7uL).BitPacked, ulong).force(ulong)

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

pure nothrow @safe std.uni.BitPacked!(uint, 11uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 11uL).BitPacked, ulong).force(ulong)

pure nothrow @safe std.uni.BitPacked!(uint, 12uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong).force(ulong)

pure nothrow @safe std.uni.BitPacked!(uint, 13uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong).force(ulong)

pure nothrow @safe std.uni.BitPacked!(uint, 14uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 14uL).BitPacked, ulong).force(ulong)

pure nothrow @safe std.uni.BitPacked!(uint, 15uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong).force(ulong)

pure nothrow @safe std.uni.BitPacked!(uint, 16uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 16uL).BitPacked, ulong).force(ulong)

std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.asSet(const(ubyte)[])

Uses:

• ref @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.__ctor!(std.uni.DecompressedIntervals).__ctor(std.uni.DecompressedIntervals)
• @safe std.uni.DecompressedIntervals std.uni.decompressIntervals(const(ubyte)[])

uint std.uni.low_8(uint)

pure @safe int std.uni.sicmp(const(char)[], const(char)[])

Uses:

• _aApplycd1

pure @safe int std.uni.sicmp(const(wchar)[], const(wchar)[])

Uses:

• _aApplywd1

pure @safe int std.uni.sicmp(const(dchar)[], const(dchar)[])

Uses:

• pure @trusted int std.uni.sicmp!(const(dchar)[], const(dchar)[]).sicmp(const(dchar)[], const(dchar)[])

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

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

bool std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.__xopEquals(ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray), ref const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray))

Uses:

• memcmp@plt

std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.slice!(0uL).sliceinout(pure nothrow @property @safe inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl) function())

std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.slice!(1uL).sliceinout(pure nothrow @property inout(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl) function())

pure nothrow @property void std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.length!(0uL).length(ulong)

Used by:

• pure nothrow ref @trusted std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.__ctor(ushort)

Uses:

• pure nothrow @safe void std.uni.copyForward!(ulong).copyForward(ulong[], ulong[])
• _d_array_bounds
• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.length!(0uL).length

pure nothrow @property @safe void std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.length!(1uL).length(ulong)

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.spillToNextPage!(1uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

Uses:

• _d_arraysetlengthT

const(pure nothrow @property @safe ulong function()) std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.length!(1uL).length

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

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

pure nothrow ref @safe std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.__ctor(ulong[]...)

Uses:

• _d_newarrayT
• _d_array_bounds

const(pure nothrow ref @safe const(std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray) function(const(ulong)[], const(ulong)[], const(ulong)[])) std.uni.MultiArray!(std.uni.BitPacked!(uint, 12uL).BitPacked, ushort).MultiArray.__ctor

Uses:

• _d_arraycopy

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(bool, 1).BitPacked).packedArrayView(inout(ulong)*, ulong)

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 7uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 8uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

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:

• 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!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.opIndex!().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!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).Trie.opIndex!().opIndex
• const(pure nothrow @trusted bool function(dchar)) std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).Trie.opIndex!().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
• pure nothrow @safe bool std.uni.isNumber(dchar)

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

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedPtrImpl.opIndexAssign(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)*))

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

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 7uL).BitPacked function(ulong))

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

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

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedPtrImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedPtrImpl) function(inout(ulong)*))

std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedPtrImpl.opIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 7uL).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.opIndexAssign(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedPtrImpl.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)*))

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 inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 11uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 12uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 13uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 14uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 15uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

pure nothrow @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 16uL).BitPacked, 16uL).PackedArrayViewImpl) std.uni.packedArrayView!(std.uni.BitPacked!(uint, 16uL).BitPacked).packedArrayView(inout(ulong)*, ulong)

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

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

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

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

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

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

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

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

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

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

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.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, 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)*))

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!(uint, 14uL).BitPacked, 16uL).PackedPtrImpl.simpleIndexinout(pure nothrow @trusted std.uni.BitPacked!(uint, 14uL).BitPacked function(ulong))

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

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

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

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

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.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

pure nothrow @trusted void std.uni.PackedPtrImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedPtrImpl.opIndexAssign(uint, 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)*))

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

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

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

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

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

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

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

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

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

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(bool, 1).BitPacked, 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.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:

• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46
• pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(bool, 1).BitPacked, 1uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(bool, 1).BitPacked, ulong, ulong)
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm9Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm9Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.41
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm7Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm7Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.45
• std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm13Vm21Z9sliceBitsTS3std3uni21__T9sliceBitsVm8Vm13Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm8Z9sliceBitsZ.TrieBuilder.addValue.Vm2TbZ.addValue.MFNaNbNebmZv.part.44

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

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

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

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)

const(pure nothrow @trusted bool function(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedArrayViewImpl)) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedArrayViewImpl.opEquals!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedArrayViewImpl).opEquals

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

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

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

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

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

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

std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedArrayViewImpl.__ctorinout(pure nothrow ref @trusted inout(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 7uL).BitPacked, 8uL).PackedArrayViewImpl) function(inout(ulong)*, ulong))

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

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

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

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

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

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

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

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 8uL).BitPacked, 8uL).PackedArrayViewImpl.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)

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)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(7uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 7uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

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

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

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 @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 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 @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.hangLV()

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

Uses:

• 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 @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.mcTrie()

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

const(pure nothrow @trusted bool function(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl)) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 11uL).BitPacked, 16uL).PackedArrayViewImpl).opEquals

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

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

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

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

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

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

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

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

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

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

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

const(pure nothrow @trusted bool function(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl)) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 12uL).BitPacked, 16uL).PackedArrayViewImpl).opEquals

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

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

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

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

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

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

Used by:

• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(9uL, 21uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(0uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)

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

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

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

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

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

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

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

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

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, 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.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 13uL).BitPacked, 16uL).PackedArrayViewImpl.opSliceAssign(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong, ulong)

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

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

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

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

const(pure nothrow @trusted bool function(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl)) std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl.opEquals!(std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 14uL).BitPacked, 16uL).PackedArrayViewImpl).opEquals

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pure nothrow @trusted void std.uni.PackedArrayViewImpl!(std.uni.BitPacked!(uint, 15uL).BitPacked, 16uL).PackedArrayViewImpl.opIndexAssign(std.uni.BitPacked!(uint, 15uL).BitPacked, 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.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.TrieBuilder!(bool, dchar, 1114112, std.uni.sliceBits!(14uL, 21uL).sliceBits, std.uni.sliceBits!(10uL, 14uL).sliceBits, std.uni.sliceBits!(6uL, 10uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(2uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, 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)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)
• pure nothrow @trusted void std.uni.TrieBuilder!(ubyte, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.addValue!(1uL, std.uni.BitPacked!(uint, 15uL).BitPacked).addValue(std.uni.BitPacked!(uint, 15uL).BitPacked, ulong)

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

@trusted dchar std.uni.compose(dchar, dchar)

Used by:

• @trusted ulong std.uni.recompose(ulong, dchar[], ubyte[])

Uses:

• std.algorithm.MapResult.S573std10functional30__T8unaryFunVAyaa5_612e726873Z8unaryFunTAyS3std8internal14unicode_tables9CompEntryZ.MapResult.opIndex.MFNaNbNfmZyw.part.38
• _d_array_bounds
• @property immutable(std.internal.unicode_tables.CompEntry[]) std.internal.unicode_comp.compositionTable()

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.hangLVT()

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

Used by:

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

Uses:

• 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

@trusted bool std.uni.isJamoL(dchar)

@trusted bool std.uni.isJamoT(dchar)

@trusted bool std.uni.isJamoV(dchar)

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

Used by:

• pure nothrow bool std.uni.isUniLower(dchar)

Uses:

• 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!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.opIndex!().opIndex
• pure nothrow @safe bool std.ascii.isASCII(dchar)
• pure nothrow @safe bool std.ascii.isLower(dchar)

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

Uses:

• pure nothrow @safe bool std.internal.unicode_tables.isSpaceGen(dchar)

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

Used by:

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

Uses:

• pure nothrow @safe bool std.ascii.isUpper(dchar)
• 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!(9uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 9uL).sliceBits).Trie.opIndex!().opIndex
• pure nothrow @safe bool std.ascii.isASCII(dchar)

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)
• pure @safe int std.internal.uni.comparePropertyName!(char).comparePropertyName(const(char)[], const(char)[])

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 nothrow @safe dchar std.uni.toUniLower(dchar)
• pure long std.string.indexOf!(char, char).indexOf(const(char)[], const(char)[], std.string.CaseSensitive).pure const(char)[] __T16simpleMindedFindS853std6string16__T7indexOfTaTaZ7indexOfFNaAxaAxaE3std6string13CaseSensitiveZl9__lambda4TAxaTAxaZ.simpleMindedFind(const(char)[], const(char)[])
• pure @safe int std.internal.uni.comparePropertyName!(char).comparePropertyName(const(char)[], const(char)[])
• 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 @property @safe immutable(uint[]) std.internal.unicode_tables.toLowerTable()

pure @safe immutable(char)[] std.uni.toLower(immutable(char)[])

Used by:

• std.datetime.Month std.datetime.monthFromString(immutable(char)[])

Uses:

• _aApplycd2

pure @safe immutable(wchar)[] std.uni.toLower(immutable(wchar)[])

Uses:

• _aApplywd2

pure @safe immutable(dchar)[] std.uni.toLower(immutable(dchar)[])

Uses:

• pure @trusted immutable(dchar)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, immutable(dchar)[]).toCase(immutable(dchar)[])

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

Used by:

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

Uses:

• pure nothrow @property @safe immutable(uint[]) std.internal.unicode_tables.toUpperTable()
• pure nothrow @trusted ushort std.uni.toUpperIndex(dchar)

pure @safe immutable(char)[] std.uni.toUpper(immutable(char)[])

Uses:

• _aApplycd2

pure @safe immutable(wchar)[] std.uni.toUpper(immutable(wchar)[])

Uses:

• _aApplywd2

pure @safe immutable(dchar)[] std.uni.toUpper(immutable(dchar)[])

Uses:

• pure @trusted immutable(dchar)[] std.uni.toCase!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, immutable(dchar)[]).toCase(immutable(dchar)[])

@safe bool std.uni.unicode.findAny(immutable(char)[])

Uses:

• pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[]))
• @safe bool std.uni.findSetName!(_D3std8internal14unicode_tables8uniProps3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))
• pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[])
• @safe bool std.uni.findSetName!(_D3std8internal14unicode_tables7scripts3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findSetName(const(char[]))
• _d_array_bounds
• @trusted long std.uni.findUnicodeSet!(_D3std8internal14unicode_tables6blocks3tabFNdNfZAyS3std8internal14unicode_tables15UnicodeProperty, char).findUnicodeSet(const(char[]))

pure nothrow @safe void std.uni.write24(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))

const(pure nothrow @safe bool function(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opEquals!(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

pure @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opIndexAssign(uint, ulong)

Uses:

• _d_newarrayT
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])

pure @property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.back(uint)

Uses:

• _d_newarrayT
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.back

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

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.empty

pure @property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.front(uint)

Uses:

• _d_newarrayT
• pure ubyte[] std.algorithm.copy!(ubyte[], ubyte[]).copy(ubyte[], ubyte[])

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.front

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.length

const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.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:

• pure @trusted ulong std.uni.InversionList!(std.uni.GcPolicy).InversionList.addInterval(int, int, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.opDollar

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array).SliceOverIndexed.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 @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 @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)*)

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

const(pure nothrow @safe bool function(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!(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

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.back

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

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.length

const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.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)

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

pure nothrow @safe void std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array)).SliceOverIndexed.popFront()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 @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*)
• std.algorithm.copy.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)
• std.algorithm.copy.TS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultTS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZ.copy.FNaS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11genericImplFS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result
• std.algorithm.copy.TAiTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFAiS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed

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 @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 @property @trusted std.uni.InversionList!(std.uni.GcPolicy).InversionList std.uni.InversionList!(std.uni.GcPolicy).InversionList.inverted()

Uses:

• pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)
• 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*)
• std.algorithm.copy.TAkTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFAkS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• std.algorithm.copy.TS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ.copy.FNaS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed11genericImplFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexed
• pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)
• std.algorithm.copy.TS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultTS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZ.copy.FNaS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result11genericImplFS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6ResultZS3std5range123__T5retroTS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ5retroFS3std3uni83__T16SliceOverIndexedTS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedZ11__T6ResultZ6Result

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

const(pure nothrow @safe bool function(std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed)) std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opEquals!(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

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)

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

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

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

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

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 std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed std.uni.SliceOverIndexed!(std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).SliceOverIndexed.opSlice()

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

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

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 void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(5uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 5uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)
• pure nothrow @trusted void std.uni.TrieBuilder!(ushort, dchar, 1114112, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(6uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 6uL).sliceBits).TrieBuilder.spillToNextPage!(2uL, std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl).spillToNextPage(ref std.uni.PackedArrayViewImpl!(ushort, 16uL).PackedArrayViewImpl)

bool std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed))

const(pure nothrow @safe bool function(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.opEquals!(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed).opEquals

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed))) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed)).opEquals

@safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.opIndexAssign(uint, ulong)

Uses:

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

@property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.back(uint)

Uses:

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

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.back

std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.empty

@property @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.front(uint)

Uses:

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

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.front

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.length

const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.opIndex

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.opSlice()

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.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.opDollar

pure nothrow @safe void std.uni.SliceOverIndexed!(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array).SliceOverIndexed.popFront()

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

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

pure nothrow @trusted ubyte[] std.uni.GcPolicy.alloc!(ubyte).alloc(ulong)

Uses:

• _d_newarrayT

pure nothrow @trusted ubyte[] std.uni.GcPolicy.realloc!(ubyte).realloc(ubyte[], ulong)

Uses:

• _d_arraysetlengthT

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

@trusted void std.uni.Grapheme.__postblit()

Uses:

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

@trusted void std.uni.Grapheme.__postblit().pure nothrow @safe const(char)[] __dgliteral1()

pure nothrow @property @trusted ulong std.uni.Grapheme.smallLength()

@trusted void std.uni.Grapheme.convertToBig()

Uses:

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

@trusted void std.uni.Grapheme.convertToBig().pure nothrow @safe const(char)[] __dgliteral1()

ref @trusted std.uni.Grapheme std.uni.Grapheme.__ctor!(int).__ctor(const(int[])...)

Uses:

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

ref @trusted std.uni.Grapheme std.uni.Grapheme.__ctor!(dchar).__ctor(const(dchar[])...)

Uses:

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

pure nothrow @trusted void std.uni.Grapheme.opIndexAssign(dchar, ulong)

ref @trusted std.uni.Grapheme std.uni.Grapheme.opOpAssign!("~").opOpAssign(dchar)

Used by:

• @trusted std.uni.Grapheme std.uni.decomposeHangul(dchar)

Uses:

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

std.uni.Grapheme.opOpAssign.VAyaa1_7eZ.opOpAssign.MFNcNewZS3std3uni8Grapheme12__dgliteral2MFNaNbNfZAxa

ref @trusted std.uni.Grapheme std.uni.Grapheme.opOpAssign!("~", const(int)[]).opOpAssign(const(int)[])

Uses:

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

ref @trusted std.uni.Grapheme std.uni.Grapheme.opOpAssign!("~", const(dchar)[]).opOpAssign(const(dchar)[])

Uses:

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

const(pure nothrow @property @trusted ubyte function()) std.uni.Grapheme.isBig

@trusted void std.uni.Grapheme.__dtor()

Uses:

• free@plt

const(pure nothrow @property @trusted ulong function()) std.uni.Grapheme.length

@trusted void std.uni.Grapheme.setBig()

const(pure nothrow @trusted dchar function(ulong)) std.uni.Grapheme.opIndex

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed std.uni.Grapheme.opSlice()

pure nothrow @trusted std.uni.SliceOverIndexed!(std.uni.Grapheme).SliceOverIndexed std.uni.Grapheme.opSlice(ulong, ulong)

const(@trusted void function(ref const(std.uni.Grapheme))) std.uni.Grapheme.__cpctor

Uses:

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

ref @trusted std.uni.Grapheme std.uni.Grapheme.opAssign(std.uni.Grapheme)

Uses:

• free@plt

pure @trusted ulong std.uni.encodeTo(char[], ulong, dchar)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, char).toCaseInPlace(ref char[])
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(char).toCaseInPlaceAlloc(ref char[], ulong, ulong)
• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, char).toCaseInPlace(ref char[])
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(char).toCaseInPlaceAlloc(ref char[], ulong, ulong)

Uses:

• abort@plt

pure @trusted ulong std.uni.encodeTo(wchar[], ulong, dchar)

Used by:

• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051, _D3std3uni10toUpperTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043u, _D3std3uni10toLowerTabFNaNbNemZw).toCaseInPlaceAlloc!(wchar).toCaseInPlaceAlloc(ref wchar[], ulong, ulong)
• pure @trusted void std.uni.toCaseInPlace!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, wchar).toCaseInPlace(ref wchar[])
• pure @trusted void std.uni.toCaseInPlaceAlloc!(_D3std3uni12toUpperIndexFNaNbNewZt, 1051u, _D3std3uni10toUpperTabFNaNbNemZw).toCaseInPlaceAlloc!(wchar).toCaseInPlaceAlloc(ref wchar[], ulong, ulong)

Uses:

• pure nothrow @safe std.utf.UTFException std.utf.UTFException.__ctor(immutable(char)[], immutable(char)[], ulong, object.Throwable)
• _d_throw
• abort@plt
• _d_newclass

pure @trusted ulong std.uni.encodeTo(dchar[], ulong, dchar)

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

Uses:

• pure nothrow @safe bool std.internal.unicode_tables.isFormatGen(dchar)

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

Uses:

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

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

Uses:

• 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 @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.markTrie()

pure nothrow @safe uint std.uni.midlow_8(uint)

bool std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.__xopEquals(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed), ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed))

const(pure nothrow @safe bool function(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.opEquals!(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed).opEquals

const(pure nothrow @safe bool function(ref const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed))) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.opEquals!(const(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed)).opEquals

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.back

std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.saveinout(pure nothrow @property @safe inout(std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed) function())

const(pure nothrow @property @safe bool function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.empty

const(pure nothrow @property @safe uint function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.front

const(pure nothrow @property @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.length

const(pure nothrow @safe uint function(ulong)) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.opIndex

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.opSlice()

pure nothrow @safe std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.opSlice(ulong, ulong)

pure nothrow @safe void std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.popBack()

const(pure nothrow @safe ulong function()) std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.opDollar

pure nothrow @safe void std.uni.SliceOverIndexed!(const(std.uni.Uint24Array!(std.uni.ReallocPolicy).Uint24Array)).SliceOverIndexed.popFront()

pure nothrow @safe std.uni.BitPacked!(uint, 7uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 7uL).BitPacked, std.uni.BitPacked!(uint, 7uL).BitPacked).force(std.uni.BitPacked!(uint, 7uL).BitPacked)

pure nothrow @safe std.uni.BitPacked!(uint, 8uL).BitPacked std.uni.force!(std.uni.BitPacked!(uint, 8uL).BitPacked, std.uni.BitPacked!(uint, 8uL).BitPacked).force(std.uni.BitPacked!(uint, 8uL).BitPacked)

pure @trusted const(char)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, const(char)[]).toCase(const(char)[])

Uses:

• _aApplycd2

pure @trusted const(char)[] std.uni.toCase!(_D3std3uni12toLowerIndexFNaNbNewZt, 1043, _D3std3uni10toLowerTabFNaNbNemZw, const(char)[]).toCase(const(char)[]).@safe int __foreachbody2(ref ulong, ref dchar)

Uses:

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