// from the beginning of the trace until now.
				mi, pi := 0, 0
				for mi < len(out[0]) {
					if pi < len(procs)-1 && procs[pi+1].time < out[0][mi].Time {
						pi++
						continue
					}
					out[0][mi].Util -= float64(1) / float64(procs[pi].n)
					if out[0][mi].Util < 0 {
						out[0][mi].Util = 0
					}
					mi++
				}
			}

	state := enc.newEncoderState(b)
	state.fieldnum = -1
	state.sendZero = true
	state.encodeUint(uint64(mv.Len()))
	mi := mv.MapRange()
	for mi.Next() {
		encodeReflectValue(state, mi.Key(), keyOp, keyIndir)
		encodeReflectValue(state, mi.Value(), elemOp, elemIndir)
	}
	enc.freeEncoderState(state)
}

// encodeInterface encodes the interface value iv.

// using the index, for instance because the index is disabled, or the package
// is not in a module.
func GetPackage(modroot, pkgdir string) (*IndexPackage, error) {
	mi, err := GetModule(modroot)
	if err == nil {
		return mi.Package(relPath(pkgdir, modroot)), nil
	}
	if !errors.Is(err, errNotFromModuleCache) {
		return nil, err
	}

	// Extract and sort the keys.
	var (
		sv  = make([]reflectWithString, v.Len())
		mi  = v.MapRange()
		err error
	)
	for i := 0; mi.Next(); i++ {
		if sv[i].ks, err = resolveKeyName(mi.Key()); err != nil {
			e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
		}
		sv[i].v = mi.Value()
	}
	slices.SortFunc(sv, func(i, j reflectWithString) int {

000002f0  85 a4 cc dc b8 12 1b eb  0a bc bc bd 1c 2f 51 0e  |............./Q.|
00000300  8f 55 f1 10 22 06 ca cb  f2 97 54 63 1c 98 36 9f  |.U..".....Tc..6.|
00000310  1d 66 b0 17 03 03 00 99  f0 14 4d 69 84 b3 ca d4  |.f........Mi....|
00000320  96 9c e2 3c a4 55 f4 b6  01 1f 1e 1f 77 98 c4 84  |...<.U......w...|
00000330  5e ce 4c 0b bf ba 39 6b  36 a6 15 9c d1 90 87 d1  |^.L...9k6.......|

		_ = me[panicStructKey]
	})
	mustPanic(func() {
		_ = me[sli]
	})
	mustPanic(func() {
		_ = me[me]
	})

	mustNotPanic(func() {
		_ = mi[structKey]
	})
	mustPanic(func() {
		_ = mi[panicStructKey]
	})
}

func TestLoadFactor(t *testing.T) {
	for b := uint8(0); b < 20; b++ {
		count := 13 * (1 << b) / 2 // 6.5
		if b == 0 {
			count = 8
		}

000000f0  da d4 27 97 2c da da 2c  c8 e7 e5 c2 6b 24 5f dd  |..'.,..,....k$_.|
00000100  68 86 b1 9b 01 95 8a 78  bb 10 26 66 24 d4 59 df  |h......x..&f$.Y.|
00000110  6d b4 56 c4 23 56 5d 3c  fc 6d 69 ce eb e2 9c 30  |m.V.#V]<.mi....0|
00000120  da 34 39 32 80 a7 26 d6  e2 11 33 a5 c1 5d 75 07  |.492..&...3..]u.|
00000130  f5 f6 98 9e f2 26 49 96  52 fb 56 6d 34 67 45 15  |.....&I.R.Vm4gE.|

	debugModFromModinfo = func(mi *modinfo.ModulePublic) *debug.Module {
		version := mi.Version
		if version == "" {
			version = "(devel)"
		}
		dm := &debug.Module{
			Path:    mi.Path,
			Version: version,
		}
		if mi.Replace != nil {
			dm.Replace = debugModFromModinfo(mi.Replace)
		} else if mi.Version != "" && cfg.BuildMod != "vendor" {

00000200  80 ce 8e bd e4 bb 45 01  c4 6b 43 f1 44 0a 5f 21  |......E..kC.D._!|
00000210  76 48 ae ce 8e 1d ba f7  7c 4f ae a2 d8 77 ce 9c  |vH......|O...w..|
00000220  6d 69 b7 1e 78 ab 02 ed  15 17 03 03 00 a3 84 ed  |mi..x...........|
00000230  ba 37 b6 6f 96 68 ef 9e  b7 c6 23 5a 9f 1b ed ad  |.7.o.h....#Z....|
00000240  3b 5d ab d4 22 d8 3e ab  db db c5 b9 57 f8 68 d1  |;]..".>.....W.h.|

	// tparams holds the type parameters of the callee and generic function arguments, if any:
	// the first n type parameters belong to the callee, followed by mi type parameters for each
	// of the generic function arguments, where mi = args[i].typ.(*Signature).TypeParams().Len().

	// infer missing type arguments of callee and function arguments
	if len(tparams) > 0 {
		err := check.newError(CannotInferTypeArgs)