DEBUG_CALL_FN(debugCall16384<>, 16384)
DEBUG_CALL_FN(debugCall32768<>, 32768)
DEBUG_CALL_FN(debugCall65536<>, 65536)

// func debugCallPanicked(val interface{})
TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
	// Copy the panic value to the top of stack at SP+8.
	MOVD	val_type+0(FP), R0
	MOVD	R0, 8(RSP)
	MOVD	val_data+8(FP), R0
	MOVD	R0, 16(RSP)
	MOVD	$2, R20
	BREAK
	RET

			want: []framework.NodeScore{
				{Name: "node-a", Score: 33}, // +13, compared to maxSkew=1
				{Name: "node-b", Score: 66}, // +6, compared to maxSkew=1
				{Name: "node-c", Score: 100},
				{Name: "node-d", Score: 16}, // +16, compared to maxSkew=1
			},
		},
		{
			name: "one constraint on node, all 4 nodes are candidates, maxSkew=3",
			pod: st.MakePod().Name("p").Label("foo", "").

	SYS_SQRTF                           = 0x64D // 1613
	SYS_SQRTL                           = 0x64E // 1614
	SYS_SINHF                           = 0x64F // 1615
	SYS_SINHL                           = 0x650 // 1616
	SYS_TANF                            = 0x651 // 1617
	SYS_TANL                            = 0x652 // 1618
	SYS_FABSF                           = 0x653 // 1619
	SYS_FABSL                           = 0x654 // 1620

DEBUG_CALL_FN(debugCall16384<>, 16384)
DEBUG_CALL_FN(debugCall32768<>, 32768)
DEBUG_CALL_FN(debugCall65536<>, 65536)

// func debugCallPanicked(val interface{})
TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
	// Copy the panic value to the top of stack.
	MOVQ	val_type+0(FP), AX
	MOVQ	AX, 0(SP)
	MOVQ	val_data+8(FP), AX
	MOVQ	AX, 8(SP)
	MOVQ	$2, R12
	BYTE	$0xcc
	RET

		switch width {
		case 21:
			if (v<<11)>>11 != v {
				c.ctxt.Diag("21 bit-width, short branch too far\n%v", p)
			}
			o1 = OP_16IR_5I(c.opirr(as), uint32(v), uint32(rj))
		case 16:
			if (v<<16)>>16 != v {
				c.ctxt.Diag("16 bit-width, short branch too far\n%v", p)
			}
			o1 = OP_16IRR(c.opirr(as), uint32(v), uint32(rj), uint32(rd))
		default:
			c.ctxt.Diag("unexpected branch encoding\n%v", p)
		}

// Special-case bit patterns on first/last bit.
// generic.rules changes ANDs of high-part/low-part masks into a couple of shifts,
// for instance:
//    x & 0xFFFF0000 -> (x >> 16) << 16
//    x & 0x80000000 -> (x >> 31) << 31
//
// In case the mask is just one bit (like second example above), it conflicts
// with the above rules to detect bit-testing / bit-clearing of first/last bit.

func stack1608() { var buf [1608]byte; use(buf[:]); C.callGoStackCheck() }
func stack1612() { var buf [1612]byte; use(buf[:]); C.callGoStackCheck() }
func stack1616() { var buf [1616]byte; use(buf[:]); C.callGoStackCheck() }
func stack1620() { var buf [1620]byte; use(buf[:]); C.callGoStackCheck() }
func stack1624() { var buf [1624]byte; use(buf[:]); C.callGoStackCheck() }

ProcStart dt=147800 p=2 p_seq=16
ProcStop dt=29
ProcStart dt=3880 p=1 p_seq=28
ProcStop dt=30
ProcStart dt=801175 p=5 p_seq=3
ProcStop dt=19
ProcStart dt=47961 p=6 p_seq=4
ProcStop dt=15
ProcStart dt=16716 p=6 p_seq=5
GoUnblock dt=60 g=6 g_seq=2 stack=0
GoStart dt=90 g=6 g_seq=3
HeapAlloc dt=193 heapalloc_value=26453304
GoBlock dt=29 reason_string=12 stack=15
ProcStop dt=12
ProcStart dt=704555 p=7 p_seq=10

	{0x212A, 0x212A, d{0, -8383, 0}},
	{0x212B, 0x212B, d{0, -8262, 0}},
	{0x2132, 0x2132, d{0, 28, 0}},
	{0x214E, 0x214E, d{-28, 0, -28}},
	{0x2160, 0x216F, d{0, 16, 0}},
	{0x2170, 0x217F, d{-16, 0, -16}},
	{0x2183, 0x2184, d{UpperLower, UpperLower, UpperLower}},
	{0x24B6, 0x24CF, d{0, 26, 0}},
	{0x24D0, 0x24E9, d{-26, 0, -26}},
	{0x2C00, 0x2C2F, d{0, 48, 0}},
	{0x2C30, 0x2C5F, d{-48, 0, -48}},

	op_MVCSK   uint32 = 0xE50E // FORMAT_SSE        MOVE WITH SOURCE KEY
	op_MVGHI   uint32 = 0xE548 // FORMAT_SIL        MOVE (64<-16)
	op_MVHHI   uint32 = 0xE544 // FORMAT_SIL        MOVE (16<-16)
	op_MVHI    uint32 = 0xE54C // FORMAT_SIL        MOVE (32<-16)
	op_MVI     uint32 = 0x9200 // FORMAT_SI         MOVE (immediate)
	op_MVIY    uint32 = 0xEB52 // FORMAT_SIY        MOVE (immediate)