"LW",
	"LWU",
	"LH",
	"LHU",
	"LB",
	"LBU",
	"SW",
	"SH",
	"SB",
	"FENCE",
	"FENCETSO",
	"PAUSE",
	"ADDIW",
	"SLLIW",
	"SRLIW",
	"SRAIW",
	"ADDW",
	"SLLW",
	"SRLW",
	"SUBW",
	"SRAW",
	"LD",
	"SD",
	"MUL",
	"MULH",
	"MULHU",
	"MULHSU",
	"MULW",
	"DIV",
	"DIVU",
	"REM",
	"REMU",
	"DIVW",
	"DIVUW",
	"REMW",
	"REMUW",
	"LRD",
	"SCD",
	"LRW",

	SRLIW	$32, X5, X6			// ERROR "immediate out of range 0 to 31"
	SRAIW	$32, X5, X6			// ERROR "immediate out of range 0 to 31"
	RORIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
	SLLIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
	SRLIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
	SRAIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"

// license that can be found in the LICENSE file.

// Fold constant shift with extension.
(SRAI [c] (MOVBreg  x)) && c <   8 => (SRAI [56+c] (SLLI <typ.Int64> [56] x))
(SRAI [c] (MOVHreg  x)) && c <  16 => (SRAI [48+c] (SLLI <typ.Int64> [48] x))
(SRAI [c] (MOVWreg  x)) && c <  32 => (SRAI [32+c] (SLLI <typ.Int64> [32] x))
(SRLI [c] (MOVBUreg x)) && c <   8 => (SRLI [56+c] (SLLI <typ.UInt64> [56] x))

		return true
	}
	return false
}
func rewriteValueRISCV64latelower_OpRISCV64SRAI(v *Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (SRAI [c] (MOVBreg x))
	// cond: c < 8
	// result: (SRAI [56+c] (SLLI <typ.Int64> [56] x))
	for {
		c := auxIntToInt64(v.AuxInt)
		if v_0.Op != OpRISCV64MOVBreg {
			break
		}
		x := v_0.Args[0]
		if !(c < 8) {
			break
		}

	SRAD	$32, R5
	MOVH	$0x0, R1
	SUBW	R5, R3
	FMOVD	$0, F10
	RISBGZ	$32, $47, $0, R3, R4
	RISBGZ	$57, $60, $51, R3, R3
	BYTE	$0x18	//lr	%r2,%r4
	BYTE	$0x24
	RISBGN	$0, $31, $32, R4, R1
	SUBW	$0x100000, R2
	SRAW	$8, R2, R2
	ORW	$0x45000000, R2
L5:
	LDGR	R1, F0
	FMOVD	104(R9), F2
	FMADD	F8, F0, F2
	FMOVD	96(R9), F4
	WFMADB	V10, V0, V2, V0
	FMOVD	88(R9), F6
	FMOVD	80(R9), F2
	WFMADB	V0, V6, V4, V6

		var braw strings.Builder
		err := tt.Resp.Write(&braw)
		if err != nil {
			t.Errorf("error writing #%d: %s", i, err)
			continue
		}
		sraw := braw.String()
		if sraw != tt.Raw {
			t.Errorf("Test %d, expecting:\n%q\nGot:\n%q\n", i, tt.Raw, sraw)
			continue
		}
	}

	BYTE	$0xFF
	LGDR	F0, R5
	SRAD	$32, R5
	MOVH	$0x0, R2
	SUBW	R5, R3
	FMOVD	$0, F8
	RISBGZ	$32, $47, $0, R3, R4
	BYTE	$0x18	//lr	%r1,%r4
	BYTE	$0x14
	RISBGN	$0, $31, $32, R4, R2
	SUBW	$0x100000, R1
	SRAW	$8, R1, R1
	ORW	$0x45000000, R1
	BR	L6
L2:
	MOVD	$0x30000000, R2
	CMPW	R1, R2
	BGT	L16
	FMOVD	200(R9), F2
	FMADD	F2, F0, F0
L1:
	FMOVD	F0, ret+8(FP)
	RET
L14:
	LTDBR	F0, F0

	"NORCC",
	"OR",
	"ORCC",
	"ORN",
	"ORNCC",
	"ORIS",
	"REM",
	"REMU",
	"RFI",
	"RLWMI",
	"RLWMICC",
	"RLWNM",
	"RLWNMCC",
	"CLRLSLWI",
	"SLW",
	"SLWCC",
	"SRW",
	"SRAW",
	"SRAWCC",
	"SRWCC",
	"STBCCC",
	"STHCCC",
	"STSW",
	"STWCCC",
	"SUB",
	"SUBCC",
	"SUBVCC",
	"SUBC",
	"SUBCCC",
	"SUBCV",
	"SUBCVCC",
	"SUBME",
	"SUBMECC",

	"MOVDGE",
	"MOVDGT",
	"MOVDLE",
	"MOVDLT",
	"MOVDNE",
	"LOCR",
	"LOCGR",
	"FLOGR",
	"POPCNT",
	"AND",
	"ANDW",
	"OR",
	"ORW",
	"XOR",
	"XORW",
	"SLW",
	"SLD",
	"SRW",
	"SRAW",
	"SRD",
	"SRAD",
	"RLL",
	"RLLG",
	"RNSBG",
	"RXSBG",
	"ROSBG",
	"RNSBGT",
	"RXSBGT",
	"ROSBGT",
	"RISBG",
	"RISBGN",
	"RISBGZ",
	"RISBGNZ",
	"RISBHG",
	"RISBLG",
	"RISBHGZ",

	RISBGZ	$40, $55, $56, R3, R2
	RISBGZ	$57, $60, $51, R3, R3
	ORW     $0x45000000, R2
	BR      L4
L13:
	BGE     L18     //jnl .L18
	BVS     L18
	FMOVD   log10rodataL19<>+16(SB), F0
	BR      L1
L17:
	SRAW    $1, R2, R2
	SUBW    $0x40000000, R2
	BR      L8
L18:
	FMOVD   log10rodataL19<>+8(SB), F0
	WORD    $0xED009000     //ddb %f0,.L36-.L19(%r9)
	BYTE    $0x00
	BYTE    $0x1D