"(*mspan).allocBitsForIndex",
			"(*mspan).base",
			"(*mspan).markBitsForBase",
			"(*mspan).markBitsForIndex",
			"(*mspan).writeUserArenaHeapBits",
			"(*muintptr).set",
			"(*puintptr).set",
			"(*wbBuf).get1",
			"(*wbBuf).get2",

			// Trace-related ones.
			"traceLocker.ok",
			"traceEnabled",
		},
		"runtime/internal/sys": {},
		"runtime/internal/math": {
			"MulUintptr",
		},
		"bytes": {

// it called anything) has to be nosplit to avoid scheduling on to a
// different P and a different buffer.
//
//go:nowritebarrierrec
//go:nosplit
func (b *wbBuf) get1() *[1]uintptr {
	if b.next+goarch.PtrSize > b.end {
		wbBufFlush()
	}
	p := (*[1]uintptr)(unsafe.Pointer(b.next))
	b.next += goarch.PtrSize
	return p
}

//go:nowritebarrierrec
//go:nosplit

	// Check pv cache
	pvCache := env.internalBinder.pvCache
	for _, b := range bindings {
		pv, err := pvCache.GetPV(b.pv.Name)
		if err != nil {
			t.Errorf("GetPV %q returned error: %v", b.pv.Name, err)
			continue
		}
		if pv.Spec.ClaimRef == nil {
			t.Errorf("PV %q ClaimRef is nil", b.pv.Name)
			continue
		}

	getPC := debugInfo.GetPC

	if ctxt.UseBASEntries {
		listSym.WriteInt(ctxt, listSym.Size, ctxt.Arch.PtrSize, ^0)
		listSym.WriteAddr(ctxt, listSym.Size, ctxt.Arch.PtrSize, startPC, 0)
	}

	// Re-read list, translating its address from block/value ID to PC.
	for i := 0; i < len(list); {
		begin := getPC(decodeValue(ctxt, readPtr(ctxt, list[i:])))

	if len(boundClaims) == 0 {
		return
	}

	var errs []error
	for _, pvc := range boundClaims {
		pvName := pvc.Spec.VolumeName
		pv, err := b.pvCache.GetPV(pvName)
		if err != nil {
			errs = append(errs, err)
			continue
		}

		// if the PersistentVolume is local and has node affinity matching specific node(s),
		// add them to the eligible nodes

		tp = s.typePointersOf(dst, size)
	}
	if src == 0 {
		for {
			var addr uintptr
			if tp, addr = tp.next(dst + size); addr == 0 {
				break
			}
			dstx := (*uintptr)(unsafe.Pointer(addr))
			p := buf.get1()
			p[0] = *dstx
		}
	} else {
		for {
			var addr uintptr
			if tp, addr = tp.next(dst + size); addr == 0 {
				break
			}
			dstx := (*uintptr)(unsafe.Pointer(addr))

                            SmallVectorImpl<int64_t>& s0_shape,
                            SmallVectorImpl<int64_t>& s1_shape) {
  if (!matchPattern(op.getS0(), m_Constant(&s0))) return false;
  if (!matchPattern(op.getS1(), m_Constant(&s1))) return false;

  for (auto s : s0.getValues<APInt>()) s0_shape.push_back(s.getSExtValue());
  for (auto s : s1.getValues<APInt>()) s1_shape.push_back(s.getSExtValue());

  return true;
}

    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("response body")
    val get1 = server.takeRequest()
    assertThat(get1.requestLine).isEqualTo("GET http://android.com/foo HTTP/1.1")
    assertThat(get1.headers["Proxy-Authorization"]).isNull()
    val get2 = server.takeRequest()
    assertThat(get2.requestLine).isEqualTo("GET http://android.com/foo HTTP/1.1")

		// lists. At the moment, Prog.Pc is a sequence number; it's not a real PC
		// until after assembly, so the translation needs to be deferred.
		debugInfo.GetPC = func(b, v ssa.ID) int64 {
			switch v {
			case ssa.BlockStart.ID:
				if b == f.Entry.ID {
					return 0 // Start at the very beginning, at the assembler-generated prologue.