// A nice long list of positions. Each position is encoded as follows to reduce size:
	// - 32-bit starting line number
	// - 32-bit ending line number
	// - (16 bit ending column number << 16) | (16-bit starting column number).
	for i, block := range f.blocks {
		start := f.fset.Position(block.startByte)
		end := f.fset.Position(block.endByte)

		start, end = dedup(start, end)

		cnt++
		if math.Copysign(1.0, k.x) < 0 {
			if v&16 == 0 {
				t.Error("key/value not updated together 1")
			}
			negcnt++
			s |= v & 15
		} else {
			if v&16 == 16 {
				t.Error("key/value not updated together 2", k, v)
			}
			s |= v
		}
		if growflag {
			// force a hashtable resize
			for i := 0; i < 100; i++ {
				m[FloatInt{3.0, i}] = 0
			}

	/* x^158784 mod p(x), x^158720 mod p(x) */
DATA ·IEEEConst+1600(SB)/8,$0x00000001ef0e3640
DATA ·IEEEConst+1608(SB)/8,$0x00000000e3fccf68

	/* x^157760 mod p(x), x^157696 mod p(x) */
DATA ·IEEEConst+1616(SB)/8,$0x00000001006d2d26
DATA ·IEEEConst+1624(SB)/8,$0x00000000d513ed24

	/* x^156736 mod p(x), x^156672 mod p(x) */
DATA ·IEEEConst+1632(SB)/8,$0x00000001170d56d6
DATA ·IEEEConst+1640(SB)/8,$0x00000000141beada

				opshift -= 8
			}
			mod = modrm >> 6
			regop = (modrm >> 3) & 07
			rm = modrm & 07
			if rex&PrefixREXR != 0 {
				rexUsed |= PrefixREXR
				regop |= 8
			}
			if addrMode == 16 {
				// 16-bit modrm form
				if mod != 3 {
					haveMem = true
					mem = addr16[rm]
					if rm == 6 && mod == 0 {
						mem.Base = 0
					}

					// Consume disp16 if present.

	{"%v", renamedInt32(-11), "-11"},
	{"%X", renamedInt64(255), "FF"},
	{"%v", renamedUint(13), "13"},
	{"%o", renamedUint8(14), "16"},
	{"%X", renamedUint16(15), "F"},
	{"%d", renamedUint32(16), "16"},
	{"%X", renamedUint64(17), "11"},
	{"%o", renamedUintptr(18), "22"},
	{"%x", renamedString("thing"), "7468696e67"},
	{"%d", renamedBytes([]byte{1, 2, 15}), `[1 2 15]`},

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)
		}