println("closeBlock", len(p.stack)-1)
	}
	blk := b.builder.build(p)
	if list, ok := blk.(*List); ok {
		p.corner = p.corner || listCorner(list)
		if p.TaskListItems {
			p.lists = append(p.lists, list)
		}
	}
	p.stack = p.stack[:len(p.stack)-1]
	if len(p.stack) > 0 {
		b := &p.stack[len(p.stack)-1]
		b.inner = append(b.inner, blk)
		// _ = b
	} else {
		p.root = blk.(*Document)
	}
	return blk
}

			dumpTo(out, indent, def)
		}

	case *LinkDef:
		fmt.Fprintf(out, "LinkDef Used:%v Text:%q URL:%s", x.Used, x.Text, x.URL)

	case []Block:
		for _, blk := range x {
			dumpNL(out, indent)
			dumpTo(out, indent, blk)
		}

	case *Heading:
		fmt.Fprintf(out, "Heading")
		dumpTo(out, indent+1, x.Text)

	case *List:

	ADD	$64,R6,R6	// increment to next 64 bytes of B
	BDNZ	cmp64_loop
	BC	$12,2,LR	// beqlr

	// Finish out tail with minimal overlapped checking.
	// Note, 0 tail is handled by beqlr above.
	BLE	CR1,cmp64_tail_gt0
	BLE	CR2,cmp64_tail_gt16
	BLE	CR3,cmp64_tail_gt32

cmp64_tail_gt48: // 49 - 63 B
	LXVD2X	(R0)(R5),V3
	LXVD2X	(R0)(R6),V4
	VCMPEQUDCC	V3,V4,V1
	BGE	CR6,different

	LXVD2X	(R5)(R10),V3

		// Write the initial GNU header.
		var blk block
		gnu := blk.toGNU()
		sparse := gnu.sparse()
		copy(gnu.realSize(), size)
		sps = populateSparseMap(sparse, sps)
		if format != FormatUnknown {
			blk.setFormat(format)
		}
		out = append(out, blk[:]...)

		// Write extended sparse blocks.
		for len(sps) > 0 {
			var blk block
			sps = populateSparseMap(blk.toSparse(), sps)

	BLE        index2to16next_p10        // If at end, then not found
	BR         notfound  // go to remainder loop
#else
	ADD     R3, R4, R9         // End of string
	SUB     R7, R9, R9         // Number of bytes left
	ANDCC   $15, R7, R10       // 16 byte offset
	ADD     R10, R9, R11       // offset + len
	CMP     R11, $16           // >= 16?
	BLE     short              // Does not cross 16 bytes

// with the core of the assembler.

package arch

import (
	"cmd/internal/obj"
	"cmd/internal/obj/ppc64"
)

func jumpPPC64(word string) bool {
	switch word {
	case "BC", "BCL", "BEQ", "BGE", "BGT", "BL", "BLE", "BLT", "BNE", "BR", "BVC", "BVS", "BDNZ", "BDZ", "CALL", "JMP":
		return true
	}
	return false
}

// IsPPC64CMP reports whether the op (as defined by an ppc64.A* constant) is

				out.WriteString(" - ")
			} else {
				out.WriteString(item.Number)
				out.WriteString(". ")
			}
			for i, blk := range item.Content {
				const fourSpace = "    "
				if i > 0 {
					out.WriteString("\n" + fourSpace)
				}
				p.text(out, fourSpace, blk.(*Paragraph).Text)
				out.WriteString("\n")
			}
		}
	}
}

// text prints the text sequence x to out.

	"ASRW",
	"AT",
	"BCC",
	"BCS",
	"BEQ",
	"BFI",
	"BFIW",
	"BFM",
	"BFMW",
	"BFXIL",
	"BFXILW",
	"BGE",
	"BGT",
	"BHI",
	"BHS",
	"BIC",
	"BICS",
	"BICSW",
	"BICW",
	"BLE",
	"BLO",
	"BLS",
	"BLT",
	"BMI",
	"BNE",
	"BPL",
	"BRK",
	"BVC",
	"BVS",
	"CASAD",
	"CASALB",
	"CASALD",
	"CASALH",
	"CASALW",
	"CASAW",
	"CASB",
	"CASD",
	"CASH",

	PCALIGN	$32
	BEQ	notfound	// Is tail length 0? CR0 is set before entering loop64.

	CMP	R4,$32		// Tail length >= 32, use cmp32 path.
	CMP	R4,$16,CR1
	BGE	cmp32

	ADD	R8,R4,R9
	ADD	$-16,R9
	BLE	CR1,cmp64_tail_gt0

cmp64_tail_gt16:	// Tail length 17 - 32
	LXVD2X	(R0)(R8),V2
	VCMPEQUBCC	V2,V1,V6
	BNE	CR6,foundat0

cmp64_tail_gt0:	// Tail length 1 - 16
	MOVD	R9,R8
	LXVD2X	(R0)(R9),V2

		dummy()
	}
}

// Signed 64-bit comparison with 1/-1 to comparison with 0.
func si64x0(x chan int64) {
	// riscv64:"BGTZ"
	for <-x >= 1 {
		dummy()
	}

	// riscv64:"BLEZ"
	for <-x < 1 {
		dummy()
	}

	// riscv64:"BLTZ"
	for <-x <= -1 {
		dummy()
	}

	// riscv64:"BGEZ"
	for <-x > -1 {
		dummy()
	}
}