}
		case "ModTime":
			z.ModTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "ModTime")
				return
			}
		case "index":
			z.Index, err = dc.ReadBytes(z.Index)
			if err != nil {
				err = msgp.WrapError(err, "Index")
				return
			}
		case "crc":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Checksums")

		bitrotReaders := make([]io.ReaderAt, len(disks))
		for index, disk := range disks {
			if disk == OfflineDisk {
				continue
			}
			tillOffset := erasure.ShardFileOffset(test.offset, test.length, test.data)

			bitrotReaders[index] = newBitrotReader(disk, nil, "testbucket", "object", tillOffset, writeAlgorithm, bitrotWriterSum(writers[index]), erasure.ShardSize())
		}

		writer := bytes.NewBuffer(nil)

func SplitStoredHashIndex(index int64) (level int, n int64) {
	// Determine level 0 record before index.
	// StoredHashIndex(0, n) < 2*n,
	// so the n we want is in [index/2, index/2+log₂(index)].
	n = index / 2
	indexN := StoredHashIndex(0, n)
	if indexN > index {
		panic("bad math")
	}
	for {
		// Each new record n adds 1 + trailingZeros(n) hashes.
		x := indexN + 1 + int64(bits.TrailingZeros64(uint64(n+1)))

	return Workloads
}

func (a *index) workloadEntryWorkloadBuilder(
	MeshConfig krt.Singleton[MeshConfig],
	AuthorizationPolicies krt.Collection[model.WorkloadAuthorization],
	PeerAuths krt.Collection[*securityclient.PeerAuthentication],
	Waypoints krt.Collection[Waypoint],
	WorkloadServices krt.Collection[model.ServiceInfo],
	WorkloadServicesNamespaceIndex *krt.Index[model.ServiceInfo, string],

	for _, obj := range slices {
		slice := obj.(*resourceapi.ResourceSlice)
		if slice.DriverName != driverName {
			continue
		}

		index := indexOfModel(driverResources, &slice.ResourceModel)
		if index >= 0 {
			storedResourceIndices.Insert(index)
			continue
		}

		obsoleteSlices = append(obsoleteSlices, slice)
	}

	if loggerV := logger.V(6); loggerV.Enabled() {

		return false
	}

	// First string is empty, so check if the second one is also empty.
	return len(t) == 0
}

// Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.
func Index(s, substr string) int {
	return stringslite.Index(s, substr)
}

// Cut slices s around the first instance of sep,
// returning the text before and after sep.

// The effective memory address is R or R+X depending on Index, Extend and Amount.
type MemExtend struct {
	Base   RegSP
	Index  Reg
	Extend ExtShift
	// Amount indicates the index shift amount (but also see ShiftMustBeZero field below).
	Amount uint8
	// Refer to ARM reference manual, for byte load/store(register), the index

	// put dynamics into array (5)
	var index int64
	for _, value := range n.List {
		if value.Op() == ir.OKEY {
			kv := value.(*ir.KeyExpr)
			index = typecheck.IndexConst(kv.Key)
			if index < 0 {
				base.Fatalf("slicelit: invalid index %v", kv.Key)
			}
			value = kv.Value
		}
		a := ir.NewIndexExpr(base.Pos, vauto, ir.NewInt(base.Pos, index))
		a.SetBounded(true)
		index++

		// TODO need to check bounds?

		},
	}

	// after adding an index with a different key, first key is evicted, idexes should contain only secondEntry
	c.Add(secondEntry.Key(), secondEntry, req, res)

	assert.Equal(t, cache.store.Len(), 1)

	// Flush the cache and validate the index is cleaned.
	cache.Flush()
	assert.Equal(t, cache.indexLength(), 2)

	}

	errStr := ""
	var wg sync.WaitGroup
	for index := range globalNotificationSys.peerClients {
		if globalNotificationSys.peerClients[index] == nil {
			continue
		}
		go func(index int) {
			for i := 0; i < connectionsPerPeer; i++ {
				wg.Add(1)
				go func() {
					defer wg.Done()
					err := globalNotificationSys.peerClients[index].DevNull(ctx, r)
					if err != nil {