type LocResults []Location

func (t LocResults) String() string {
	s := ""
	a := "<"
	for _, r := range t {
		a += s
		s = ","
		a += r.String()
	}
	a += ">"
	return a
}

type Spill struct {
	Type   *types.Type
	Offset int64
	Reg    int16

	MOVD	R3, FIXED_FRAME+16(R1)	// addr retvalid (arg2)
	ADD     $LOCAL_REGARGS, R1, R3
	MOVD	R3, FIXED_FRAME+24(R1)	// abiregargs (arg3)
	BL	·callReflect(SB)
	ADD	$LOCAL_REGARGS, R1, R20	// set address of spill area
	CALL	runtime·unspillArgs(SB)
	RET

// methodValueCall is the code half of the function returned by makeMethodValue.
// See the comment on the declaration of methodValueCall in makefunc.go
// for more details.

	//    │ └---- Next 2 bits -> sub-bucket 0
	//    └------- Bit 10 set -> bucket 2
	//
	// Following this pattern, bucket 38 will have the bit 46 set. We don't
	// have any buckets for higher values, so we spill the rest into an overflow
	// bucket containing values of 2^47-1 nanoseconds or approx. 1 day or more.
	// This range is more than enough to handle durations produced by the runtime.
	timeHistMinBucketBits = 9

	}
	if g := p.Get(); g != "b" {
		t.Fatalf("got %#v; want b", g)
	}
	if g := p.Get(); g != nil {
		t.Fatalf("got %#v; want nil", g)
	}
	Runtime_procUnpin()

	// Put in a large number of objects so they spill into
	// stealable space.
	for i := 0; i < 100; i++ {
		p.Put("c")
	}
	// After one GC, the victim cache should keep them alive.
	runtime.GC()
	if g := p.Get(); g != "c" {
		t.Fatalf("got %#v; want c after GC", g)

	// if called from a non-go thread.
	XORPS	X15, X15
	XORQ	R14, R14

	get_tls(AX)
	CMPQ	AX, $0
	JE	2(PC)
	// Exception from Go thread, set R14.
	MOVQ	g(AX), R14

	// Reserve space for spill slots.
	ADJSP	$16
	MOVQ	CX, AX
	MOVQ	DX, BX
	// Calling ABIInternal because TLS might be nil.
	CALL	runtime·sigtrampgo<ABIInternal>(SB)
	// Return value is already stored in AX.

	ADJSP	$-16

	// Transition from C ABI to Go ABI.
	PUSH_REGS_HOST_TO_ABI0()

	// Set up ABIInternal environment: g in R14, cleared X15.
	get_tls(R12)
	MOVQ	g(R12), R14
	PXOR	X15, X15

	// Reserve space for spill slots.
	NOP	SP		// disable vet stack checking
	ADJSP   $24

	// Call into the Go signal handler
	MOVQ	DI, AX	// sig
	MOVQ	SI, BX	// info
	MOVQ	DX, CX	// ctx
	CALL	·sigtrampgo<ABIInternal>(SB)

 - Another.

Even more text.
 - List immediately after.

 - Blank line between items.

Yet more text.

 - Another list after blank line.

 - Blank line between items.

Still more text.
 - One list item.

   Multiple paragraphs.
-- dump --
Doc
	Paragraph
		Plain "Text."
	List ForceBlankBefore=false ForceBlankBetween=false
		Item Number=""
			Paragraph

        when:
        output.println("1st line")
        output.text("2nd line")
        output.text(" - still 2nd line")
        output.println()
        output.text("3rd line")

        then:
        result.toString() == TextUtil.toPlatformLineSeparators("""[PREFIX]1st line
[PREFIX]2nd line - still 2nd line
[PREFIX]3rd line""")
    }

    def "allows not prefixing first line"() {

	defer a.Free()

	const iValue = 10

	i := arena.New[int](a)
	*i = iValue

	if *i != iValue {
		// This test doesn't reasonably expect this to fail. It's more likely
		// that *i crashes for some reason. Still, why not check it.
		log.Fatalf("bad i value: got %d, want %d", *i, iValue)
	}

	const wantLen = 125
	const wantCap = 1912

	sl := arena.MakeSlice[*int](a, wantLen, wantCap)
	if len(sl) != wantLen {

package main

import "fmt"

type i5f5 struct {
	a, b          int16
	c, d, e       int32
	r, s, t, u, v float32
}

//go:noinline
func spills(_ *float32) {

}

//go:registerparams
//go:noinline
func F(x i5f5) i5f5 {
	y := x.v
	spills(&y)
	x.r = y
	return x
}

func main() {
	x := i5f5{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	y := x
	z := F(x)