VADDPD.RD_SAE Y3, Y2, K1, Y1     // ERROR "unsupported rounding"
	VADDPD.RZ_SAE Y3, Y2, K1, Y1     // ERROR "unsupported rounding"
	VADDPD.RN_SAE Y3, Y2, K1, Y1     // ERROR "unsupported rounding"
	// Unsupported SAE.
	VMAXPD.SAE (AX), Z2, K1, Z1      // ERROR "illegal SAE with memory argument"
	VADDPD.SAE X3, X2, K1, X1        // ERROR "unsupported SAE"
	// Unsupported zeroing.
	VFPCLASSPDX.Z $0, (AX), K2, K1   // ERROR "unsupported zeroing"

	"FCVTZSDW",
	"FCVTZSS",
	"FCVTZSSW",
	"FCVTZUD",
	"FCVTZUDW",
	"FCVTZUS",
	"FCVTZUSW",
	"FDIVD",
	"FDIVS",
	"FLDPD",
	"FLDPQ",
	"FLDPS",
	"FMADDD",
	"FMADDS",
	"FMAXD",
	"FMAXNMD",
	"FMAXNMS",
	"FMAXS",
	"FMIND",
	"FMINNMD",
	"FMINNMS",
	"FMINS",
	"FMOVD",
	"FMOVQ",
	"FMOVS",
	"FMSUBD",
	"FMSUBS",
	"FMULD",
	"FMULS",
	"FNEGD",

	// arm64:"FMIND"
	// riscv64:"FMIN"
	// ppc64/power9:"XSMINJDP"
	// ppc64/power10:"XSMINJDP"
	return min(a, b)
}

func Float64Max(a, b float64) float64 {
	// amd64:"MINSD"
	// arm64:"FMAXD"
	// riscv64:"FMAX"
	// ppc64/power9:"XSMAXJDP"
	// ppc64/power10:"XSMAXJDP"
	return max(a, b)
}

func Float32Min(a, b float32) float32 {
	// amd64:"MINSS"
	// arm64:"FMINS"
	// riscv64:"FMINS"

	// the streams instead of the underlying connection *may* not perform the same if two streams
	// traveling the same direction (e.g. stdout, stderr) are being maxed out.
	opts := remotecommand.StreamOptions{}
	if h.Options.Stdin {
		stdin := websocketStreams.stdinStream
		if h.MaxBytesPerSec > 0 {
			stdin = flowrate.NewReader(stdin, h.MaxBytesPerSec)
		}
		opts.Stdin = stdin

	VINSWVRX R1, V2, V3                     // 1061118f
	VMODSD V1, V2, V3                       // 106117cb
	VMODSQ V1, V2, V3                       // 1061170b
	VMODSW V1, V2, V3                       // 1061178b
	VMODUD V1, V2, V3                       // 106116cb
	VMODUQ V1, V2, V3                       // 1061160b
	VMODUW V1, V2, V3                       // 1061168b
	VMSUMCUD V1, V2, V3, V4                 // 108110d7

	ASH2ADD
	ASH2ADDUW
	ASH3ADD
	ASH3ADDUW
	ASLLIUW

	// 1.2: Basic Bit Manipulation (Zbb)
	AANDN
	AORN
	AXNOR
	ACLZ
	ACLZW
	ACTZ
	ACTZW
	ACPOP
	ACPOPW
	AMAX
	AMAXU
	AMIN
	AMINU
	ASEXTB
	ASEXTH
	AZEXTH

	// 1.3: Bitwise Rotation (Zbb)
	AROL
	AROLW
	AROR
	ARORI
	ARORIW
	ARORW
	AORCB
	AREV8

func test(t *testing.T, build func([]byte) []int) {
	t.Run("ababab...", func(t *testing.T) {
		// Very repetitive input has numLMS = len(x)/2-1
		// at top level, the largest it can be.
		// But maxID is only two (aba and ab$).
		size := 100000
		if testing.Short() {
			size = 10000
		}
		x := make([]byte, size)
		for i := range x {
			x[i] = "ab"[i%2]
		}
		testSA(t, x, build)
	})

		{name: "LoweredFMIND", argLength: 2, reg: fp21, resultNotInArgs: true, asm: "FMIND", commutative: true, typ: "Float64"},             // min(arg0, arg1)
		{name: "LoweredFMAXD", argLength: 2, reg: fp21, resultNotInArgs: true, asm: "FMAXD", commutative: true, typ: "Float64"},             // max(arg0, arg1)
	}

	RISCV64blocks := []blockData{
		{name: "BEQ", controls: 2},
		{name: "BNE", controls: 2},
		{name: "BLT", controls: 2},

	// - A closed stream that has been removed (this will have ID <= maxID)
	// - An idle stream that is being used for "grouping" (this will have ID > maxID)
	n := ws.nodes[streamID]
	if n == nil {
		if streamID <= ws.maxID || ws.maxIdleNodesInTree == 0 {
			return
		}
		ws.maxID = streamID
		n = &http2priorityNode{
			q:      *ws.queuePool.get(),
			id:     streamID,

	"VPEXTD",
	"VPDEPD",
	"VMULOUD",
	"VMULOSD",
	"VMULLD",
	"VMULHUW",
	"VMULHUD",
	"VMULHSW",
	"VMULHSD",
	"VMULEUD",
	"VMULESD",
	"VMSUMCUD",
	"VMODUW",
	"VMODUQ",
	"VMODUD",
	"VMODSW",
	"VMODSQ",
	"VMODSD",
	"VINSWVRX",
	"VINSWVLX",
	"VINSWRX",
	"VINSWLX",
	"VINSW",
	"VINSHVRX",
	"VINSHVLX",
	"VINSHRX",
	"VINSHLX",
	"VINSDRX",
	"VINSDLX",