// amd64:"ANDL\t[$]1023"
	// arm64:"AND\t[$]1023",-"SDIV"
	// arm/6:"AND",-".*udiv"
	// arm/7:"BFC",-".*udiv",-"AND"
	// ppc64x:"RLDICL"
	return len(a) % 1024
}

func LenMod2(s string) int {
	// 386:"ANDL\t[$]2047"
	// amd64:"ANDL\t[$]2047"
	// arm64:"AND\t[$]2047",-"SDIV"
	// arm/6:"AND",-".*udiv"
	// arm/7:"BFC",-".*udiv",-"AND"
	// ppc64x:"RLDICL"
	return len(s) % (4097 >> 1)
}

	"ROR",
	"RORW",
	"SBC",
	"SBCS",
	"SBCSW",
	"SBCW",
	"SBFIZ",
	"SBFIZW",
	"SBFM",
	"SBFMW",
	"SBFX",
	"SBFXW",
	"SCVTFD",
	"SCVTFS",
	"SCVTFWD",
	"SCVTFWS",
	"SDIV",
	"SDIVW",
	"SEV",
	"SEVL",
	"SHA1C",
	"SHA1H",
	"SHA1M",
	"SHA1P",
	"SHA1SU0",
	"SHA1SU1",
	"SHA256H",
	"SHA256H2",
	"SHA256SU0",
	"SHA256SU1",
	"SHA512H",
	"SHA512H2",

        !matchPattern(for_op.getUpperBound(), m_ConstantInt(&upper_bound)) ||
        !matchPattern(for_op.getStep(), m_ConstantInt(&step))) {
      return failure();
    }
    uint64_t trip_count = (upper_bound - lower_bound).sdiv(step).getZExtValue();
    if (trip_count <= 0) return failure();

    // TODO(fengliuai): use loopUnrollByFactor once the iter_arg is supported

    Block *single_block = for_op.getBody();
    IRMapping mapping;

	SBFX_ZZ:           "SBFX.ZZ",
	SDIV_EQ:           "SDIV.EQ",
	SDIV_NE:           "SDIV.NE",
	SDIV_CS:           "SDIV.CS",
	SDIV_CC:           "SDIV.CC",
	SDIV_MI:           "SDIV.MI",
	SDIV_PL:           "SDIV.PL",
	SDIV_VS:           "SDIV.VS",
	SDIV_VC:           "SDIV.VC",
	SDIV_HI:           "SDIV.HI",
	SDIV_LS:           "SDIV.LS",
	SDIV_GE:           "SDIV.GE",
	SDIV_LT:           "SDIV.LT",

	// FDIV <Sd>, <Sn>, <Sm>
	{0xffe0fc00, 0x1e201800, FDIV, instArgs{arg_Sd, arg_Sn, arg_Sm}, nil},
	// FDIV <Dd>, <Dn>, <Dm>
	{0xffe0fc00, 0x1e601800, FDIV, instArgs{arg_Dd, arg_Dn, arg_Dm}, nil},
	// FDIV <Vd>.<t>, <Vn>.<t>, <Vm>.<t>

	SBFIZ $6, R11, $15, R20                    // 74397a93
	SBFXW $8, R15, $10, R20                    // f4450813
	SBFX $2, R27, $54, R7                      // 67df4293
	SDIVW R22, R14, R9                         // c90dd61a
	SDIV R13, R21, R9                          // a90ecd9a
	SEV                                        // 9f2003d5
	SEVL                                       // bf2003d5

		{name: "DIV", argLength: 2, reg: gp21, asm: "SDIV"},                                                           // arg0 / arg1, signed
		{name: "UDIV", argLength: 2, reg: gp21, asm: "UDIV"},                                                          // arg0 / arg1, unsigned

{"Name":"SDIV","Bits":"0|0|0|1|1|0|1|0|1|1|0|Rm:5|0|0|0|0|1|1|Rn:5|Rd:5","Arch":"32-bit variant","Syntax":"SDIV <Wd>, <Wn>, <Wm>","Code":"","Alias":""},
{"Name":"SDIV","Bits":"1|0|0|1|1|0|1|0|1|1|0|Rm:5|0|0|0|0|1|1|Rn:5|Rd:5","Arch":"64-bit variant","Syntax":"SDIV <Xd>, <Xn>, <Xm>","Code":"","Alias":""},

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package runtime

import "unsafe"

// Called from compiler-generated code; declared for go vet.
func udiv()
func _div()
func _divu()
func _mod()
func _modu()

// Called from assembly only; declared for go vet.
func usplitR0()
func load_g()
func save_g()
func emptyfunc()
func _initcgo()
func read_tls_fallback()

		return
	}
	q, r := udiv(x, y)
	q1 := x/y
	r1 := x%y
	if q1 != q {
		print("uint64(", x, "/", y, ") = ", q1, ", want ", q, "\n")
	}
	if r1 != r {
		print("uint64(", x, "%", y, ") = ", r1, ", want ", r, "\n")
	}
}

func checkuint32(x, y uint32) {
	if y == 0 {
		divzerouint32(x, y)
		modzerouint32(x, y)
		return
	}
	q, r := udiv(uint64(x), uint64(y))
	q1 := x/y