[]relocationTestEntry{
			{
				entry: &dwarf.Entry{
					Offset:   0xb,
					Tag:      dwarf.TagCompileUnit,
					Children: true,
					Field: []dwarf.Field{
						{Attr: dwarf.AttrProducer, Val: "GNU C11 7.2.0 -march=rv64imafdc -mabi=lp64d -g -gdwarf-2", Class: dwarf.ClassString},
						{Attr: dwarf.AttrLanguage, Val: int64(12), Class: dwarf.ClassConstant},
						{Attr: dwarf.AttrName, Val: "hello.c", Class: dwarf.ClassString},

		t.Fatal("parse error:", err)
	}
	var b bytes.Buffer
	err = tmpl.Execute(&b, 5) // 5 is out of range indexing "hi"
	if err == nil {
		t.Fatal("expected error")
	}
	const want = `template: top:7:20: executing "three" at <index "hi" $>: error calling index: index out of range: 5`
	got := err.Error()
	if got != want {
		t.Errorf("expected\n%q\ngot\n%q", want, got)
	}
}

func TestJSEscaping(t *testing.T) {

	SYS_TSEARCH                         = 0x2CD // 717
	SYS_TWALK                           = 0x2CE // 718
	SYS_INSQUE                          = 0x2CF // 719
	SYS_REMQUE                          = 0x2D0 // 720
	SYS_POPEN                           = 0x2D1 // 721
	SYS_PCLOSE                          = 0x2D2 // 722
	SYS_SWAB                            = 0x2D3 // 723
	SYS_MEMCCPY                         = 0x2D4 // 724

		t.Fatal("parse error:", err)
	}
	var b bytes.Buffer
	err = tmpl.Execute(&b, 5) // 5 is out of range indexing "hi"
	if err == nil {
		t.Fatal("expected error")
	}
	const want = `template: top:7:20: executing "three" at <index "hi" $>: error calling index: index out of range: 5`
	got := err.Error()
	if got != want {
		t.Errorf("expected\n%q\ngot\n%q", want, got)
	}
}

type CustomError struct{}

	MOVD	$716, R12
	B	runtime·callbackasm1(SB)
	MOVD	$717, R12
	B	runtime·callbackasm1(SB)
	MOVD	$718, R12
	B	runtime·callbackasm1(SB)
	MOVD	$719, R12
	B	runtime·callbackasm1(SB)
	MOVD	$720, R12
	B	runtime·callbackasm1(SB)
	MOVD	$721, R12
	B	runtime·callbackasm1(SB)
	MOVD	$722, R12
	B	runtime·callbackasm1(SB)
	MOVD	$723, R12
	B	runtime·callbackasm1(SB)
	MOVD	$724, R12

	MOVW	$716, R12
	B	runtime·callbackasm1(SB)
	MOVW	$717, R12
	B	runtime·callbackasm1(SB)
	MOVW	$718, R12
	B	runtime·callbackasm1(SB)
	MOVW	$719, R12
	B	runtime·callbackasm1(SB)
	MOVW	$720, R12
	B	runtime·callbackasm1(SB)
	MOVW	$721, R12
	B	runtime·callbackasm1(SB)
	MOVW	$722, R12
	B	runtime·callbackasm1(SB)
	MOVW	$723, R12
	B	runtime·callbackasm1(SB)
	MOVW	$724, R12

func stack712()  { var buf [712]byte; use(buf[:]); C.callGoStackCheck() }
func stack716()  { var buf [716]byte; use(buf[:]); C.callGoStackCheck() }
func stack720()  { var buf [720]byte; use(buf[:]); C.callGoStackCheck() }
func stack724()  { var buf [724]byte; use(buf[:]); C.callGoStackCheck() }
func stack728()  { var buf [728]byte; use(buf[:]); C.callGoStackCheck() }

	716:  {region: 0x52, script: 0x5b, flags: 0x0},
	717:  {region: 0x9a, script: 0x22, flags: 0x0},
	718:  {region: 0x9a, script: 0x22, flags: 0x0},
	719:  {region: 0x96, script: 0x5b, flags: 0x0},
	720:  {region: 0x23, script: 0x3, flags: 0x1},
	721:  {region: 0xa5, script: 0x5b, flags: 0x0},
	722:  {region: 0x166, script: 0x5b, flags: 0x0},
	723:  {region: 0xd0, script: 0x5b, flags: 0x0},

		if p.From.Reg == REG_CR || p.To.Reg == REG_CR {
			c.ctxt.Diag("CR argument must be a conditional register field (CR0-CR7)\n%v", p)
		}
		o1 = AOP_RRR(OP_MCRF, ((uint32(p.To.Reg) & 7) << 2), ((uint32(p.From.Reg) & 7) << 2), 0)

	case 68: /* mfcr rD; mfocrf CRM,rD */
		o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) /*  form, whole register */
		if p.From.Reg != REG_CR {
			v := uint32(1) << uint(7-(p.From.Reg&7)) /* CR(n) */

		{0x115af, 0x11930, 897},
		{0x1d165, 0x1d16e, 9},
		{0x1d16f, 0x1d172, 1},
		{0xe0020, 0xe007f, 1},
	},
}

var _Other_ID_Continue = &RangeTable{
	R16: []Range16{
		{0x00b7, 0x0387, 720},
		{0x1369, 0x1371, 1},
		{0x19da, 0x19da, 1},
	},
}

var _Other_ID_Start = &RangeTable{
	R16: []Range16{
		{0x1885, 0x1886, 1},
		{0x2118, 0x212e, 22},
		{0x309b, 0x309c, 1},
	},