GraphViz .dot file

Jump to D main()


TypeInfo_Ah.__init

Used by:

TypeInfo_Axa.__init

Used by:

TypeInfo_Aya.__init

Used by:

TypeInfo_AAya.__init

Used by:

TypeInfo_S3std5stdio4File.__init

Used by:

TypeInfo_AS3std4file8DirEntry.__init

Used by:

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:

void gc.gc.GC.initialize()

Uses:

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

Uses:

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

ulong gc.gc.GC.fullCollect()

Uses:

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

Uses:

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

Uses:

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

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

Uses:

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

Used by:

Uses:

byte[72] gc.gc.GC.mutexStorage

Used by:

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

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

Used by:

Uses:

ulong gc.gc.GC.reserveNoSync(ulong)

Uses:

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

void gc.gc.GC.fullCollectNoStack()

Uses:

void gc.gc.GC.Dtor()

Uses:

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

Uses:

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

Uses:

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

Uses:

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

Uses:

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

Uses:

void gc.gc.GC.enable()

Uses:

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

Uses:

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

Used by:

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

Uses:

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

Uses:

gc.gc.GC.__Class

Used by:

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

Uses:

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

Uses:

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

Used by:

Uses:

void gc.gc.GC.disable()

Uses:

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

Uses:

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

Used by:

Uses:

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

Uses:

ulong gc.gc.GC.reserve(ulong)

Uses:

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

Uses:

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

Used by:

Uses:

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

Uses:

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

Uses:

void gc.gc.GC.minimize()

Uses:

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

Uses:

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

Uses:

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:

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

ubyte gc.gc.Gcx.findBinImpl(ulong)

ulong gc.gc.Gcx.fullcollect()

Used by:

Uses:

void gc.gc.Gcx.log_collect()

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

Uses:

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:

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

Uses:

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

Used by:

Uses:

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

Uses:

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:

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

Uses:

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

Uses:

ulong gc.gc.Gcx.reserve(ulong)

Uses:

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

Uses:

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

Uses:

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

Uses:

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:

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

void gc.gc.Gcx.log_init()

void gc.gc.Gcx.minimize()

Uses:

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.Pool.initialize(ulong, bool)

Uses:

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:

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:

gc.gc.GCMutex.__Class

Used by:

void gc.gc.__modinit()

Uses:

void* gc.os.os_mem_map(ulong)

Used by:

Uses:

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

Used by:

Uses:

void gc.os.__modinit()

Uses:

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

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

void gc.bits.GCBits.set(ulong)

Used by:

void gc.bits.GCBits.Dtor()

Used by:

Uses:

ulong* gc.bits.GCBits.base()

Used by:

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

Used by:

Uses:

ulong gc.bits.GCBits.test(ulong)

Used by:

void gc.bits.GCBits.zero()

Used by:

Uses:

void gc.bits.GCBits.alloc(ulong)

Used by:

Uses:

void gc.bits.GCBits.clear(ulong)

ulong gc.bits.GCBits.testSet(ulong)

Used by:

ulong gc.bits.GCBits.testClear(ulong)

Used by:

void gc.bits.__modinit()

Uses:

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

Uses:

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

Uses:

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

Uses:

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

Uses:

gc.gc.GC gc.proxy._gc

Used by:

gc.proxy.Proxy* gc.proxy.proxy

Used by:

gc.proxy.Proxy gc.proxy.pthis

Used by:

void gc.proxy.__modinit()

Uses:

void gc.proxy.initProxy()

Used by:

Uses:

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

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

Uses:

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

Uses:

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:

void rt.aaA.__modinit()

Uses:

void rt.adi.__modinit()

Uses:

void rt.deh.__modinit()

Uses:

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

Used by:

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

Uses:

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

Uses:

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

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

Uses:

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:

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

Uses:

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

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Uses:

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:

Uses:

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

Uses:

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

Uses:

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

Uses:

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

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

Used by:

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

Uses:

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

Uses:

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

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

Used by:

Uses:

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

Used by:

Uses:

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

Uses:

void rt.util.utf.__modinit()

Uses:

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

Used by:

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

void rt.util.hash.__modinit()

Uses:

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

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

Used by:

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

Used by:

Uses:

void rt.util.string.__modinit()

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

void rt.util.console.__modinit()

Uses:

void rt.cast_.__modinit()

Uses:

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

Uses:

void rt.minfo.ModuleGroup.runTlsCtors()

Uses:

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

Uses:

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

Used by:

Uses:

void rt.minfo.ModuleGroup.runTlsDtors()

Uses:

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

Uses:

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

Used by:

Uses:

void rt.minfo.ModuleGroup.free()

Uses:

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 nothrow void function()* __lambda1!(object.ModuleInfo*).__lambda1(object.ModuleInfo*)

Uses:

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

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

void rt.minfo.ModuleGroup.runDtors()

Uses:

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

Uses:

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

Used by:

Uses:

void rt.minfo.ModuleGroup.sortCtors()

Uses:

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

Used by:

Uses:

rt.minfo.ModuleGroup.sortCtors.MFZv8StackRec11__xopEqualsFKxS2rt5minfo11ModuleGroup9sortCtorsMFZv8StackRecKxS2rt5minfo11ModuleGroup9sortCtorsMFZv8StackRecZb

Uses:

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

Used by:

Uses:

void rt.minfo.__modinit()

Uses:

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

void rt.qsort.__modinit()

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

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

Used by:

Uses:

void rt.tlsgc.__modinit()

Uses:

void rt.aApply.__modinit()

Uses:

shared(ulong) rt.dmain2._initCount

Used by:

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

Uses:

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:

Uses:

void rt.dmain2.printThrowable(object.Throwable)

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Uses:

rt.dmain2.CArgs rt.dmain2._cArgs

Used by:

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

Used by:

void rt.dmain2.__modinit()

Uses:

void rt.memory.initStaticDataGC()

Used by:

Uses:

void rt.memory.__modinit()

Uses:

void rt.aApplyR.__modinit()

Uses:

void rt.switch_.__modinit()

Uses:

void rt.arraycat.__modinit()

Uses:

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

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

Used by:

Uses:

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:

Uses:

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

Used by:

Uses:

void rt.lifetime._staticDtor1()

Uses:

bool function(Object)* rt.lifetime.collectHandler

Used by:

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

Used by:

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

Used by:

Uses:

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

Used by:

Uses:

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)

Used by:

Uses:

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)

Used by:

Uses:

void rt.lifetime.__modinit()

Uses:

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

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

int rt.monitor_.inited

Used by:

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

Uses:

void rt.monitor_.__modinit()

Uses:

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

Uses:

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

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

void rt.typeinfo.ti_idouble.__modinit()

Uses:

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:

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:

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:

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

Uses:

void rt.typeinfo.ti_AC.__modinit()

Uses:

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:

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:

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

Uses:

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:

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:

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:

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:

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:

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

Uses:

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:

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:

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:

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:

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

void rt.typeinfo.ti_long.__modinit()

Uses:

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

Uses:

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

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:

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:

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

void rt.typeinfo.ti_void.__modinit()

Uses:

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:

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:

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

Uses:

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:

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

Uses:

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

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

Uses:

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:

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

Uses:

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

void rt.typeinfo.ti_float.__modinit()

Uses:

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

void rt.typeinfo.ti_ireal.__modinit()

Uses:

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:

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:

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:

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

void rt.typeinfo.ti_ulong.__modinit()

Uses:

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

Uses:

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:

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:

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

Uses:

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

Uses:

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

Uses:

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:

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:

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:

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

Uses:

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:

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

Uses:

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

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

Uses:

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

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

void rt.typeinfo.ti_ifloat.__modinit()

Uses:

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:

void rt.arraycast.__modinit()

Uses:

rt.critical_.critsec_t* rt.critical_.dcs_list

Used by:

void rt.critical_.__modinit()

Uses:

TypeInfo_S3std4file15DirIteratorImpl.__init

Used by:

TypeInfo_AS3std3uni17CodepointInterval.__init

Used by:

void gcc.deh.__gdc_terminate()

Uses:

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

Used by:

Uses:

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

Uses:

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

Used by:

Uses:

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:

Uses:

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:

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

Used by:

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

Used by:

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

Used by:

Uses:

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

Used by:

Uses:

uint gcc.unwind.pe.size_of_encoded_value(ubyte)

Used by:

Uses:

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

Used by:

Uses:

void gcc.unwind.pe.__modinit()

Uses:

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:

void gcc.builtins.__modinit()

Uses:

void gcc.gthreads.posix.__modinit()

Uses:

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

Used by:

Uses:

void gcc.backtrace.LibBacktrace.initLibBacktrace()

Uses:

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

Used by:

Uses:

gcc.backtrace.LibBacktrace.__Class

Used by:

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

Uses:

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

Used by:

Uses:

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

Uses:

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

Used by:

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:

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

Uses:

void gcc.backtrace.SymbolCallbackInfo.reset()

void gcc.backtrace.__modinit()

Uses:

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:

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 bool std.functional.binaryFun!("a == b").binaryFun!(dchar, char).binaryFun(dchar, char)

Used by:

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:

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:

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:

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:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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:

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:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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:

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:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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:

Uses:

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

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:

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

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

Uses:

pure nothrow bool std.uni.isUniLower(dchar)

Uses:

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

Uses:

pure nothrow @property @safe immutable(std.uni.Trie!(std.uni.BitPacked!(bool, 1).BitPacked, dchar, 1114112uL, std.uni.sliceBits!(13uL, 21uL).sliceBits, std.uni.sliceBits!(8uL, 13uL).sliceBits, std.uni.sliceBits!(0uL, 8uL).sliceBits).Trie) std.uni.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:

Uses:

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

Uses:

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

Uses:

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

Uses:

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

Uses:

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:

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

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

Used by:

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)

Used by:

Uses:

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:

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:

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

Uses:

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:

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:

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:

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

Uses:

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

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

Used by:

Uses:

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:

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

Used by:

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

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

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:

@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.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:

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

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:

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

@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.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.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:

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

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:

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:

Uses:

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

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

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:

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

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:

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

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:

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

@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.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.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:

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

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:

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:

Uses:

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

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

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:

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

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:

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

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:

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

@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.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.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:

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

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:

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

Uses:

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

Used by:

Uses:

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

Used by:

Uses:

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

Uses:

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

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

Uses:

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

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:

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:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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:

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:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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:

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:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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:

Uses:

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:

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 @safe void std.uni.toLowerInPlace(ref wchar[])

Uses:

pure @safe void std.uni.toLowerInPlace(ref dchar[])

Uses:

pure @safe void std.uni.toUpperInPlace(ref char[])

Uses:

pure @safe void std.uni.toUpperInPlace(ref wchar[])

Uses:

pure @safe void std.uni.toUpperInPlace(ref dchar[])

Uses:

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:

Uses:

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

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:

Uses:

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

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:

Uses:

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

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

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

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:

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)

Used by:

Uses:

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

Used by:

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.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

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.addValue!(1uL, std.uni.BitPacked!(uint, 14uL).BitPacked).addValue(std.uni.BitPacked!(uint, 14uL).BitPacked, ulong)

Used by:

Uses:

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:

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:

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

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

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:

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)

Used by:

Uses:

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

Used by:

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.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

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.addValue!(1uL, std.uni.BitPacked!(uint, 13uL).BitPacked).addValue(std.uni.BitPacked!(uint, 13uL).BitPacked, ulong)

Used by:

Uses:

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:

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:

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

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

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:

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

Uses:

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

Used by:

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)

Used by:

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!(1uL, std.uni.BitPacked!(uint, 12uL).BitPacked).addValue(std.uni.BitPacked!(uint, 12uL).BitPacked, ulong)

Used by:

Uses:

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:

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:

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

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

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:

Uses:

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

Used by:

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!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

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)

Used by:

Uses:

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:

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:

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

Uses:

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:

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:

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

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

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:

Uses:

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

Used by:

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.addValue!(0uL, std.uni.BitPacked!(uint, 8uL).BitPacked).addValue(std.uni.BitPacked!(uint, 8uL).BitPacked, ulong)

Used by:

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.addValue!(1uL, std.uni.BitPacked!(uint, 16uL).BitPacked).addValue(std.uni.BitPacked!(uint, 16uL).BitPacked, ulong)

Used by:

Uses:

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:

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:

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

Uses:

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

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

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

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:

Uses:

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

Used by:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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

Uses:

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:

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:

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:

@trusted std.uni.Grapheme std.uni.decomposeHangul(dchar)

Uses:

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

pure @trusted immutable(char)[] std.uni.toLower!(immutable(char)[]).toLower(immutable(char)[])

Uses:

pure @trusted immutable(wchar)[] std.uni.toLower!(immutable(wchar)[]).toLower(immutable(wchar)[])

Uses:

pure @trusted immutable(dchar)[] std.uni.toLower!(immutable(dchar)[]).toLower(immutable(dchar)[])

Uses:

pure @trusted immutable(char)[] std.uni.toUpper!(immutable(char)[]).toUpper(immutable(char)[])

Uses:

pure @trusted immutable(wchar)[] std.uni.toUpper!(immutable(wchar)[]).toUpper(immutable(wchar)[])

Uses:

pure @trusted immutable(dchar)[] std.uni.toUpper!(immutable(dchar)[]).toUpper(immutable(dchar)[])

Uses:

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:

Uses:

pure @trusted int std.uni.icmp!(const(wchar)[], const(wchar)[]).icmp(const(wchar)[], const(wchar)[])

Used by:

Uses:

pure nothrow @trusted int std.uni.icmp!(const(dchar)[], const(dchar)[]).icmp(const(dchar)[], const(dchar)[])

Uses:

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:

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:

Uses:

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:

Uses:

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:

Uses:

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:

Uses:

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:

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:

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

Uses:

pure @trusted int std.uni.sicmp!(const(char)[], const(char)[]).sicmp(const(char)[], const(char)[]).@safe int __foreachbody3(ref dchar)

Uses:

pure @trusted int std.uni.sicmp!(const(wchar)[], const(wchar)[]).sicmp(const(wchar)[], const(wchar)[])

Uses:

pure @trusted int std.uni.sicmp!(const(wchar)[], const(wchar)[]).sicmp(const(wchar)[], const(wchar)[]).@safe int __foreachbody3(ref dchar)

Uses:

pure @trusted int std.uni.sicmp!(const(dchar)[], const(dchar)[]).sicmp(const(dchar)[], const(dchar)[])

Used by:

Uses:

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:

Uses:

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

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:

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:

Uses:

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

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:

Uses:

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:

Uses:

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

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:

Uses:

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:

Uses:

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:

Uses:

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

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

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:

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)

Used by:

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)

Used by:

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!(3uL, bool).addValue(bool, ulong)

Uses:

std.uni.TrieBuilder.TbTwVi1114112TS3std3uni22__T9sliceBitsVm14Vm21Z9sliceBitsTS3std3uni22__T9sliceBitsVm10Vm14Z9sliceBitsTS3std3uni21__T9sliceBitsVm6Vm10Z9sliceBitsTS3std3uni20__T9sliceBitsVm0Vm6Z9sliceBitsZ.TrieBuilder.addValue.Vm3TbZ.addValue.MFNaNbNebmZv.part.46

Used by:

Uses:

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.addValue!(1uL, std.uni.BitPacked!(uint, 11uL).BitPacked).addValue(std.uni.BitPacked!(uint, 11uL).BitPacked, ulong)

Used by:

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)

Used by:

Uses:

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:

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:

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

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:

std.uni.switchUniformLowerBound.S573std10functional29__T9binaryFunVAyaa4_613c3d62Z9binaryFunTS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedTkZ.switchUniformLowerBound.FNaNbNfS3std3uni84__T16SliceOverIndexedTxS3std3uni36__T11Uint24ArrayTS3std3uni8GcPolicyZ11Uint24ArrayZ16SliceOverIndexedkZm

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:

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:

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

@trusted void std.uni.DecompressedIntervals.popFront()

Uses:

std.uni.DecompressedIntervals.popFront.MFNeZv.part.18

Used by:

Uses:

pure nothrow @safe void std.uni.copyBackwards!(ulong).copyBackwards(ulong[], ulong[])

Uses:

std.uni.copyBackwards.TmZ.copyBackwards.FNaNbNfAmAmZv.part.26

Used by:

Uses:

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:

Uses:

pure @trusted int std.uni.fullCasedCmp!(const(wchar)[]).fullCasedCmp(dchar, dchar, ref const(wchar)[])

Used by:

Uses:

pure nothrow @trusted int std.uni.fullCasedCmp!(const(dchar)[]).fullCasedCmp(dchar, dchar, ref const(dchar)[])

Used by:

Uses:

pure @trusted void std.uni.toLowerInPlace!(char).toLowerInPlace(ref char[])

Uses:

pure @trusted void std.uni.toLowerInPlace!(wchar).toLowerInPlace(ref wchar[])

Uses:

pure @trusted void std.uni.toLowerInPlace!(dchar).toLowerInPlace(ref dchar[])

Uses:

pure @trusted void std.uni.toUpperInPlace!(char).toUpperInPlace(ref char[])

Uses:

pure @trusted void std.uni.toUpperInPlace!(wchar).toUpperInPlace(ref wchar[])

Uses:

pure @trusted void std.uni.toUpperInPlace!(dchar).toUpperInPlace(ref dchar[])

Uses:

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:

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:

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:

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:

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:

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:

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:

Uses:

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

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:

Uses:

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

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

Uses:

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

Uses:

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

Uses:

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:

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

Uses:

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

Uses:

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

Uses:

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

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

Uses:

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.0

Used by:

Uses:

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.1

Uses:

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.12

Uses:

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.2

Uses:

std.uni.SliceOverIndexed.TAiZ.SliceOverIndexed.opIndex.MxFNaNbNfmZxi.part.8

Uses:

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:

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 @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[]))

Used by:

Uses:

pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[])).@safe bool __lambda2!(immutable(char)[]).__lambda2(immutable(char)[])

Uses:

pure @safe bool std.uni.isPrettyPropertyName!(char).isPrettyPropertyName(const(char[])).pure @safe immutable(char)[][] __T4findS803std3uni28__T20isPrettyPropertyNameTaZ20isPrettyPropertyNameFNaNfxAaZb9__lambda2TAAyaZ.find(immutable(char)[][])

Used by:

Uses:

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

Used by:

Uses:

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResult11__xopEqualsFKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultKxS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZb

Uses:

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ.MapResult.back()

Uses:

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:

Uses:

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

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure @property @safe dchar __T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ.MapResult.back()

Uses:

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:

Uses:

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 @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 @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe bool __lambda4!(dchar).__lambda4(dchar)

Uses:

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe dchar __lambda5!(dchar).__lambda5(dchar)

Uses:

pure @trusted int std.uni.comparePropertyName!(char, char).comparePropertyName(const(char)[], const(char)[]).pure nothrow @safe bool __lambda6!(dchar).__lambda6(dchar)

Uses:

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:

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult4saveMFNaNdNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda4TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda3TAxaZ9MapResultZ12FilterResult

Uses:

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:

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:

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:

Uses:

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:

std.uni.comparePropertyName.TaTaZ.comparePropertyName.FNaNeAxaAxaZi287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult4saveMFNaNdNfZS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ287__T12FilterResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda6TS3std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFAxaAxaZ102__T9MapResultS813std3uni29__T19comparePropertyNameTaTaZ19comparePropertyNameFNeAxaAxaZi9__lambda5TAxaZ9MapResultZ12FilterResult

Uses:

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:

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:

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:

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:

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

Used by:

Uses:

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

@trusted bool std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__xopEquals(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array), ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))

Uses:

const(pure nothrow @trusted bool function(ref const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

Used by:

Uses:

const(pure nothrow @trusted bool function(const(std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array))) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opEquals!().opEquals

Uses:

pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.opIndexAssign(uint, ulong)

Used by:

Uses:

pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.append!(int[]).append(int[])

Used by:

Uses:

pure @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.dupThisReference(uint)

Uses:

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:

Uses:

const(pure nothrow @property @trusted bool function()) std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.empty

Used by:

pure nothrow @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.__dtor()

Used by:

pure @property @trusted void std.uni.Uint24Array!(std.uni.GcPolicy).Uint24Array.length(ulong)

Used by:

Uses:

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