xref: /external/llvm/test/MC/AArch64/neon-diagnostics.s

// RUN: not llvm-mc -triple aarch64-none-linux-gnu -mattr=+neon < %s 2> %t
// RUN: FileCheck --check-prefix=CHECK-ERROR < %t %s

//------------------------------------------------------------------------------
// Vector Integer Add/sub
//------------------------------------------------------------------------------

        // Mismatched vector types
        add v0.16b, v1.8b, v2.8b
        sub v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         add v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sub v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                              ^

//------------------------------------------------------------------------------
// Vector Floating-Point Add/sub
//------------------------------------------------------------------------------

        // Mismatched and invalid vector types
        fadd v0.2d, v1.2s, v2.2s
        fsub v0.4s, v1.2s, v2.4s
        fsub v0.8b, v1.8b, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fadd v0.2d, v1.2s, v2.2s
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fsub v0.4s, v1.2s, v2.4s
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fsub v0.8b, v1.8b, v2.8b
// CHECK-ERROR:                  ^

//----------------------------------------------------------------------
// Vector Integer Mul
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
        mul v0.16b, v1.8b, v2.8b
        mul v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         mul v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         mul v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^

//----------------------------------------------------------------------
// Vector Floating-Point Mul/Div
//----------------------------------------------------------------------
        // Mismatched vector types
        fmul v0.16b, v1.8b, v2.8b
        fdiv v0.2s, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fmul v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fdiv v0.2s, v1.2d, v2.2d
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Vector And Orr Eor Bsl Bit Bif, Orn, Bic,
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        and v0.8b, v1.16b, v2.8b
        orr v0.4h, v1.4h, v2.4h
        eor v0.2s, v1.2s, v2.2s
        bsl v0.8b, v1.16b, v2.8b
        bsl v0.2s, v1.2s, v2.2s
        bit v0.2d, v1.2d, v2.2d
        bif v0.4h, v1.4h, v2.4h
        orn v0.8b, v1.16b, v2.16b
        bic v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         and v0.8b, v1.16b, v2.8b
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         orr v0.4h, v1.4h, v2.4h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         eor v0.2s, v1.2s, v2.2s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         bsl v0.8b, v1.16b, v2.8b
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         bsl v0.2s, v1.2s, v2.2s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         bit v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         bif v0.4h, v1.4h, v2.4h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         orn v0.8b, v1.16b, v2.16b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         bic v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^

//----------------------------------------------------------------------
// Vector Integer Multiply-accumulate and Multiply-subtract
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
        mla v0.16b, v1.8b, v2.8b
        mls v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         mla v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         mls v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^

//----------------------------------------------------------------------
// Vector Floating-Point Multiply-accumulate and Multiply-subtract
//----------------------------------------------------------------------
        // Mismatched vector types
        fmla v0.2s, v1.2d, v2.2d
        fmls v0.16b, v1.8b, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fmla v0.2s, v1.2d, v2.2d
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fmls v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                         ^


//----------------------------------------------------------------------
// Vector Move Immediate Shifted
// Vector Move Inverted Immediate Shifted
// Vector Bitwise Bit Clear (AND NOT) - immediate
// Vector Bitwise OR - immedidate
//----------------------------------------------------------------------
      // out of range immediate (0 to 0xff)
      movi v0.2s, #-1
      mvni v1.4s, #256
      // out of range shift (0, 8, 16, 24 and 0, 8)
      bic v15.4h, #1, lsl #7
      orr v31.2s, #1, lsl #25
      movi v5.4h, #10, lsl #16
      // invalid vector type (2s, 4s, 4h, 8h)
      movi v5.8b, #1, lsl #8

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          movi v0.2s, #-1
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         mvni v1.4s, #256
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         bic v15.4h, #1, lsl #7
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         orr v31.2s, #1, lsl #25
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         movi v5.4h, #10, lsl #16
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         movi v5.8b, #1, lsl #8
// CHECK-ERROR:                         ^
//----------------------------------------------------------------------
// Vector Move Immediate Masked
// Vector Move Inverted Immediate Masked
//----------------------------------------------------------------------
      // out of range immediate (0 to 0xff)
      movi v0.2s, #-1, msl #8
      mvni v7.4s, #256, msl #16
      // out of range shift (8, 16)
      movi v3.2s, #1, msl #0
      mvni v17.4s, #255, msl #32
      // invalid vector type (2s, 4s)
      movi v5.4h, #31, msl #8

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         movi v0.2s, #-1, msl #8
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         mvni v7.4s, #256, msl #16
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         movi v3.2s, #1, msl #0
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         mvni v17.4s, #255, msl #32
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         movi v5.4h, #31, msl #8
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Vector Immediate - per byte
//----------------------------------------------------------------------
        // out of range immediate (0 to 0xff)
        movi v0.8b, #-1
        movi v1.16b, #256

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         movi v0.8b, #-1
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         movi v1.16b, #256
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Scalar Floating-point Reciprocal Estimate
//----------------------------------------------------------------------

    frecpe s19, h14
    frecpe d13, s13

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frecpe s19, h14
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frecpe d13, s13
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Floating-point Reciprocal Exponent
//----------------------------------------------------------------------

    frecpx s18, h10
    frecpx d16, s19

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frecpx s18, h10
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frecpx d16, s19
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Floating-point Reciprocal Square Root Estimate
//----------------------------------------------------------------------

    frsqrte s22, h13
    frsqrte d21, s12

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frsqrte s22, h13
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frsqrte d21, s12
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Vector Move Immediate - bytemask, per doubleword
//---------------------------------------------------------------------
        // invalid bytemask (0x00 or 0xff)
        movi v0.2d, #0x10ff00ff00ff00ff

// CHECK:ERROR: error: invalid operand for instruction
// CHECK:ERROR:         movi v0.2d, #0x10ff00ff00ff00ff
// CHECK:ERROR:                     ^

//----------------------------------------------------------------------
// Vector Move Immediate - bytemask, one doubleword
//----------------------------------------------------------------------
        // invalid bytemask (0x00 or 0xff)
        movi v0.2d, #0xffff00ff001f00ff

// CHECK:ERROR: error: invalid operand for instruction
// CHECK:ERROR:         movi v0.2d, #0xffff00ff001f00ff
// CHECK:ERROR:                     ^
//----------------------------------------------------------------------
// Vector Floating Point Move Immediate
//----------------------------------------------------------------------
        // invalid vector type (2s, 4s, 2d)
         fmov v0.4h, #1.0

// CHECK:ERROR: error: invalid operand for instruction
// CHECK:ERROR:         fmov v0.4h, #1.0
// CHECK:ERROR:              ^

//----------------------------------------------------------------------
// Vector Move -  register
//----------------------------------------------------------------------
      // invalid vector type (8b, 16b)
      mov v0.2s, v31.8b
// CHECK:ERROR: error: invalid operand for instruction
// CHECK:ERROR:         mov v0.2s, v31.8b
// CHECK:ERROR:                ^

//----------------------------------------------------------------------
// Vector Absolute Difference and Accumulate (Signed, Unsigned)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types (2d)
        saba v0.16b, v1.8b, v2.8b
        uaba v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         saba v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uaba v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^

//----------------------------------------------------------------------
// Vector Absolute Difference and Accumulate (Signed, Unsigned)
// Vector Absolute Difference (Signed, Unsigned)

        // Mismatched and invalid vector types (2d)
        uaba v0.16b, v1.8b, v2.8b
        saba v0.2d, v1.2d, v2.2d
        uabd v0.4s, v1.2s, v2.2s
        sabd v0.4h, v1.8h, v8.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uaba v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         saba v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uabd v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sabd v0.4h, v1.8h, v8.8h
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Vector Absolute Difference (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fabd v0.2s, v1.4s, v2.2d
        fabd v0.4h, v1.4h, v2.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fabd v0.2s, v1.4s, v2.2d
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fabd v0.4h, v1.4h, v2.4h
// CHECK-ERROR:                 ^
//----------------------------------------------------------------------
// Vector Multiply (Polynomial)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
         pmul v0.8b, v1.8b, v2.16b
         pmul v0.2s, v1.2s, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         pmul v0.8b, v1.8b, v2.16b
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         pmul v0.2s, v1.2s, v2.2s
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Scalar Integer Add and Sub
//----------------------------------------------------------------------

      // Mismatched registers
         add d0, s1, d2
         sub s1, d1, d2

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         add d0, s1, d2
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sub s1, d1, d2
// CHECK-ERROR:             ^

//----------------------------------------------------------------------
// Vector Reciprocal Step (Floating Point)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
         frecps v0.4s, v1.2d, v2.4s
         frecps v0.8h, v1.8h, v2.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frecps v0.4s, v1.2d, v2.4s
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        frecps v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                  ^

//----------------------------------------------------------------------
// Vector Reciprocal Square Root Step (Floating Point)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
         frsqrts v0.2d, v1.2d, v2.2s
         frsqrts v0.4h, v1.4h, v2.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        frsqrts v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        frsqrts v0.4h, v1.4h, v2.4h
// CHECK-ERROR:                   ^


//----------------------------------------------------------------------
// Vector Absolute Compare Mask Less Than Or Equal (Floating Point)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
        facge v0.2d, v1.2s, v2.2d
        facge v0.4h, v1.4h, v2.4h
        facle v0.8h, v1.4h, v2.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        facge v0.2d, v1.2s, v2.2d
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        facge v0.4h, v1.4h, v2.4h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        facle v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                 ^
//----------------------------------------------------------------------
// Vector Absolute Compare Mask Less Than (Floating Point)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
        facgt v0.2d, v1.2d, v2.4s
        facgt v0.8h, v1.8h, v2.8h
        faclt v0.8b, v1.8b, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        facgt v0.2d, v1.2d, v2.4s
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        facgt v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        faclt v0.8b, v1.8b, v2.8b
// CHECK-ERROR:                 ^


//----------------------------------------------------------------------
// Vector Compare Mask Equal (Integer)
//----------------------------------------------------------------------

         // Mismatched vector types
         cmeq c0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmeq c0.2d, v1.2d, v2.2s
// CHECK-ERROR:                              ^

//----------------------------------------------------------------------
// Vector Compare Mask Higher or Same (Unsigned Integer)
// Vector Compare Mask Less or Same (Unsigned Integer)
// CMLS is alias for CMHS with operands reversed.
//----------------------------------------------------------------------

         // Mismatched vector types
         cmhs c0.4h, v1.8b, v2.8b
         cmls c0.16b, v1.16b, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmhs c0.4h, v1.8b, v2.8b
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmls c0.16b, v1.16b, v2.2d
// CHECK-ERROR:                                ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than or Equal (Integer)
// Vector Compare Mask Less Than or Equal (Integer)
// CMLE is alias for CMGE with operands reversed.
//----------------------------------------------------------------------

         // Mismatched vector types
         cmge c0.8h, v1.8b, v2.8b
         cmle c0.4h, v1.2s, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmge c0.8h, v1.8b, v2.8b
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmle c0.4h, v1.2s, v2.2s
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Vector Compare Mask Higher (Unsigned Integer)
// Vector Compare Mask Lower (Unsigned Integer)
// CMLO is alias for CMHI with operands reversed.
//----------------------------------------------------------------------

         // Mismatched vector types
         cmhi c0.4s, v1.4s, v2.16b
         cmlo c0.8b, v1.8b, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmhi c0.4s, v1.4s, v2.16b
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmlo c0.8b, v1.8b, v2.2s
// CHECK-ERROR:                               ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than (Integer)
// Vector Compare Mask Less Than (Integer)
// CMLT is alias for CMGT with operands reversed.
//----------------------------------------------------------------------

         // Mismatched vector types
         cmgt c0.8b, v1.4s, v2.16b
         cmlt c0.8h, v1.16b, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmgt c0.8b, v1.4s, v2.16b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmlt c0.8h, v1.16b, v2.4s
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Vector Compare Mask Bitwise Test (Integer)
//----------------------------------------------------------------------

         // Mismatched vector types
         cmtst c0.16b, v1.16b, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmtst c0.16b, v1.16b, v2.4s
// CHECK-ERROR:                                  ^

//----------------------------------------------------------------------
// Vector Compare Mask Equal (Floating Point)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
        fcmeq v0.2d, v1.2s, v2.2d
        fcmeq v0.16b, v1.16b, v2.16b
        fcmeq v0.8b, v1.4h, v2.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmeq v0.2d, v1.2s, v2.2d
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmeq v0.16b, v1.16b, v2.16b
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmeq v0.8b, v1.4h, v2.4h
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than Or Equal (Floating Point)
// Vector Compare Mask Less Than Or Equal (Floating Point)
// FCMLE is alias for FCMGE with operands reversed.
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
         fcmge v31.4s, v29.2s, v28.4s
         fcmge v3.8b, v8.2s, v12.2s
         fcmle v17.8h, v15.2d, v13.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmge v31.4s, v29.2s, v28.4s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmge v3.8b, v8.2s, v12.2s
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmle v17.8h, v15.2d, v13.2d
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than (Floating Point)
// Vector Compare Mask Less Than (Floating Point)
// FCMLT is alias for FCMGT with operands reversed.
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
         fcmgt v0.2d, v31.2s, v16.2s
         fcmgt v4.4s, v7.4s, v15.4h
         fcmlt v29.2d, v5.2d, v2.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmgt v0.2d, v31.2s, v16.2s
// CHECK-ERROR:                         ^

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmgt v4.4s, v7.4s, v15.4h
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmlt v29.2d, v5.2d, v2.16b
// CHECK-ERROR:                                ^

//----------------------------------------------------------------------
// Vector Compare Mask Equal to Zero (Integer)
//----------------------------------------------------------------------
        // Mismatched vector types and invalid imm
         // Mismatched vector types
         cmeq c0.2d, v1.2s, #0
         cmeq c0.2d, v1.2d, #1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmeq c0.2d, v1.2s, #0
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmeq c0.2d, v1.2d, #1
// CHECK-ERROR:                            ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than or Equal to Zero (Signed Integer)
//----------------------------------------------------------------------
        // Mismatched vector types and invalid imm
         cmge c0.8h, v1.8b, #0
         cmge c0.4s, v1.4s, #-1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmge c0.8h, v1.8b, #0
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmge c0.4s, v1.4s, #-1
// CHECK-ERROR:                             ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than Zero (Signed Integer)
//----------------------------------------------------------------------
        // Mismatched vector types and invalid imm
         cmgt c0.8b, v1.4s, #0
         cmgt c0.8b, v1.8b, #-255

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmgt c0.8b, v1.4s, #0
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmgt c0.8b, v1.8b, #-255
// CHECK-ERROR:                             ^

//----------------------------------------------------------------------
// Vector Compare Mask Less Than or Equal To Zero (Signed Integer)
//----------------------------------------------------------------------
        // Mismatched vector types and invalid imm
         cmle c0.4h, v1.2s, #0
         cmle c0.16b, v1.16b, #16

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        cmle c0.4h, v1.2s, #0
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmle c0.16b, v1.16b, #16
// CHECK-ERROR:                               ^
//----------------------------------------------------------------------
// Vector Compare Mask Less Than Zero (Signed Integer)
//----------------------------------------------------------------------
        // Mismatched vector types and invalid imm
         cmlt c0.8h, v1.16b, #0
         cmlt c0.8h, v1.8h, #-15

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmlt c0.8h, v1.16b, #0
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cmlt c0.8h, v1.8h, #-15
// CHECK-ERROR:                             ^

//----------------------------------------------------------------------
// Vector Compare Mask Equal to Zero (Floating Point)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types, invalid imm
        fcmeq v0.2d, v1.2s, #0.0
        fcmeq v0.16b, v1.16b, #0.0
        fcmeq v0.8b, v1.4h, #1.0
        fcmeq v0.8b, v1.4h, #1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmeq v0.2d, v1.2s, #0.0
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmeq v0.16b, v1.16b, #0.0
// CHECK-ERROR:                 ^


// CHECK-ERROR: error: expected floating-point constant #0.0
// CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1.0
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmeq v0.8b, v1.4h, #1
// CHECK-ERROR:                             ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than or Equal to Zero (Floating Point)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types, invalid imm
         fcmge v31.4s, v29.2s, #0.0
         fcmge v3.8b, v8.2s, #0.0
         fcmle v17.8h, v15.2d, #-1.0
         fcmle v17.8h, v15.2d, #2

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
// CHECK-ERROR:                 ^


// CHECK-ERROR: error: expected floating-point constant #0.0
// CHECK-ERROR:        fcmle v17.8h, v15.2d, #-1.0
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmle v17.8h, v15.2d, #2
// CHECK-ERROR:                               ^

//----------------------------------------------------------------------
// Vector Compare Mask Greater Than Zero (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types, invalid imm
         fcmgt v0.2d, v31.2s, #0.0
         fcmgt v4.4s, v7.4h, #0.0
         fcmlt v29.2d, v5.2d, #255.0
         fcmlt v29.2d, v5.2d, #255

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
// CHECK-ERROR:                        ^


// CHECK-ERROR: error: expected floating-point constant #0.0
// CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255.0
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmlt v29.2d, v5.2d, #255
// CHECK-ERROR:                              ^

//----------------------------------------------------------------------
// Vector Compare Mask Less Than or Equal To Zero (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types, invalid imm
         fcmge v31.4s, v29.2s, #0.0
         fcmge v3.8b, v8.2s, #0.0
         fcmle v17.2d, v15.2d, #15.0
         fcmle v17.2d, v15.2d, #15

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmge v31.4s, v29.2s, #0.0
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmge v3.8b, v8.2s, #0.0
// CHECK-ERROR:                 ^


// CHECK-ERROR: error: expected floating-point constant #0.0
// CHECK-ERROR:        fcmle v17.2d, v15.2d, #15.0
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmle v17.2d, v15.2d, #15
// CHECK-ERROR:                              ^

//----------------------------------------------------------------------
// Vector Compare Mask Less Than Zero (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types, invalid imm
         fcmgt v0.2d, v31.2s, #0.0
         fcmgt v4.4s, v7.4h, #0.0
         fcmlt v29.2d, v5.2d, #16.0
         fcmlt v29.2d, v5.2d, #2

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmgt v0.2d, v31.2s, #0.0
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmgt v4.4s, v7.4h, #0.0
// CHECK-ERROR:                        ^


// CHECK-ERROR: error: expected floating-point constant #0.0
// CHECK-ERROR:        fcmlt v29.2d, v5.2d, #16.0
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcmlt v29.2d, v5.2d, #2
// CHECK-ERROR:                              ^

/-----------------------------------------------------------------------
// Vector Integer Halving Add (Signed)
// Vector Integer Halving Add (Unsigned)
// Vector Integer Halving Sub (Signed)
// Vector Integer Halving Sub (Unsigned)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types (2d)
        shadd v0.2d, v1.2d, v2.2d
        uhadd v4.2s, v5.2s, v5.4h
        shsub v11.4h, v12.8h, v13.4h
        uhsub v31.16b, v29.8b, v28.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        shadd v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uhadd v4.2s, v5.2s, v5.4h
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        shsub v11.4h, v12.8h, v13.4h
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uhsub v31.16b, v29.8b, v28.8b
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Vector Integer Rouding Halving Add (Signed)
// Vector Integer Rouding Halving Add (Unsigned)
//----------------------------------------------------------------------

        // Mismatched and invalid vector types (2d)
        srhadd v0.2s, v1.2s, v2.2d
        urhadd v0.16b, v1.16b, v2.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        srhadd v0.2s, v1.2s, v2.2d
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        urhadd v0.16b, v1.16b, v2.8h
// CHECK-ERROR:                                  ^

//----------------------------------------------------------------------
// Vector Integer Saturating Add (Signed)
// Vector Integer Saturating Add (Unsigned)
// Vector Integer Saturating Sub (Signed)
// Vector Integer Saturating Sub (Unsigned)
//----------------------------------------------------------------------

        // Mismatched vector types
        sqadd v0.2s, v1.2s, v2.2d
        uqadd v31.8h, v1.4h, v2.4h
        sqsub v10.8h, v1.16b, v2.16b
        uqsub v31.8b, v1.8b, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqadd v0.2s, v1.2s, v2.2d
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqadd v31.8h, v1.4h, v2.4h
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqsub v10.8h, v1.16b, v2.16b
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqsub v31.8b, v1.8b, v2.4s
// CHECK-ERROR:                                ^

//----------------------------------------------------------------------
// Scalar Integer Saturating Add (Signed)
// Scalar Integer Saturating Add (Unsigned)
// Scalar Integer Saturating Sub (Signed)
// Scalar Integer Saturating Sub (Unsigned)
//----------------------------------------------------------------------

      // Mismatched registers
         sqadd d0, s31, d2
         uqadd s0, s1, d2
         sqsub b0, b2, s18
         uqsub h1, h2, d2

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqadd d0, s31, d2
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqadd s0, s1, d2
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqsub b0, b2, s18
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqsub h1, h2, d2
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Scalar Integer Saturating Doubling Multiply Half High (Signed)
//----------------------------------------------------------------------

    sqdmulh h10, s11, h12
    sqdmulh s20, h21, s2

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmulh h10, s11, h12
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmulh s20, h21, s2
// CHECK-ERROR:                     ^

//------------------------------------------------------------------------
// Scalar Integer Saturating Rounding Doubling Multiply Half High (Signed)
//------------------------------------------------------------------------

    sqrdmulh h10, s11, h12
    sqrdmulh s20, h21, s2

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrdmulh h10, s11, h12
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrdmulh s20, h21, s2
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Vector Shift Left (Signed and Unsigned Integer)
//----------------------------------------------------------------------
        // Mismatched vector types
        sshl v0.4s, v15.2s, v16.2s
        ushl v1.16b, v25.16b, v6.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sshl v0.4s, v15.2s, v16.2s
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ushl v1.16b, v25.16b, v6.8h
// CHECK-ERROR:                                 ^

//----------------------------------------------------------------------
// Vector Saturating Shift Left (Signed and Unsigned Integer)
//----------------------------------------------------------------------
        // Mismatched vector types
        sqshl v0.2s, v15.4s, v16.2d
        uqshl v1.8b, v25.4h, v6.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqshl v0.2s, v15.4s, v16.2d
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqshl v1.8b, v25.4h, v6.8h
// CHECK-ERROR:                         ^

//----------------------------------------------------------------------
// Vector Rouding Shift Left (Signed and Unsigned Integer)
//----------------------------------------------------------------------
        // Mismatched vector types
        srshl v0.8h, v15.8h, v16.16b
        urshl v1.2d, v25.2d, v6.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        srshl v0.8h, v15.8h, v16.16b
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        urshl v1.2d, v25.2d, v6.4s
// CHECK-ERROR:                                ^

//----------------------------------------------------------------------
// Vector Saturating Rouding Shift Left (Signed and Unsigned Integer)
//----------------------------------------------------------------------
        // Mismatched vector types
        sqrshl v0.2s, v15.8h, v16.16b
        uqrshl v1.4h, v25.4h,  v6.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrshl v0.2s, v15.8h, v16.16b
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqrshl v1.4h, v25.4h,  v6.2d
// CHECK-ERROR:                                  ^

//----------------------------------------------------------------------
// Scalar Integer Shift Left (Signed, Unsigned)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        sshl d0, d1, s2
        ushl b2, b0, b1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sshl d0, d1, s2
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ushl b2, b0, b1
// CHECK-ERROR:             ^

//----------------------------------------------------------------------
// Scalar Integer Saturating Shift Left (Signed, Unsigned)
//----------------------------------------------------------------------

        // Mismatched vector types
        sqshl b0, s1, b0
        uqshl h0, b1, h0
        sqshl s0, h1, s0
        uqshl d0, b1, d0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqshl b0, s1, b0
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqshl h0, b1, h0
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqshl s0, h1, s0
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqshl d0, b1, d0
// CHECK-ERROR:                  ^

//----------------------------------------------------------------------
// Scalar Integer Rouding Shift Left (Signed, Unsigned)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        srshl h0, h1, h2
        urshl s0, s1, s2

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        srshl h0, h1, h2
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        urshl s0, s1, s2
// CHECK-ERROR:              ^


//----------------------------------------------------------------------
// Scalar Integer Saturating Rounding Shift Left (Signed, Unsigned)
//----------------------------------------------------------------------

        // Mismatched vector types
        sqrshl b0, b1, s0
        uqrshl h0, h1, b0
        sqrshl s0, s1, h0
        uqrshl d0, d1, b0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrshl b0, b1, s0
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqrshl h0, h1, b0
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrshl s0, s1, h0
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqrshl d0, d1, b0
// CHECK-ERROR:                       ^


//----------------------------------------------------------------------
// Vector Maximum (Signed, Unsigned)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        smax v0.2d, v1.2d, v2.2d
        umax v0.4h, v1.4h, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smax v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umax v0.4h, v1.4h, v2.2s
// CHECK-ERROR:                              ^

//----------------------------------------------------------------------
// Vector Minimum (Signed, Unsigned)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        smin v0.2d, v1.2d, v2.2d
        umin v0.2s, v1.2s, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smin v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umin v0.2s, v1.2s, v2.8b
// CHECK-ERROR:                             ^


//----------------------------------------------------------------------
// Vector Maximum (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fmax v0.2s, v1.2s, v2.4s
        fmax v0.8b, v1.8b, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmax v0.2s, v1.2s, v2.4s
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmax v0.8b, v1.8b, v2.8b
// CHECK-ERROR:                ^
//----------------------------------------------------------------------
// Vector Minimum (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fmin v0.4s, v1.4s, v2.2d
        fmin v0.8h, v1.8h, v2.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmin v0.4s, v1.4s, v2.2d
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmin v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                ^

//----------------------------------------------------------------------
// Vector maxNum (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fmaxnm v0.2s, v1.2s, v2.2d
        fmaxnm v0.4h, v1.8h, v2.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxnm v0.2s, v1.2s, v2.2d
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxnm v0.4h, v1.8h, v2.4h
// CHECK-ERROR:                  ^

//----------------------------------------------------------------------
// Vector minNum (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fminnm v0.4s, v1.2s, v2.4s
        fminnm v0.16b, v0.16b, v0.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminnm v0.4s, v1.2s, v2.4s
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminnm v0.16b, v0.16b, v0.16b
// CHECK-ERROR:                  ^


//----------------------------------------------------------------------
// Vector Maximum Pairwise (Signed, Unsigned)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        smaxp v0.2d, v1.2d, v2.2d
        umaxp v0.4h, v1.4h, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smaxp v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umaxp v0.4h, v1.4h, v2.2s
// CHECK-ERROR:                               ^

//----------------------------------------------------------------------
// Vector Minimum Pairwise (Signed, Unsigned)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        sminp v0.2d, v1.2d, v2.2d
        uminp v0.2s, v1.2s, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sminp v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uminp v0.2s, v1.2s, v2.8b
// CHECK-ERROR:                               ^


//----------------------------------------------------------------------
// Vector Maximum Pairwise (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fmaxp v0.2s, v1.2s, v2.4s
        fmaxp v0.8b, v1.8b, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxp v0.2s, v1.2s, v2.4s
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxp v0.8b, v1.8b, v2.8b
// CHECK-ERROR:                 ^
//----------------------------------------------------------------------
// Vector Minimum Pairwise (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fminp v0.4s, v1.4s, v2.2d
        fminp v0.8h, v1.8h, v2.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminp v0.4s, v1.4s, v2.2d
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fminp v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Vector maxNum Pairwise (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fmaxnmp v0.2s, v1.2s, v2.2d
        fmaxnmp v0.4h, v1.8h, v2.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxnmp v0.2s, v1.2s, v2.2d
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxnmp v0.4h, v1.8h, v2.4h
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Vector minNum Pairwise (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        fminnmp v0.4s, v1.2s, v2.4s
        fminnmp v0.16b, v0.16b, v0.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminnmp v0.4s, v1.2s, v2.4s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminnmp v0.16b, v0.16b, v0.16b
// CHECK-ERROR:                   ^


//----------------------------------------------------------------------
// Vector Add Pairwise (Integer)
//----------------------------------------------------------------------

        // Mismatched vector types
        addp v0.16b, v1.8b, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         addp v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                         ^

//----------------------------------------------------------------------
// Vector Add Pairwise (Floating Point)
//----------------------------------------------------------------------
        // Mismatched and invalid vector types
        faddp v0.16b, v1.8b, v2.8b
        faddp v0.2d, v1.2d, v2.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         faddp v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         faddp v0.2d, v1.2d, v2.8h
// CHECK-ERROR:                                ^


//----------------------------------------------------------------------
// Vector Saturating Doubling Multiply High
//----------------------------------------------------------------------
         // Mismatched and invalid vector types
         sqdmulh v2.4h, v25.8h, v3.4h
         sqdmulh v12.2d, v5.2d, v13.2d
         sqdmulh v3.8b, v1.8b, v30.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqdmulh v2.4h, v25.8h, v3.4h
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqdmulh v12.2d, v5.2d, v13.2d
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqdmulh v3.8b, v1.8b, v30.8b
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Vector Saturating Rouding Doubling Multiply High
//----------------------------------------------------------------------
         // Mismatched and invalid vector types
         sqrdmulh v2.2s, v25.4s, v3.4s
         sqrdmulh v12.16b, v5.16b, v13.16b
         sqrdmulh v3.4h, v1.4h, v30.2d


// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrdmulh v2.2s, v25.4s, v3.4s
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrdmulh v12.16b, v5.16b, v13.16b
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrdmulh v3.4h, v1.4h, v30.2d
// CHECK-ERROR:                                    ^

//----------------------------------------------------------------------
// Vector Multiply Extended
//----------------------------------------------------------------------
         // Mismatched and invalid vector types
      fmulx v21.2s, v5.2s, v13.2d
      fmulx v1.4h, v25.4h, v3.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fmulx v21.2s, v5.2s, v13.2d
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fmulx v1.4h, v25.4h, v3.4h
// CHECK-ERROR:                  ^

//------------------------------------------------------------------------------
// Vector Shift Left by Immediate
//------------------------------------------------------------------------------
         // Mismatched vector types and out of range
         shl v0.4s, v15,2s, #3
         shl v0.2d, v17.4s, #3
         shl v0.8b, v31.8b, #-1
         shl v0.8b, v31.8b, #8
         shl v0.4s, v21.4s, #32
         shl v0.2d, v1.2d, #64


// CHECK-ERROR: error: unexpected token in argument list
// CHECK-ERROR:         shl v0.4s, v15,2s, #3
// CHECK-ERROR:                         ^

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shl v0.2d, v17.4s, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:         shl v0.8b, v31.8b, #-1
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:         shl v0.8b, v31.8b, #8
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:         shl v0.4s, v21.4s, #32
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:         shl v0.2d, v1.2d, #64
// CHECK-ERROR:                           ^

//----------------------------------------------------------------------
// Vector Shift Left Long by Immediate
//----------------------------------------------------------------------
        // Mismatched vector types
        sshll v0.4s, v15.2s, #3
        ushll v1.16b, v25.16b, #6
        sshll2 v0.2d, v3.8s, #15
        ushll2 v1.4s, v25.4s, #7

        // Out of range
        sshll v0.8h, v1.8b, #-1
        sshll v0.8h, v1.8b, #9
        ushll v0.4s, v1.4h, #17
        ushll v0.2d, v1.2s, #33
        sshll2 v0.8h, v1.16b, #9
        sshll2 v0.4s, v1.8h, #17
        ushll2 v0.2d, v1.4s, #33

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sshll v0.4s, v15.2s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ushll v1.16b, v25.16b, #6
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sshll2 v0.2d, v3.8s, #15
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ushll2 v1.4s, v25.4s, #7
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:        sshll v0.8h, v1.8b, #-1
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:        sshll v0.8h, v1.8b, #9
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:        ushll v0.4s, v1.4h, #17
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:        ushll v0.2d, v1.2s, #33
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:        sshll2 v0.8h, v1.16b, #9
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:        sshll2 v0.4s, v1.8h, #17
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:        ushll2 v0.2d, v1.4s, #33
// CHECK-ERROR:                             ^


//------------------------------------------------------------------------------
// Vector shift right by immediate
//------------------------------------------------------------------------------
         sshr v0.8b, v1.8h, #3
         sshr v0.4h, v1.4s, #3
         sshr v0.2s, v1.2d, #3
         sshr v0.16b, v1.16b, #9
         sshr v0.8h, v1.8h, #17
         sshr v0.4s, v1.4s, #33
         sshr v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sshr v0.8b, v1.8h, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sshr v0.4h, v1.4s, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sshr v0.2s, v1.2d, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         sshr v0.16b, v1.16b, #9
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         sshr v0.8h, v1.8h, #17
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         sshr v0.4s, v1.4s, #33
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         sshr v0.2d, v1.2d, #65
// CHECK-ERROR:                            ^

//------------------------------------------------------------------------------
// Vector  shift right by immediate
//------------------------------------------------------------------------------
         ushr v0.8b, v1.8h, #3
         ushr v0.4h, v1.4s, #3
         ushr v0.2s, v1.2d, #3
         ushr v0.16b, v1.16b, #9
         ushr v0.8h, v1.8h, #17
         ushr v0.4s, v1.4s, #33
         ushr v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ushr v0.8b, v1.8h, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ushr v0.4h, v1.4s, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ushr v0.2s, v1.2d, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         ushr v0.16b, v1.16b, #9
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         ushr v0.8h, v1.8h, #17
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         ushr v0.4s, v1.4s, #33
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         ushr v0.2d, v1.2d, #65
// CHECK-ERROR:                            ^

//------------------------------------------------------------------------------
// Vector shift right and accumulate by immediate
//------------------------------------------------------------------------------
         ssra v0.8b, v1.8h, #3
         ssra v0.4h, v1.4s, #3
         ssra v0.2s, v1.2d, #3
         ssra v0.16b, v1.16b, #9
         ssra v0.8h, v1.8h, #17
         ssra v0.4s, v1.4s, #33
         ssra v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ssra v0.8b, v1.8h, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ssra v0.4h, v1.4s, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ssra v0.2s, v1.2d, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         ssra v0.16b, v1.16b, #9
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         ssra v0.8h, v1.8h, #17
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         ssra v0.4s, v1.4s, #33
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         ssra v0.2d, v1.2d, #65
// CHECK-ERROR:                            ^

//------------------------------------------------------------------------------
// Vector  shift right and accumulate by immediate
//------------------------------------------------------------------------------
         usra v0.8b, v1.8h, #3
         usra v0.4h, v1.4s, #3
         usra v0.2s, v1.2d, #3
         usra v0.16b, v1.16b, #9
         usra v0.8h, v1.8h, #17
         usra v0.4s, v1.4s, #33
         usra v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         usra v0.8b, v1.8h, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         usra v0.4h, v1.4s, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         usra v0.2s, v1.2d, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         usra v0.16b, v1.16b, #9
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         usra v0.8h, v1.8h, #17
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         usra v0.4s, v1.4s, #33
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         usra v0.2d, v1.2d, #65
// CHECK-ERROR:                            ^

//------------------------------------------------------------------------------
// Vector rounding shift right by immediate
//------------------------------------------------------------------------------
         srshr v0.8b, v1.8h, #3
         srshr v0.4h, v1.4s, #3
         srshr v0.2s, v1.2d, #3
         srshr v0.16b, v1.16b, #9
         srshr v0.8h, v1.8h, #17
         srshr v0.4s, v1.4s, #33
         srshr v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         srshr v0.8b, v1.8h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         srshr v0.4h, v1.4s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         srshr v0.2s, v1.2d, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         srshr v0.16b, v1.16b, #9
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         srshr v0.8h, v1.8h, #17
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         srshr v0.4s, v1.4s, #33
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         srshr v0.2d, v1.2d, #65
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Vecotr rounding shift right by immediate
//------------------------------------------------------------------------------
         urshr v0.8b, v1.8h, #3
         urshr v0.4h, v1.4s, #3
         urshr v0.2s, v1.2d, #3
         urshr v0.16b, v1.16b, #9
         urshr v0.8h, v1.8h, #17
         urshr v0.4s, v1.4s, #33
         urshr v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urshr v0.8b, v1.8h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urshr v0.4h, v1.4s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urshr v0.2s, v1.2d, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         urshr v0.16b, v1.16b, #9
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         urshr v0.8h, v1.8h, #17
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         urshr v0.4s, v1.4s, #33
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         urshr v0.2d, v1.2d, #65
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Vector rounding shift right and accumulate by immediate
//------------------------------------------------------------------------------
         srsra v0.8b, v1.8h, #3
         srsra v0.4h, v1.4s, #3
         srsra v0.2s, v1.2d, #3
         srsra v0.16b, v1.16b, #9
         srsra v0.8h, v1.8h, #17
         srsra v0.4s, v1.4s, #33
         srsra v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         srsra v0.8b, v1.8h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         srsra v0.4h, v1.4s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         srsra v0.2s, v1.2d, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         srsra v0.16b, v1.16b, #9
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         srsra v0.8h, v1.8h, #17
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         srsra v0.4s, v1.4s, #33
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         srsra v0.2d, v1.2d, #65
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Vector rounding shift right and accumulate by immediate
//------------------------------------------------------------------------------
         ursra v0.8b, v1.8h, #3
         ursra v0.4h, v1.4s, #3
         ursra v0.2s, v1.2d, #3
         ursra v0.16b, v1.16b, #9
         ursra v0.8h, v1.8h, #17
         ursra v0.4s, v1.4s, #33
         ursra v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursra v0.8b, v1.8h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursra v0.4h, v1.4s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursra v0.2s, v1.2d, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         ursra v0.16b, v1.16b, #9
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         ursra v0.8h, v1.8h, #17
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         ursra v0.4s, v1.4s, #33
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         ursra v0.2d, v1.2d, #65
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Vector shift right and insert by immediate
//------------------------------------------------------------------------------
         sri v0.8b, v1.8h, #3
         sri v0.4h, v1.4s, #3
         sri v0.2s, v1.2d, #3
         sri v0.16b, v1.16b, #9
         sri v0.8h, v1.8h, #17
         sri v0.4s, v1.4s, #33
         sri v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sri v0.8b, v1.8h, #3
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sri v0.4h, v1.4s, #3
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sri v0.2s, v1.2d, #3
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         sri v0.16b, v1.16b, #9
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         sri v0.8h, v1.8h, #17
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         sri v0.4s, v1.4s, #33
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         sri v0.2d, v1.2d, #65
// CHECK-ERROR:                           ^

//------------------------------------------------------------------------------
// Vector shift left and insert by immediate
//------------------------------------------------------------------------------
         sli v0.8b, v1.8h, #3
         sli v0.4h, v1.4s, #3
         sli v0.2s, v1.2d, #3
         sli v0.16b, v1.16b, #8
         sli v0.8h, v1.8h, #16
         sli v0.4s, v1.4s, #32
         sli v0.2d, v1.2d, #64

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sli v0.8b, v1.8h, #3
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sli v0.4h, v1.4s, #3
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sli v0.2s, v1.2d, #3
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:         sli v0.16b, v1.16b, #8
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:         sli v0.8h, v1.8h, #16
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:         sli v0.4s, v1.4s, #32
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:         sli v0.2d, v1.2d, #64
// CHECK-ERROR:                           ^

//------------------------------------------------------------------------------
// Vector saturating shift left unsigned by immediate
//------------------------------------------------------------------------------
         sqshlu v0.8b, v1.8h, #3
         sqshlu v0.4h, v1.4s, #3
         sqshlu v0.2s, v1.2d, #3
         sqshlu v0.16b, v1.16b, #8
         sqshlu v0.8h, v1.8h, #16
         sqshlu v0.4s, v1.4s, #32
         sqshlu v0.2d, v1.2d, #64

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshlu v0.8b, v1.8h, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshlu v0.4h, v1.4s, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshlu v0.2s, v1.2d, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:         sqshlu v0.16b, v1.16b, #8
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:         sqshlu v0.8h, v1.8h, #16
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:         sqshlu v0.4s, v1.4s, #32
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:         sqshlu v0.2d, v1.2d, #64
// CHECK-ERROR:                              ^

//------------------------------------------------------------------------------
// Vector saturating shift left by immediate
//------------------------------------------------------------------------------
         sqshl v0.8b, v1.8h, #3
         sqshl v0.4h, v1.4s, #3
         sqshl v0.2s, v1.2d, #3
         sqshl v0.16b, v1.16b, #8
         sqshl v0.8h, v1.8h, #16
         sqshl v0.4s, v1.4s, #32
         sqshl v0.2d, v1.2d, #64

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshl v0.8b, v1.8h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshl v0.4h, v1.4s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshl v0.2s, v1.2d, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:         sqshl v0.16b, v1.16b, #8
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:         sqshl v0.8h, v1.8h, #16
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:         sqshl v0.4s, v1.4s, #32
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:         sqshl v0.2d, v1.2d, #64
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Vector saturating shift left by immediate
//------------------------------------------------------------------------------
         uqshl v0.8b, v1.8h, #3
         uqshl v0.4h, v1.4s, #3
         uqshl v0.2s, v1.2d, #3
         uqshl v0.16b, v1.16b, #8
         uqshl v0.8h, v1.8h, #16
         uqshl v0.4s, v1.4s, #32
         uqshl v0.2d, v1.2d, #64

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqshl v0.8b, v1.8h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqshl v0.4h, v1.4s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqshl v0.2s, v1.2d, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:         uqshl v0.16b, v1.16b, #8
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:         uqshl v0.8h, v1.8h, #16
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:         uqshl v0.4s, v1.4s, #32
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:         uqshl v0.2d, v1.2d, #64
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Vector shift right narrow by immediate
//------------------------------------------------------------------------------
         shrn v0.8b, v1.8b, #3
         shrn v0.4h, v1.4h, #3
         shrn v0.2s, v1.2s, #3
         shrn2 v0.16b, v1.8h, #17
         shrn2 v0.8h, v1.4s, #33
         shrn2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shrn v0.8b, v1.8b, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shrn v0.4h, v1.4h, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shrn v0.2s, v1.2s, #3
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         shrn2 v0.16b, v1.8h, #17
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         shrn2 v0.8h, v1.4s, #33
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         shrn2 v0.4s, v1.2d, #65
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Vector saturating shift right unsigned narrow by immediate
//------------------------------------------------------------------------------
         sqshrun v0.8b, v1.8b, #3
         sqshrun v0.4h, v1.4h, #3
         sqshrun v0.2s, v1.2s, #3
         sqshrun2 v0.16b, v1.8h, #17
         sqshrun2 v0.8h, v1.4s, #33
         sqshrun2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshrun v0.8b, v1.8b, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshrun v0.4h, v1.4h, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshrun v0.2s, v1.2s, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         sqshrun2 v0.16b, v1.8h, #17
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         sqshrun2 v0.8h, v1.4s, #33
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         sqshrun2 v0.4s, v1.2d, #65
// CHECK-ERROR:                                ^

//------------------------------------------------------------------------------
// Vector rounding shift right narrow by immediate
//------------------------------------------------------------------------------
         rshrn v0.8b, v1.8b, #3
         rshrn v0.4h, v1.4h, #3
         rshrn v0.2s, v1.2s, #3
         rshrn2 v0.16b, v1.8h, #17
         rshrn2 v0.8h, v1.4s, #33
         rshrn2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rshrn v0.8b, v1.8b, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rshrn v0.4h, v1.4h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rshrn v0.2s, v1.2s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         rshrn2 v0.16b, v1.8h, #17
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         rshrn2 v0.8h, v1.4s, #33
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         rshrn2 v0.4s, v1.2d, #65
// CHECK-ERROR:                              ^

//------------------------------------------------------------------------------
// Vector saturating shift right rounded unsigned narrow by immediate
//------------------------------------------------------------------------------
         sqrshrun v0.8b, v1.8b, #3
         sqrshrun v0.4h, v1.4h, #3
         sqrshrun v0.2s, v1.2s, #3
         sqrshrun2 v0.16b, v1.8h, #17
         sqrshrun2 v0.8h, v1.4s, #33
         sqrshrun2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrshrun v0.8b, v1.8b, #3
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrshrun v0.4h, v1.4h, #3
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrshrun v0.2s, v1.2s, #3
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         sqrshrun2 v0.16b, v1.8h, #17
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         sqrshrun2 v0.8h, v1.4s, #33
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         sqrshrun2 v0.4s, v1.2d, #65
// CHECK-ERROR:                                 ^

//------------------------------------------------------------------------------
// Vector saturating shift right narrow by immediate
//------------------------------------------------------------------------------
         sqshrn v0.8b, v1.8b, #3
         sqshrn v0.4h, v1.4h, #3
         sqshrn v0.2s, v1.2s, #3
         sqshrn2 v0.16b, v1.8h, #17
         sqshrn2 v0.8h, v1.4s, #33
         sqshrn2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshrn v0.8b, v1.8b, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshrn v0.4h, v1.4h, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqshrn v0.2s, v1.2s, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         sqshrn2 v0.16b, v1.8h, #17
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         sqshrn2 v0.8h, v1.4s, #33
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         sqshrn2 v0.4s, v1.2d, #65
// CHECK-ERROR:                               ^

//------------------------------------------------------------------------------
// Vector saturating shift right narrow by immediate
//------------------------------------------------------------------------------
         uqshrn v0.8b, v1.8b, #3
         uqshrn v0.4h, v1.4h, #3
         uqshrn v0.2s, v1.2s, #3
         uqshrn2 v0.16b, v1.8h, #17
         uqshrn2 v0.8h, v1.4s, #33
         uqshrn2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqshrn v0.8b, v1.8b, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqshrn v0.4h, v1.4h, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqshrn v0.2s, v1.2s, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         uqshrn2 v0.16b, v1.8h, #17
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         uqshrn2 v0.8h, v1.4s, #33
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         uqshrn2 v0.4s, v1.2d, #65
// CHECK-ERROR:                               ^

//------------------------------------------------------------------------------
// Vector saturating shift right rounded narrow by immediate
//------------------------------------------------------------------------------
         sqrshrn v0.8b, v1.8b, #3
         sqrshrn v0.4h, v1.4h, #3
         sqrshrn v0.2s, v1.2s, #3
         sqrshrn2 v0.16b, v1.8h, #17
         sqrshrn2 v0.8h, v1.4s, #33
         sqrshrn2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrshrn v0.8b, v1.8b, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrshrn v0.4h, v1.4h, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqrshrn v0.2s, v1.2s, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         sqrshrn2 v0.16b, v1.8h, #17
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         sqrshrn2 v0.8h, v1.4s, #33
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         sqrshrn2 v0.4s, v1.2d, #65
// CHECK-ERROR:                                ^

//------------------------------------------------------------------------------
// Vector saturating shift right rounded narrow by immediate
//------------------------------------------------------------------------------
         uqrshrn v0.8b, v1.8b, #3
         uqrshrn v0.4h, v1.4h, #3
         uqrshrn v0.2s, v1.2s, #3
         uqrshrn2 v0.16b, v1.8h, #17
         uqrshrn2 v0.8h, v1.4s, #33
         uqrshrn2 v0.4s, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqrshrn v0.8b, v1.8b, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqrshrn v0.4h, v1.4h, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqrshrn v0.2s, v1.2s, #3
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:         uqrshrn2 v0.16b, v1.8h, #17
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:         uqrshrn2 v0.8h, v1.4s, #33
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         uqrshrn2 v0.4s, v1.2d, #65
// CHECK-ERROR:                                ^

//------------------------------------------------------------------------------
// Fixed-point convert to floating-point
//------------------------------------------------------------------------------
         scvtf v0.2s, v1.2d, #3
         scvtf v0.4s, v1.4h, #3
         scvtf v0.2d, v1.2s, #3
         ucvtf v0.2s, v1.2s, #33
         ucvtf v0.4s, v1.4s, #33
         ucvtf v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         scvtf v0.2s, v1.2d, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         scvtf v0.4s, v1.4h, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         scvtf v0.2d, v1.2s, #3
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         ucvtf v0.2s, v1.2s, #33
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         ucvtf v0.4s, v1.4s, #33
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         ucvtf v0.2d, v1.2d, #65
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Floating-point convert to fixed-point
//------------------------------------------------------------------------------
         fcvtzs v0.2s, v1.2d, #3
         fcvtzs v0.4s, v1.4h, #3
         fcvtzs v0.2d, v1.2s, #3
         fcvtzu v0.2s, v1.2s, #33
         fcvtzu v0.4s, v1.4s, #33
         fcvtzu v0.2d, v1.2d, #65

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtzs v0.2s, v1.2d, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtzs v0.4s, v1.4h, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtzs v0.2d, v1.2s, #3
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         fcvtzu v0.2s, v1.2s, #33
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:         fcvtzu v0.4s, v1.4s, #33
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:         fcvtzu v0.2d, v1.2d, #65
// CHECK-ERROR:                              ^

//----------------------------------------------------------------------
// Vector operation on 3 operands with different types
//----------------------------------------------------------------------

        // Mismatched and invalid vector types
        saddl v0.8h, v1.8h, v2.8b
        saddl v0.4s, v1.4s, v2.4h
        saddl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        saddl2 v0.4s, v1.8s, v2.8h
        saddl2 v0.8h, v1.16h, v2.16b
        saddl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        uaddl v0.8h, v1.8h, v2.8b
        uaddl v0.4s, v1.4s, v2.4h
        uaddl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        uaddl2 v0.8h, v1.16h, v2.16b
        uaddl2 v0.4s, v1.8s, v2.8h
        uaddl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        ssubl v0.8h, v1.8h, v2.8b
        ssubl v0.4s, v1.4s, v2.4h
        ssubl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        ssubl2 v0.8h, v1.16h, v2.16b
        ssubl2 v0.4s, v1.8s, v2.8h
        ssubl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        usubl v0.8h, v1.8h, v2.8b
        usubl v0.4s, v1.4s, v2.4h
        usubl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        usubl2 v0.8h, v1.16h, v2.16b
        usubl2 v0.4s, v1.8s, v2.8h
        usubl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        sabal v0.8h, v1.8h, v2.8b
        sabal v0.4s, v1.4s, v2.4h
        sabal v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabal v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabal v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabal v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        sabal2 v0.8h, v1.16h, v2.16b
        sabal2 v0.4s, v1.8s, v2.8h
        sabal2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabal2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabal2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabal2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        uabal v0.8h, v1.8h, v2.8b
        uabal v0.4s, v1.4s, v2.4h
        uabal v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabal v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabal v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabal v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        uabal2 v0.8h, v1.16h, v2.16b
        uabal2 v0.4s, v1.8s, v2.8h
        uabal2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabal2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabal2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabal2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        sabdl v0.8h, v1.8h, v2.8b
        sabdl v0.4s, v1.4s, v2.4h
        sabdl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabdl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabdl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabdl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        sabdl2 v0.8h, v1.16h, v2.16b
        sabdl2 v0.4s, v1.8s, v2.8h
        sabdl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabdl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabdl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sabdl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        uabdl v0.8h, v1.8h, v2.8b
        uabdl v0.4s, v1.4s, v2.4h
        uabdl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabdl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabdl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabdl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        uabdl2 v0.8h, v1.16h, v2.16b
        uabdl2 v0.4s, v1.8s, v2.8h
        uabdl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabdl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabdl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uabdl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        smlal v0.8h, v1.8h, v2.8b
        smlal v0.4s, v1.4s, v2.4h
        smlal v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        smlal2 v0.8h, v1.16h, v2.16b
        smlal2 v0.4s, v1.8s, v2.8h
        smlal2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        umlal v0.8h, v1.8h, v2.8b
        umlal v0.4s, v1.4s, v2.4h
        umlal v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        umlal2 v0.8h, v1.16h, v2.16b
        umlal2 v0.4s, v1.8s, v2.8h
        umlal2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        smlsl v0.8h, v1.8h, v2.8b
        smlsl v0.4s, v1.4s, v2.4h
        smlsl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        smlsl2 v0.8h, v1.16h, v2.16b
        smlsl2 v0.4s, v1.8s, v2.8h
        smlsl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        umlsl v0.8h, v1.8h, v2.8b
        umlsl v0.4s, v1.4s, v2.4h
        umlsl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        umlsl2 v0.8h, v1.16h, v2.16b
        umlsl2 v0.4s, v1.8s, v2.8h
        umlsl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        smull v0.8h, v1.8h, v2.8b
        smull v0.4s, v1.4s, v2.4h
        smull v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        smull2 v0.8h, v1.16h, v2.16b
        smull2 v0.4s, v1.8s, v2.8h
        smull2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

        umull v0.8h, v1.8h, v2.8b
        umull v0.4s, v1.4s, v2.4h
        umull v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                        ^

        umull2 v0.8h, v1.16h, v2.16b
        umull2 v0.4s, v1.8s, v2.8h
        umull2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                      ^

//------------------------------------------------------------------------------
// Long - Variant 2
//------------------------------------------------------------------------------

        sqdmlal v0.4s, v1.4s, v2.4h
        sqdmlal v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                          ^

        sqdmlal2 v0.4s, v1.8s, v2.8h
        sqdmlal2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                        ^

        // Mismatched vector types
        sqdmlal v0.8h, v1.8b, v2.8b
        sqdmlal2 v0.8h, v1.16b, v2.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal v0.8h, v1.8b, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal2 v0.8h, v1.16b, v2.16b
// CHECK-ERROR:                    ^

        sqdmlsl v0.4s, v1.4s, v2.4h
        sqdmlsl v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                          ^

        sqdmlsl2 v0.4s, v1.8s, v2.8h
        sqdmlsl2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                        ^

        // Mismatched vector types
        sqdmlsl v0.8h, v1.8b, v2.8b
        sqdmlsl2 v0.8h, v1.16b, v2.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl v0.8h, v1.8b, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl2 v0.8h, v1.16b, v2.16b
// CHECK-ERROR:                    ^


        sqdmull v0.4s, v1.4s, v2.4h
        sqdmull v0.2d, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull v0.4s, v1.4s, v2.4h
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull v0.2d, v1.2d, v2.2s
// CHECK-ERROR:                          ^

        sqdmull2 v0.4s, v1.8s, v2.8h
        sqdmull2 v0.2d, v1.4d, v2.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull2 v0.4s, v1.8s, v2.8h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull2 v0.2d, v1.4d, v2.4s
// CHECK-ERROR:                        ^

        // Mismatched vector types
        sqdmull v0.8h, v1.8b, v2.8b
        sqdmull2 v0.8h, v1.16b, v2.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull v0.8h, v1.8b, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull2 v0.8h, v1.16b, v2.16b
// CHECK-ERROR:                    ^


//------------------------------------------------------------------------------
// Long - Variant 3
//------------------------------------------------------------------------------

        pmull v0.8h, v1.8h, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        pmull v0.8h, v1.8h, v2.8b
// CHECK-ERROR:                        ^

        pmull v0.1q, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        pmull v0.1q, v1.2d, v2.2d
// CHECK-ERROR:                     ^

        // Mismatched vector types
        pmull v0.4s, v1.4h, v2.4h
        pmull v0.2d, v1.2s, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        pmull v0.4s, v1.4h, v2.4h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        pmull v0.2d, v1.2s, v2.2s
// CHECK-ERROR:                 ^


        pmull2 v0.8h, v1.16h, v2.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        pmull2 v0.8h, v1.16h, v2.16b
// CHECK-ERROR:                      ^

        pmull2 v0.q, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        pmull2 v0.q, v1.2d, v2.2d
// CHECK-ERROR:                  ^

        // Mismatched vector types
        pmull2 v0.4s, v1.8h v2.8h
        pmull2 v0.2d, v1.4s, v2.4s


// CHECK-ERROR: error: unexpected token in argument list
// CHECK-ERROR:        pmull2 v0.4s, v1.8h v2.8h
// CHECK-ERROR:                            ^

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        pmull2 v0.2d, v1.4s, v2.4s
// CHECK-ERROR:                  ^

//------------------------------------------------------------------------------
// Widen
//------------------------------------------------------------------------------

        saddw v0.8h, v1.8h, v2.8h
        saddw v0.4s, v1.4s, v2.4s
        saddw v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddw v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddw v0.4s, v1.4s, v2.4s
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddw v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                               ^

        saddw2 v0.8h, v1.8h, v2.16h
        saddw2 v0.4s, v1.4s, v2.8s
        saddw2 v0.2d, v1.2d, v2.4d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddw2 v0.8h, v1.8h, v2.16h
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddw2 v0.4s, v1.4s, v2.8s
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddw2 v0.2d, v1.2d, v2.4d
// CHECK-ERROR:                             ^

        uaddw v0.8h, v1.8h, v2.8h
        uaddw v0.4s, v1.4s, v2.4s
        uaddw v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddw v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddw v0.4s, v1.4s, v2.4s
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddw v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                               ^

        uaddw2 v0.8h, v1.8h, v2.16h
        uaddw2 v0.4s, v1.4s, v2.8s
        uaddw2 v0.2d, v1.2d, v2.4d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddw2 v0.8h, v1.8h, v2.16h
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddw2 v0.4s, v1.4s, v2.8s
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddw2 v0.2d, v1.2d, v2.4d
// CHECK-ERROR:                             ^

        ssubw v0.8h, v1.8h, v2.8h
        ssubw v0.4s, v1.4s, v2.4s
        ssubw v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubw v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubw v0.4s, v1.4s, v2.4s
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubw v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                               ^

        ssubw2 v0.8h, v1.8h, v2.16h
        ssubw2 v0.4s, v1.4s, v2.8s
        ssubw2 v0.2d, v1.2d, v2.4d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubw2 v0.8h, v1.8h, v2.16h
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubw2 v0.4s, v1.4s, v2.8s
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ssubw2 v0.2d, v1.2d, v2.4d
// CHECK-ERROR:                             ^

        usubw v0.8h, v1.8h, v2.8h
        usubw v0.4s, v1.4s, v2.4s
        usubw v0.2d, v1.2d, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubw v0.8h, v1.8h, v2.8h
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubw v0.4s, v1.4s, v2.4s
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubw v0.2d, v1.2d, v2.2d
// CHECK-ERROR:                               ^

        usubw2 v0.8h, v1.8h, v2.16h
        usubw2 v0.4s, v1.4s, v2.8s
        usubw2 v0.2d, v1.2d, v2.4d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubw2 v0.8h, v1.8h, v2.16h
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubw2 v0.4s, v1.4s, v2.8s
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usubw2 v0.2d, v1.2d, v2.4d
// CHECK-ERROR:                             ^

//------------------------------------------------------------------------------
// Narrow
//------------------------------------------------------------------------------

        addhn v0.8b, v1.8h, v2.8d
        addhn v0.4h, v1.4s, v2.4h
        addhn v0.2s, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addhn v0.8b, v1.8h, v2.8d
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addhn v0.4h, v1.4s, v2.4h
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addhn v0.2s, v1.2d, v2.2s
// CHECK-ERROR:                               ^

        addhn2 v0.16b, v1.8h, v2.8b
        addhn2 v0.8h, v1.4s, v2.4h
        addhn2 v0.4s, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addhn2 v0.16b, v1.8h, v2.8b
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addhn2 v0.8h, v1.4s, v2.4h
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addhn2 v0.4s, v1.2d, v2.2s
// CHECK-ERROR:                                ^

        raddhn v0.8b, v1.8h, v2.8b
        raddhn v0.4h, v1.4s, v2.4h
        raddhn v0.2s, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        raddhn v0.8b, v1.8h, v2.8b
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        raddhn v0.4h, v1.4s, v2.4h
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        raddhn v0.2s, v1.2d, v2.2s
// CHECK-ERROR:                                ^

        raddhn2 v0.16b, v1.8h, v2.8b
        raddhn2 v0.8h, v1.4s, v2.4h
        raddhn2 v0.4s, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        raddhn2 v0.16b, v1.8h, v2.8b
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        raddhn2 v0.8h, v1.4s, v2.4h
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        raddhn2 v0.4s, v1.2d, v2.2s
// CHECK-ERROR:                                 ^

        rsubhn v0.8b, v1.8h, v2.8b
        rsubhn v0.4h, v1.4s, v2.4h
        rsubhn v0.2s, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        rsubhn v0.8b, v1.8h, v2.8b
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        rsubhn v0.4h, v1.4s, v2.4h
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        rsubhn v0.2s, v1.2d, v2.2s
// CHECK-ERROR:                                ^

        rsubhn2 v0.16b, v1.8h, v2.8b
        rsubhn2 v0.8h, v1.4s, v2.4h
        rsubhn2 v0.4s, v1.2d, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        rsubhn2 v0.16b, v1.8h, v2.8b
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        rsubhn2 v0.8h, v1.4s, v2.4h
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        rsubhn2 v0.4s, v1.2d, v2.2s
// CHECK-ERROR:                                 ^

//----------------------------------------------------------------------
// Scalar Reduce Add Pairwise (Integer)
//----------------------------------------------------------------------
         // invalid vector types
      addp s0, d1.2d
      addp d0, d1.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          addp s0, d1.2d
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          addp d0, d1.2s
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Scalar Reduce Add Pairwise (Floating Point)
//----------------------------------------------------------------------
         // invalid vector types
      faddp s0, d1.2d
      faddp d0, d1.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          faddp s0, d1.2d
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          faddp d0, d1.2s
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Reduce Maximum Pairwise (Floating Point)
//----------------------------------------------------------------------
         // mismatched and invalid vector types
      fmaxp s0, v1.2d
      fmaxp d31, v2.2s
      fmaxp h3, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmaxp s0, v1.2d
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmaxp d31, v2.2s
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmaxp h3, v2.2s
// CHECK-ERROR:                ^


//----------------------------------------------------------------------
// Scalar Reduce Minimum Pairwise (Floating Point)
//----------------------------------------------------------------------
         // mismatched and invalid vector types
      fminp s0, v1.4h
      fminp d31, v2.8h
      fminp b3, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fminp s0, v1.4h
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fminp d31, v2.8h
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fminp b3, v2.2s
// CHECK-ERROR:                ^


//----------------------------------------------------------------------
// Scalar Reduce maxNum Pairwise (Floating Point)
//----------------------------------------------------------------------
         // mismatched and invalid vector types
      fmaxnmp s0, v1.8b
      fmaxnmp d31, v2.16b
      fmaxnmp v1.2s, v2.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmaxnmp s0, v1.8b
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmaxnmp d31, v2.16b
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: too few operands for instruction
// CHECK-ERROR:          fmaxnmp v1.2s, v2.2s
// CHECK-ERROR:          ^

//----------------------------------------------------------------------
// Scalar Reduce minNum Pairwise (Floating Point)
//----------------------------------------------------------------------
         // mismatched and invalid vector types
      fminnmp s0, v1.2d
      fminnmp d31, v2.4s
      fminnmp v1.4s, v2.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fminnmp s0, v1.2d
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fminnmp d31, v2.4s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fminnmp v1.4s, v2.2d
// CHECK-ERROR:          ^

      mla v0.2d, v1.2d, v16.d[1]
      mla v0.2s, v1.2s, v2.s[4]
      mla v0.4s, v1.4s, v2.s[4]
      mla v0.2h, v1.2h, v2.h[1]
      mla v0.4h, v1.4h, v2.h[8]
      mla v0.8h, v1.8h, v2.h[8]
      mla v0.4h, v1.4h, v16.h[2]
      mla v0.8h, v1.8h, v16.h[2]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mla v0.2d, v1.2d, v16.d[1]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mla v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mla v0.4s, v1.4s, v2.s[4]
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mla v0.2h, v1.2h, v2.h[1]
// CHECK-ERROR:            ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mla v0.4h, v1.4h, v2.h[8]
// CHECK-ERROR:                               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mla v0.8h, v1.8h, v2.h[8]
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mla v0.4h, v1.4h, v16.h[2]
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mla v0.8h, v1.8h, v16.h[2]
// CHECK-ERROR:                              ^

      mls v0.2d, v1.2d, v16.d[1]
      mls v0.2s, v1.2s, v2.s[4]
      mls v0.4s, v1.4s, v2.s[4]
      mls v0.2h, v1.2h, v2.h[1]
      mls v0.4h, v1.4h, v2.h[8]
      mls v0.8h, v1.8h, v2.h[8]
      mls v0.4h, v1.4h, v16.h[2]
      mls v0.8h, v1.8h, v16.h[2]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mls v0.2d, v1.2d, v16.d[1]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mls v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mls v0.4s, v1.4s, v2.s[4]
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mls v0.2h, v1.2h, v2.h[1]
// CHECK-ERROR:            ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mls v0.4h, v1.4h, v2.h[8]
// CHECK-ERROR:                               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mls v0.8h, v1.8h, v2.h[8]
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mls v0.4h, v1.4h, v16.h[2]
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mls v0.8h, v1.8h, v16.h[2]
// CHECK-ERROR:                              ^

      fmla v0.4h, v1.4h, v2.h[2]
      fmla v0.8h, v1.8h, v2.h[2]
      fmla v0.2s, v1.2s, v2.s[4]
      fmla v0.2s, v1.2s, v22.s[4]
      fmla v3.4s, v8.4s, v2.s[4]
      fmla v3.4s, v8.4s, v22.s[4]
      fmla v0.2d, v1.2d, v2.d[2]
      fmla v0.2d, v1.2d, v22.d[2]

// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmla v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmla v0.8h, v1.8h, v2.h[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmla v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmla v0.2s, v1.2s, v22.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmla v3.4s, v8.4s, v2.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmla v3.4s, v8.4s, v22.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmla v0.2d, v1.2d, v2.d[2]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmla v0.2d, v1.2d, v22.d[2]
// CHECK-ERROR:                                 ^

      fmls v0.4h, v1.4h, v2.h[2]
      fmls v0.8h, v1.8h, v2.h[2]
      fmls v0.2s, v1.2s, v2.s[4]
      fmls v0.2s, v1.2s, v22.s[4]
      fmls v3.4s, v8.4s, v2.s[4]
      fmls v3.4s, v8.4s, v22.s[4]
      fmls v0.2d, v1.2d, v2.d[2]
      fmls v0.2d, v1.2d, v22.d[2]

// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmls v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmls v0.8h, v1.8h, v2.h[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmls v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmls v0.2s, v1.2s, v22.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmls v3.4s, v8.4s, v2.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmls v3.4s, v8.4s, v22.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmls v0.2d, v1.2d, v2.d[2]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmls v0.2d, v1.2d, v22.d[2]
// CHECK-ERROR:                                 ^

      smlal v0.4h, v1.4h, v2.h[2]
      smlal v0.4s, v1.4h, v2.h[8]
      smlal v0.4s, v1.4h, v16.h[2]
      smlal v0.2s, v1.2s, v2.s[1]
      smlal v0.2d, v1.2s, v2.s[4]
      smlal v0.2d, v1.2s, v22.s[4]
      smlal2 v0.4h, v1.8h, v1.h[2]
      smlal2 v0.4s, v1.8h, v1.h[8]
      smlal2 v0.4s, v1.8h, v16.h[2]
      smlal2 v0.2s, v1.4s, v1.s[2]
      smlal2 v0.2d, v1.4s, v1.s[4]
      smlal2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlal v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal v0.4s, v1.4h, v16.h[2]
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal v0.2s, v1.2s, v2.s[1]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlal v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlal v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal2 v0.4h, v1.8h, v1.h[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlal2 v0.4s, v1.8h, v1.h[8]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal2 v0.4s, v1.8h, v16.h[2]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlal2 v0.2s, v1.4s, v1.s[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlal2 v0.2d, v1.4s, v1.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlal2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                   ^

      smlsl v0.4h, v1.4h, v2.h[2]
      smlsl v0.4s, v1.4h, v2.h[8]
      smlsl v0.4s, v1.4h, v16.h[2]
      smlsl v0.2s, v1.2s, v2.s[1]
      smlsl v0.2d, v1.2s, v2.s[4]
      smlsl v0.2d, v1.2s, v22.s[4]
      smlsl2 v0.4h, v1.8h, v1.h[2]
      smlsl2 v0.4s, v1.8h, v1.h[8]
      smlsl2 v0.4s, v1.8h, v16.h[2]
      smlsl2 v0.2s, v1.4s, v1.s[2]
      smlsl2 v0.2d, v1.4s, v1.s[4]
      smlsl2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlsl v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl v0.4s, v1.4h, v16.h[2]
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl v0.2s, v1.2s, v2.s[1]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlsl v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlsl v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl2 v0.4h, v1.8h, v1.h[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v1.h[8]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl2 v0.4s, v1.8h, v16.h[2]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smlsl2 v0.2s, v1.4s, v1.s[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v1.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smlsl2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                   ^

      umlal v0.4h, v1.4h, v2.h[2]
      umlal v0.4s, v1.4h, v2.h[8]
      umlal v0.4s, v1.4h, v16.h[2]
      umlal v0.2s, v1.2s, v2.s[1]
      umlal v0.2d, v1.2s, v2.s[4]
      umlal v0.2d, v1.2s, v22.s[4]
      umlal2 v0.4h, v1.8h, v1.h[2]
      umlal2 v0.4s, v1.8h, v1.h[8]
      umlal2 v0.4s, v1.8h, v16.h[2]
      umlal2 v0.2s, v1.4s, v1.s[2]
      umlal2 v0.2d, v1.4s, v1.s[4]
      umlal2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlal v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal v0.4s, v1.4h, v16.h[2]
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal v0.2s, v1.2s, v2.s[1]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlal v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlal v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal2 v0.4h, v1.8h, v1.h[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlal2 v0.4s, v1.8h, v1.h[8]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal2 v0.4s, v1.8h, v16.h[2]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlal2 v0.2s, v1.4s, v1.s[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlal2 v0.2d, v1.4s, v1.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlal2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                   ^

      umlsl v0.4h, v1.4h, v2.h[2]
      umlsl v0.4s, v1.4h, v2.h[8]
      umlsl v0.4s, v1.4h, v16.h[2]
      umlsl v0.2s, v1.2s, v2.s[3]
      umlsl v0.2d, v1.2s, v2.s[4]
      umlsl v0.2d, v1.2s, v22.s[4]
      umlsl2 v0.4h, v1.8h, v1.h[2]
      umlsl2 v0.4s, v1.8h, v1.h[8]
      umlsl2 v0.4s, v1.8h, v16.h[2]
      umlsl2 v0.2s, v1.4s, v1.s[2]
      umlsl2 v0.2d, v1.4s, v1.s[4]
      umlsl2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlsl v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl v0.4s, v1.4h, v16.h[2]
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl v0.2s, v1.2s, v2.s[3]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlsl v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlsl v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl2 v0.4h, v1.8h, v1.h[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v1.h[8]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl2 v0.4s, v1.8h, v16.h[2]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umlsl2 v0.2s, v1.4s, v1.s[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v1.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umlsl2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                   ^

      sqdmlal v0.4h, v1.4h, v2.h[2]
      sqdmlal v0.4s, v1.4h, v2.h[8]
      sqdmlal v0.4s, v1.4h, v16.h[2]
      sqdmlal v0.2s, v1.2s, v2.s[3]
      sqdmlal v0.2d, v1.2s, v2.s[4]
      sqdmlal v0.2d, v1.2s, v22.s[4]
      sqdmlal2 v0.4h, v1.8h, v1.h[2]
      sqdmlal2 v0.4s, v1.8h, v1.h[8]
      sqdmlal2 v0.4s, v1.8h, v16.h[2]
      sqdmlal2 v0.2s, v1.4s, v1.s[2]
      sqdmlal2 v0.2d, v1.4s, v1.s[4]
      sqdmlal2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal v0.4s, v1.4h, v16.h[2]
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal v0.2s, v1.2s, v2.s[3]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlal v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal2 v0.4h, v1.8h, v1.h[2]
// CHECK-ERROR:                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v1.h[8]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal2 v0.4s, v1.8h, v16.h[2]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal2 v0.2s, v1.4s, v1.s[2]
// CHECK-ERROR:                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v1.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlal2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                     ^

      sqdmlsl v0.4h, v1.4h, v2.h[2]
      sqdmlsl v0.4s, v1.4h, v2.h[8]
      sqdmlsl v0.4s, v1.4h, v16.h[2]
      sqdmlsl v0.2s, v1.2s, v2.s[3]
      sqdmlsl v0.2d, v1.2s, v2.s[4]
      sqdmlsl v0.2d, v1.2s, v22.s[4]
      sqdmlsl2 v0.4h, v1.8h, v1.h[2]
      sqdmlsl2 v0.4s, v1.8h, v1.h[8]
      sqdmlsl2 v0.4s, v1.8h, v16.h[2]
      sqdmlsl2 v0.2s, v1.4s, v1.s[2]
      sqdmlsl2 v0.2d, v1.4s, v1.s[4]
      sqdmlsl2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl v0.4s, v1.4h, v16.h[2]
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl v0.2s, v1.2s, v2.s[3]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlsl v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl2 v0.4h, v1.8h, v1.h[2]
// CHECK-ERROR:                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v1.h[8]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl2 v0.4s, v1.8h, v16.h[2]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl2 v0.2s, v1.4s, v1.s[2]
// CHECK-ERROR:                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v1.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmlsl2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                     ^

      mul v0.4h, v1.4h, v2.h[8]
      mul v0.4h, v1.4h, v16.h[8]
      mul v0.8h, v1.8h, v2.h[8]
      mul v0.8h, v1.8h, v16.h[8]
      mul v0.2s, v1.2s, v2.s[4]
      mul v0.2s, v1.2s, v22.s[4]
      mul v0.4s, v1.4s, v2.s[4]
      mul v0.4s, v1.4s, v22.s[4]
      mul v0.2d, v1.2d, v2.d[1]

// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mul v0.4h, v1.4h, v2.h[8]
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mul v0.4h, v1.4h, v16.h[8]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mul v0.8h, v1.8h, v2.h[8]
// CHECK-ERROR:                               ^
// CHECK-ERROR: invalid operand for instruction
// CHECK-ERROR:        mul v0.8h, v1.8h, v16.h[8]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mul v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mul v0.2s, v1.2s, v22.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mul v0.4s, v1.4s, v2.s[4]
// CHECK-ERROR:                               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        mul v0.4s, v1.4s, v22.s[4]
// CHECK-ERROR:                                ^

      fmul v0.4h, v1.4h, v2.h[4]
      fmul v0.2s, v1.2s, v2.s[4]
      fmul v0.2s, v1.2s, v22.s[4]
      fmul v0.4s, v1.4s, v2.s[4]
      fmul v0.4s, v1.4s, v22.s[4]
      fmul v0.2d, v1.2d, v2.d[2]
      fmul v0.2d, v1.2d, v22.d[2]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        mul v0.2d, v1.2d, v2.d[1]
// CHECK-ERROR:               ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmul v0.4h, v1.4h, v2.h[4]
// CHECK-ERROR:                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmul v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmul v0.2s, v1.2s, v22.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmul v0.4s, v1.4s, v2.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmul v0.4s, v1.4s, v22.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmul v0.2d, v1.2d, v2.d[2]
// CHECK-ERROR:                                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmul v0.2d, v1.2d, v22.d[2]
// CHECK-ERROR:                                 ^

      fmulx v0.4h, v1.4h, v2.h[4]
      fmulx v0.2s, v1.2s, v2.s[4]
      fmulx v0.2s, v1.2s, v22.s[4]
      fmulx v0.4s, v1.4s, v2.s[4]
      fmulx v0.4s, v1.4s, v22.s[4]
      fmulx v0.2d, v1.2d, v2.d[2]
      fmulx v0.2d, v1.2d, v22.d[2]

// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmulx v0.4h, v1.4h, v2.h[4]
// CHECK-ERROR:                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmulx v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmulx v0.2s, v1.2s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmulx v0.4s, v1.4s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmulx v0.4s, v1.4s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmulx v0.2d, v1.2d, v2.d[2]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        fmulx v0.2d, v1.2d, v22.d[2]
// CHECK-ERROR:                                  ^

      smull v0.4h, v1.4h, v2.h[2]
      smull v0.4s, v1.4h, v2.h[8]
      smull v0.4s, v1.4h, v16.h[4]
      smull v0.2s, v1.2s, v2.s[2]
      smull v0.2d, v1.2s, v2.s[4]
      smull v0.2d, v1.2s, v22.s[4]
      smull2 v0.4h, v1.8h, v2.h[2]
      smull2 v0.4s, v1.8h, v2.h[8]
      smull2 v0.4s, v1.8h, v16.h[4]
      smull2 v0.2s, v1.4s, v2.s[2]
      smull2 v0.2d, v1.4s, v2.s[4]
      smull2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smull v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull v0.4s, v1.4h, v16.h[4]
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull v0.2s, v1.2s, v2.s[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smull v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smull v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull2 v0.4h, v1.8h, v2.h[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smull2 v0.4s, v1.8h, v2.h[8]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull2 v0.4s, v1.8h, v16.h[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smull2 v0.2s, v1.4s, v2.s[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smull2 v0.2d, v1.4s, v2.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        smull2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                   ^

      umull v0.4h, v1.4h, v2.h[2]
      umull v0.4s, v1.4h, v2.h[8]
      umull v0.4s, v1.4h, v16.h[4]
      umull v0.2s, v1.2s, v2.s[2]
      umull v0.2d, v1.2s, v2.s[4]
      umull v0.2d, v1.2s, v22.s[4]
      umull2 v0.4h, v1.8h, v2.h[2]
      umull2 v0.4s, v1.8h, v2.h[8]
      umull2 v0.4s, v1.8h, v16.h[4]
      umull2 v0.2s, v1.4s, v2.s[2]
      umull2 v0.2d, v1.4s, v2.s[4]
      umull2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umull v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull v0.4s, v1.4h, v16.h[4]
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull v0.2s, v1.2s, v2.s[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umull v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umull v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull2 v0.4h, v1.8h, v2.h[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umull2 v0.4s, v1.8h, v2.h[8]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull2 v0.4s, v1.8h, v16.h[4]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umull2 v0.2s, v1.4s, v2.s[2]
// CHECK-ERROR:               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umull2 v0.2d, v1.4s, v2.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        umull2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                   ^

      sqdmull v0.4h, v1.4h, v2.h[2]
      sqdmull v0.4s, v1.4h, v2.h[8]
      sqdmull v0.4s, v1.4h, v16.h[4]
      sqdmull v0.2s, v1.2s, v2.s[2]
      sqdmull v0.2d, v1.2s, v2.s[4]
      sqdmull v0.2d, v1.2s, v22.s[4]
      sqdmull2 v0.4h, v1.8h, v2.h[2]
      sqdmull2 v0.4s, v1.8h, v2.h[8]
      sqdmull2 v0.4s, v1.8h, v16.h[4]
      sqdmull2 v0.2s, v1.4s, v2.s[2]
      sqdmull2 v0.2d, v1.4s, v2.s[4]
      sqdmull2 v0.2d, v1.4s, v22.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull v0.4h, v1.4h, v2.h[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmull v0.4s, v1.4h, v2.h[8]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull v0.4s, v1.4h, v16.h[4]
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull v0.2s, v1.2s, v2.s[2]
// CHECK-ERROR:                ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmull v0.2d, v1.2s, v2.s[4]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmull v0.2d, v1.2s, v22.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull2 v0.4h, v1.8h, v2.h[2]
// CHECK-ERROR:                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v2.h[8]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull2 v0.4s, v1.8h, v16.h[4]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull2 v0.2s, v1.4s, v2.s[2]
// CHECK-ERROR:                 ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v2.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmull2 v0.2d, v1.4s, v22.s[4]
// CHECK-ERROR:                                     ^

      sqdmulh v0.4h, v1.4h, v2.h[8]
      sqdmulh v0.4h, v1.4h, v16.h[2]
      sqdmulh v0.8h, v1.8h, v2.h[8]
      sqdmulh v0.8h, v1.8h, v16.h[2]
      sqdmulh v0.2s, v1.2s, v2.s[4]
      sqdmulh v0.2s, v1.2s, v22.s[4]
      sqdmulh v0.4s, v1.4s, v2.s[4]
      sqdmulh v0.4s, v1.4s, v22.s[4]
      sqdmulh v0.2d, v1.2d, v22.d[1]

// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v2.h[8]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmulh v0.4h, v1.4h, v16.h[2]
// CHECK-ERROR:                              ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v2.h[8]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmulh v0.8h, v1.8h, v16.h[2]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmulh v0.2s, v1.2s, v22.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v2.s[4]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqdmulh v0.4s, v1.4s, v22.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmulh v0.2d, v1.2d, v22.d[1]
// CHECK-ERROR:                   ^

      sqrdmulh v0.4h, v1.4h, v2.h[8]
      sqrdmulh v0.4h, v1.4h, v16.h[2]
      sqrdmulh v0.8h, v1.8h, v2.h[8]
      sqrdmulh v0.8h, v1.8h, v16.h[2]
      sqrdmulh v0.2s, v1.2s, v2.s[4]
      sqrdmulh v0.2s, v1.2s, v22.s[4]
      sqrdmulh v0.4s, v1.4s, v2.s[4]
      sqrdmulh v0.4s, v1.4s, v22.s[4]
      sqrdmulh v0.2d, v1.2d, v22.d[1]

// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v2.h[8]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrdmulh v0.4h, v1.4h, v16.h[2]
// CHECK-ERROR:                               ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v2.h[8]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrdmulh v0.8h, v1.8h, v16.h[2]
// CHECK-ERROR:                                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v2.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqrdmulh v0.2s, v1.2s, v22.s[4]
// CHECK-ERROR:                                     ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v2.s[4]
// CHECK-ERROR:                                    ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:        sqrdmulh v0.4s, v1.4s, v22.s[4]
// CHECK-ERROR:                                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqrdmulh v0.2d, v1.2d, v22.d[1]
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Across vectors
//----------------------------------------------------------------------

        saddlv b0, v1.8b
        saddlv b0, v1.16b
        saddlv h0, v1.4h
        saddlv h0, v1.8h
        saddlv s0, v1.2s
        saddlv s0, v1.4s
        saddlv d0, v1.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddlv b0, v1.8b
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddlv b0, v1.16b
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddlv h0, v1.4h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddlv h0, v1.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddlv s0, v1.2s
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddlv s0, v1.4s
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        saddlv d0, v1.2s
// CHECK-ERROR:                   ^

        uaddlv b0, v1.8b
        uaddlv b0, v1.16b
        uaddlv h0, v1.4h
        uaddlv h0, v1.8h
        uaddlv s0, v1.2s
        uaddlv s0, v1.4s
        uaddlv d0, v1.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddlv b0, v1.8b
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddlv b0, v1.16b
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddlv h0, v1.4h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddlv h0, v1.8h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddlv s0, v1.2s
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddlv s0, v1.4s
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uaddlv d0, v1.2s
// CHECK-ERROR:                   ^

        smaxv s0, v1.2s
        sminv s0, v1.2s
        umaxv s0, v1.2s
        uminv s0, v1.2s
        addv s0, v1.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smaxv s0, v1.2s
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sminv s0, v1.2s
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umaxv s0, v1.2s
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uminv s0, v1.2s
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addv s0, v1.2s
// CHECK-ERROR:                 ^

        smaxv d0, v1.2d
        sminv d0, v1.2d
        umaxv d0, v1.2d
        uminv d0, v1.2d
        addv d0, v1.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        smaxv d0, v1.2d
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sminv d0, v1.2d
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        umaxv d0, v1.2d
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uminv d0, v1.2d
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        addv d0, v1.2d
// CHECK-ERROR:             ^

        fmaxnmv b0, v1.16b
        fminnmv b0, v1.16b
        fmaxv b0, v1.16b
        fminv b0, v1.16b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxnmv b0, v1.16b
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminnmv b0, v1.16b
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxv b0, v1.16b
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminv b0, v1.16b
// CHECK-ERROR:              ^

        fmaxnmv h0, v1.8h
        fminnmv h0, v1.8h
        fmaxv h0, v1.8h
        fminv h0, v1.8h

// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmaxnmv h0, v1.8h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fminnmv h0, v1.8h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fmaxv h0, v1.8h
// CHECK-ERROR:              ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:        fminv h0, v1.8h
// CHECK-ERROR:              ^

        fmaxnmv d0, v1.2d
        fminnmv d0, v1.2d
        fmaxv d0, v1.2d
        fminv d0, v1.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxnmv d0, v1.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminnmv d0, v1.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fmaxv d0, v1.2d
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fminv d0, v1.2d
// CHECK-ERROR:              ^

//----------------------------------------------------------------------
// Floating-point Multiply Extended
//----------------------------------------------------------------------

    fmulx s20, h22, s15
    fmulx d23, d11, s1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmulx s20, h22, s15
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmulx d23, d11, s1
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Floating-point Reciprocal Step
//----------------------------------------------------------------------

    frecps s21, s16, h13
    frecps d22, s30, d21

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          frecps s21, s16, h13
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          frecps d22, s30, d21
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Floating-point Reciprocal Square Root Step
//----------------------------------------------------------------------

    frsqrts s21, h5, s12
    frsqrts d8, s22, d18

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          frsqrts s21, h5, s12
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          frsqrts d8, s22, d18
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Vector load/store multiple N-element structure (class SIMD lselem)
//----------------------------------------------------------------------
         ld1 {x3}, [x2]
         ld1 {v4}, [x0]
         ld1 {v32.16b}, [x0]
         ld1 {v15.8h}, [x32]
// CHECK-ERROR: error: vector register expected
// CHECK-ERROR:        ld1 {x3}, [x2]
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ld1 {v4}, [x0]
// CHECK-ERROR:             ^
// CHECK-ERROR: error: vector register expected
// CHECK-ERROR:        ld1 {v32.16b}, [x0]
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ld1 {v15.8h}, [x32]
// CHECK-ERROR:                       ^

         ld1 {v0.16b, v2.16b}, [x0]
         ld1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
         ld1 v0.8b, v1.8b}, [x0]
         ld1 {v0.8h-v4.8h}, [x0]
         ld1 {v1.8h-v1.8h}, [x0]
         ld1 {v15.8h-v17.4h}, [x15]
         ld1 {v0.8b-v2.8b, [x0]
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        ld1 {v0.16b, v2.16b}, [x0]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        ld1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
// CHECK-ERROR:                                         ^
// CHECK-ERROR: error: unexpected token in argument list
// CHECK-ERROR:        ld1 v0.8b, v1.8b}, [x0]
// CHECK-ERROR:            ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        ld1 {v0.8h-v4.8h}, [x0]
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        ld1 {v1.8h-v1.8h}, [x0]
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld1 {v15.8h-v17.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: '}' expected
// CHECK-ERROR:        ld1 {v0.8b-v2.8b, [x0]
// CHECK-ERROR:                        ^

         ld2 {v15.8h, v16.4h}, [x15]
         ld2 {v0.8b, v2.8b}, [x0]
         ld2 {v15.4h, v16.4h, v17.4h}, [x32]
         ld2 {v15.8h-v16.4h}, [x15]
         ld2 {v0.2d-v2.2d}, [x0]
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld2 {v15.8h, v16.4h}, [x15]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        ld2 {v0.8b, v2.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR:        ld2 {v15.4h, v16.4h, v17.4h}, [x32]
// CHECK-ERROR:            ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld2 {v15.8h-v16.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ld2 {v0.2d-v2.2d}, [x0]
// CHECK-ERROR:            ^

         ld3 {v15.8h, v16.8h, v17.4h}, [x15]
         ld3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
         ld3 {v0.8b, v2.8b, v3.8b}, [x0]
         ld3 {v15.8h-v17.4h}, [x15]
         ld3 {v31.4s-v2.4s}, [sp]
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld3 {v15.8h, v16.8h, v17.4h}, [x15]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        ld3 {v0.8b, v2.8b, v3.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld3 {v15.8h-v17.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ld3 {v31.4s-v2.4s}, [sp]
// CHECK-ERROR:            ^

         ld4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
         ld4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
         ld4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
         ld4 {v15.8h-v18.4h}, [x15]
         ld4 {v31.2s-v1.2s}, [x31]
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        ld4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        ld4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
// CHECK-ERROR:                                             ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        ld4 {v15.8h-v18.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ld4 {v31.2s-v1.2s}, [x31]
// CHECK-ERROR:            ^

         st1 {x3}, [x2]
         st1 {v4}, [x0]
         st1 {v32.16b}, [x0]
         st1 {v15.8h}, [x32]
// CHECK-ERROR: error: vector register expected
// CHECK-ERROR:        st1 {x3}, [x2]
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        st1 {v4}, [x0]
// CHECK-ERROR:             ^
// CHECK-ERROR: error: vector register expected
// CHECK-ERROR:        st1 {v32.16b}, [x0]
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        st1 {v15.8h}, [x32]
// CHECK-ERROR:                       ^

         st1 {v0.16b, v2.16b}, [x0]
         st1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
         st1 v0.8b, v1.8b}, [x0]
         st1 {v0.8h-v4.8h}, [x0]
         st1 {v1.8h-v1.8h}, [x0]
         st1 {v15.8h-v17.4h}, [x15]
         st1 {v0.8b-v2.8b, [x0]
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        st1 {v0.16b, v2.16b}, [x0]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        st1 {v0.8h, v1.8h, v2.8h, v3.8h, v4.8h}, [x0]
// CHECK-ERROR:                                         ^
// CHECK-ERROR: error: unexpected token in argument list
// CHECK-ERROR:        st1 v0.8b, v1.8b}, [x0]
// CHECK-ERROR:            ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        st1 {v0.8h-v4.8h}, [x0]
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        st1 {v1.8h-v1.8h}, [x0]
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st1 {v15.8h-v17.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: '}' expected
// CHECK-ERROR:        st1 {v0.8b-v2.8b, [x0]
// CHECK-ERROR:                        ^

         st2 {v15.8h, v16.4h}, [x15]
         st2 {v0.8b, v2.8b}, [x0]
         st2 {v15.4h, v16.4h, v17.4h}, [x30]
         st2 {v15.8h-v16.4h}, [x15]
         st2 {v0.2d-v2.2d}, [x0]
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st2 {v15.8h, v16.4h}, [x15]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        st2 {v0.8b, v2.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        st2 {v15.4h, v16.4h, v17.4h}, [x30]
// CHECK-ERROR:            ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st2 {v15.8h-v16.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        st2 {v0.2d-v2.2d}, [x0]
// CHECK-ERROR:            ^

         st3 {v15.8h, v16.8h, v17.4h}, [x15]
         st3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
         st3 {v0.8b, v2.8b, v3.8b}, [x0]
         st3 {v15.8h-v17.4h}, [x15]
         st3 {v31.4s-v2.4s}, [sp]
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st3 {v15.8h, v16.8h, v17.4h}, [x15]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st3 {v0.8b, v1,8b, v2.8b, v3.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        st3 {v0.8b, v2.8b, v3.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st3 {v15.8h-v17.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        st3 {v31.4s-v2.4s}, [sp]
// CHECK-ERROR:            ^

         st4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
         st4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
         st4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
         st4 {v15.8h-v18.4h}, [x15]
         st4 {v31.2s-v1.2s}, [x31]
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st4 {v15.8h, v16.8h, v17.4h, v18.8h}, [x15]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: registers must be sequential
// CHECK-ERROR:        st4 {v0.8b, v2.8b, v3.8b, v4.8b}, [x0]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        st4 {v15.4h, v16.4h, v17.4h, v18.4h, v19.4h}, [x31]
// CHECK-ERROR:                                             ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:        st4 {v15.8h-v18.4h}, [x15]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        st4 {v31.2s-v1.2s}, [x31]
// CHECK-ERROR:            ^

//----------------------------------------------------------------------
// Vector post-index load/store multiple N-element structure
// (class SIMD lselem-post)
//----------------------------------------------------------------------
         ld1 {v0.16b}, [x0], #8
         ld1 {v0.8h, v1.16h}, [x0], x1
         ld1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          ld1 {v0.16b}, [x0], #8
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid vector kind qualifier
// CHECK-ERROR:          ld1 {v0.8h, v1.16h}, [x0], x1
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:          ld1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
// CHECK-ERROR:                                                  ^

         ld2 {v0.16b, v1.16b}, [x0], #16
         ld3 {v5.2s, v6.2s, v7.2s}, [x1], #48
         ld4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:          ld2 {v0.16b, v1.16b}, [x0], #16
// CHECK-ERROR:                                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:          ld3 {v5.2s, v6.2s, v7.2s}, [x1], #48
// CHECK-ERROR:                                           ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:          ld4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
// CHECK-ERROR:                                     ^

         st1 {v0.16b}, [x0], #8
         st1 {v0.8h, v1.16h}, [x0], x1
         st1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:          st1 {v0.16b}, [x0], #8
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid vector kind qualifier
// CHECK-ERROR:          st1 {v0.8h, v1.16h}, [x0], x1
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:          st1 {v0.8b, v1.8b, v2.8b, v3.8b}, [x0], #24
                                                 ^

         st2 {v0.16b, v1.16b}, [x0], #16
         st3 {v5.2s, v6.2s, v7.2s}, [x1], #48
         st4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:          st2 {v0.16b, v1.16b}, [x0], #16
// CHECK-ERROR:                                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:          st3 {v5.2s, v6.2s, v7.2s}, [x1], #48
// CHECK-ERROR:                                           ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR:          st4 {v31.2d, v0.2d, v1.2d, v2.1d}, [x3], x1
// CHECK-ERROR:                                     ^

//------------------------------------------------------------------------------
// Load single N-element structure to all lanes of N consecutive
// registers (N = 1,2,3,4)
//------------------------------------------------------------------------------
         ld1r {x1}, [x0]
         ld2r {v31.4s, v0.2s}, [sp]
         ld3r {v0.8b, v1.8b, v2.8b, v3.8b}, [x0]
         ld4r {v31.2s, v0.2s, v1.2d, v2.2s}, [sp]
// CHECK-ERROR: error: vector register expected
// CHECK-ERROR: ld1r {x1}, [x0]
// CHECK-ERROR:       ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR: ld2r {v31.4s, v0.2s}, [sp]
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld3r {v0.8b, v1.8b, v2.8b, v3.8b}, [x0]
// CHECK-ERROR:      ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR: ld4r {v31.2s, v0.2s, v1.2d, v2.2s}, [sp]
// CHECK-ERROR:                      ^

//------------------------------------------------------------------------------
// Load/Store single N-element structure to/from one lane of N consecutive
// registers (N = 1, 2,3,4)
//------------------------------------------------------------------------------
         ld1 {v0.b}[16], [x0]
         ld2 {v15.h, v16.h}[8], [x15]
         ld3 {v31.s, v0.s, v1.s}[-1], [sp]
         ld4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR: ld1 {v0.b}[16], [x0]
// CHECK-ERROR:            ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR: ld2 {v15.h, v16.h}[8], [x15]
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: vector lane must be an integer in range
// CHECK-ERROR: ld3 {v31.s, v0.s, v1.s}[-1], [sp]
// CHECK-ERROR:                         ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR: ld4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
// CHECK-ERROR:                              ^

         st1 {v0.d}[16], [x0]
         st2 {v31.s, v0.s}[3], [8]
         st3 {v15.h, v16.h, v17.h}[-1], [x15]
         st4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR: st1 {v0.d}[16], [x0]
// CHECK-ERROR:            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: st2 {v31.s, v0.s}[3], [8]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: vector lane must be an integer in range
// CHECK-ERROR: st3 {v15.h, v16.h, v17.h}[-1], [x15]
// CHECK-ERROR:                           ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR: st4 {v0.d, v1.d, v2.d, v3.d}[2], [x0]
// CHECK-ERROR:                              ^

//------------------------------------------------------------------------------
// Post-index of load single N-element structure to all lanes of N consecutive
// registers (N = 1,2,3,4)
//------------------------------------------------------------------------------
         ld1r {v15.8h}, [x15], #5
         ld2r {v0.2d, v1.2d}, [x0], #7
         ld3r {v15.4h, v16.4h, v17.4h}, [x15], #1
         ld4r {v31.1d, v0.1d, v1.1d, v2.1d}, [sp], sp
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld1r {v15.8h}, [x15], #5
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld2r {v0.2d, v1.2d}, [x0], #7
// CHECK-ERROR:                            ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld3r {v15.4h, v16.4h, v17.4h}, [x15], #1
// CHECK-ERROR:                                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld4r {v31.1d, v0.1d, v1.1d, v2.1d}, [sp], sp
// CHECK-ERROR:                                           ^

//------------------------------------------------------------------------------
// Post-index of Load/Store single N-element structure to/from one lane of N
// consecutive registers (N = 1, 2,3,4)
//------------------------------------------------------------------------------
         ld1 {v0.b}[0], [x0], #2
         ld2 {v15.h, v16.h}[0], [x15], #3
         ld3 {v31.s, v0.s, v1.d}[0], [sp], x9
         ld4 {v0.d, v1.d, v2.d, v3.d}[1], [x0], #24
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld1 {v0.b}[0], [x0], #2
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld2 {v15.h, v16.h}[0], [x15], #3
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: mismatched register size suffix
// CHECK-ERROR: ld3 {v31.s, v0.s, v1.d}[0], [sp], x9
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: ld4 {v0.d, v1.d, v2.d, v3.d}[1], [x0], #24
// CHECK-ERROR:                                        ^

         st1 {v0.d}[0], [x0], #7
         st2 {v31.s, v0.s}[0], [sp], #6
         st3 {v15.h, v16.h, v17.h}[0], [x15], #8
         st4 {v0.b, v1.b, v2.b, v3.b}[1], [x0], #1
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: st1 {v0.d}[0], [x0], #7
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: st2 {v31.s, v0.s}[0], [sp], #6
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: st3 {v15.h, v16.h, v17.h}[0], [x15], #8
// CHECK-ERROR:                                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR: st4 {v0.b, v1.b, v2.b, v3.b}[1], [x0], #1
// CHECK-ERROR:                                        ^


         ins v2.b[16], w1
         ins v7.h[8], w14
         ins v20.s[5], w30
         ins v1.d[2], x7
         ins v2.b[3], b1
         ins v7.h[2], h14
         ins v20.s[1], s30
         ins v1.d[0], d7

// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         ins v2.b[16], w1
// CHECK-ERROR:                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         ins v7.h[8], w14
// CHECK-ERROR:                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         ins v20.s[5], w30
// CHECK-ERROR:                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         ins v1.d[2], x7
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ins v2.b[3], b1
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ins v7.h[2], h14
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ins v20.s[1], s30
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ins v1.d[0], d7
// CHECK-ERROR:                      ^

         smov w1, v0.b[16]
         smov w14, v6.h[8]
         smov x1, v0.b[16]
         smov x14, v6.h[8]
         smov x20, v9.s[5]
         smov w1, v0.d[0]
         smov w14, v6.d[1]
         smov x1, v0.d[0]
         smov x14, v6.d[1]
         smov x20, v9.d[0]

// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         smov w1, v0.b[16]
// CHECK-ERROR:                       ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         smov w14, v6.h[8]
// CHECK-ERROR:                        ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         smov x1, v0.b[16]
// CHECK-ERROR:                       ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         smov x14, v6.h[8]
// CHECK-ERROR:                        ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         smov x20, v9.s[5]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         smov w1, v0.d[0]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         smov w14, v6.d[1]
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         smov x1, v0.d[0]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         smov x14, v6.d[1]
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         smov x20, v9.d[0]
// CHECK-ERROR:                      ^

         umov w1, v0.b[16]
         umov w14, v6.h[8]
         umov w20, v9.s[5]
         umov x7, v18.d[3]
         umov w1, v0.d[0]
         umov s20, v9.s[2]
         umov d7, v18.d[1]

// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         umov w1, v0.b[16]
// CHECK-ERROR:                       ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         umov w14, v6.h[8]
// CHECK-ERROR:                        ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         umov w20, v9.s[5]
// CHECK-ERROR:                        ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:         umov x7, v18.d[3]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         umov w1, v0.d[0]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         umov s20, v9.s[2]
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         umov d7, v18.d[1]
// CHECK-ERROR:              ^

         Ins v1.h[2], v3.b[6]
         Ins v6.h[7], v7.s[2]
         Ins v15.d[0], v22.s[2]
         Ins v0.d[0], v4.b[1]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         Ins v1.h[2], v3.b[6]
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         Ins v6.h[7], v7.s[2]
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         Ins v15.d[0], v22.s[2]
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         Ins v0.d[0], v4.b[1]
// CHECK-ERROR:                         ^

         dup v1.8h, v2.b[2]
         dup v11.4s, v7.h[7]
         dup v17.2d, v20.s[0]
         dup v1.16b, v2.h[2]
         dup v11.8h, v7.s[3]
         dup v17.4s, v20.d[0]
         dup v5.2d, v1.b[1]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v1.8h, v2.b[2]
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v11.4s, v7.h[7]
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v17.2d, v20.s[0]
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v1.16b, v2.h[2]
// CHECK-ERROR:                        ^
// CHECK-ERROR: invalid operand for instruction
// CHECK-ERROR:         dup v11.8h, v7.s[3]
// CHECK-ERROR:                        ^
// CHECK-ERROR: invalid operand for instruction
// CHECK-ERROR:         dup v17.4s, v20.d[0]
// CHECK-ERROR:                         ^
// CHECK-ERROR: invalid operand for instruction
// CHECK-ERROR:         dup v5.2d, v1.b[1]
// CHECK-ERROR:                       ^

         dup v1.8b, b1
         dup v11.4h, h14
         dup v17.2s, s30
         dup v1.16b, d2
         dup v11.8s, w16
         dup v17.4d, w28
         dup v5.2d, w0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v1.8b, b1
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v11.4h, h14
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v17.2s, s30
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v1.16b, d2
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v11.8s, w16
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v17.4d, w28
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         dup v5.2d, w0
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Compare Bitwise Equal
//----------------------------------------------------------------------

         cmeq b20, d21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmeq b20, d21, d22
// CHECK-ERROR:               ^

//----------------------------------------------------------------------
// Scalar Compare Bitwise Equal To Zero
//----------------------------------------------------------------------

         cmeq d20, b21, #0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmeq d20, b21, #0
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Compare Unsigned Higher Or Same
//----------------------------------------------------------------------

         cmhs b20, d21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmhs b20, d21, d22
// CHECK-ERROR:               ^


//----------------------------------------------------------------------
// Scalar Compare Signed Greather Than Or Equal
//----------------------------------------------------------------------

         cmge b20, d21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmge b20, d21, d22
// CHECK-ERROR:               ^

//----------------------------------------------------------------------
// Scalar Compare Signed Greather Than Or Equal To Zero
//----------------------------------------------------------------------

         cmge d20, b21, #0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmge d20, b21, #0
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Compare Unsigned Higher
//----------------------------------------------------------------------

         cmhi b20, d21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmhi b20, d21, d22
// CHECK-ERROR:               ^

//----------------------------------------------------------------------
// Scalar Compare Signed Greater Than
//----------------------------------------------------------------------

         cmgt b20, d21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmgt b20, d21, d22
// CHECK-ERROR:               ^

//----------------------------------------------------------------------
// Scalar Compare Signed Greater Than Zero
//----------------------------------------------------------------------

         cmgt d20, b21, #0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmgt d20, b21, #0
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Compare Signed Less Than Or Equal To Zero
//----------------------------------------------------------------------

         cmle d20, b21, #0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmle d20, b21, #0
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Compare Less Than Zero
//----------------------------------------------------------------------

         cmlt d20, b21, #0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmlt d20, b21, #0
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Compare Bitwise Test Bits
//----------------------------------------------------------------------

         cmtst b20, d21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          cmtst b20, d21, d22
// CHECK-ERROR:                ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Equal
//----------------------------------------------------------------------

         fcmeq s10, h11, s12
         fcmeq d20, s21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmeq s10, h11, s12
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmeq d20, s21, d22
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Equal To Zero
//----------------------------------------------------------------------

         fcmeq h10, s11, #0.0
         fcmeq d20, s21, #0.0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmeq h10, s11, #0.0
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmeq d20, s21, #0.0
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Greater Than Or Equal
//----------------------------------------------------------------------

         fcmge s10, h11, s12
         fcmge d20, s21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmge s10, h11, s12
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmge d20, s21, d22
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Greater Than Or Equal To Zero
//----------------------------------------------------------------------

         fcmge h10, s11, #0.0
         fcmge d20, s21, #0.0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmge h10, s11, #0.0
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmge d20, s21, #0.0
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Greather Than
//----------------------------------------------------------------------

         fcmgt s10, h11, s12
         fcmgt d20, s21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmgt s10, h11, s12
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmgt d20, s21, d22
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Greather Than Zero
//----------------------------------------------------------------------

         fcmgt h10, s11, #0.0
         fcmgt d20, s21, #0.0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmgt h10, s11, #0.0
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmgt d20, s21, #0.0
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Less Than Or Equal To Zero
//----------------------------------------------------------------------

         fcmle h10, s11, #0.0
         fcmle d20, s21, #0.0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmle h10, s11, #0.0
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmle d20, s21, #0.0
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Compare Mask Less Than
//----------------------------------------------------------------------

         fcmlt h10, s11, #0.0
         fcmlt d20, s21, #0.0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmlt h10, s11, #0.0
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fcmlt d20, s21, #0.0
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Absolute Compare Mask Greater Than Or Equal
//----------------------------------------------------------------------

         facge s10, h11, s12
         facge d20, s21, d22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          facge s10, h11, s12
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          facge d20, s21, d22
// CHECK-ERROR:                     ^

//----------------------------------------------------------------------
// Scalar Floating-point Absolute Compare Mask Greater Than
//----------------------------------------------------------------------

         facgt s10, h11, s12
         facgt d20, d21, s22

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          facgt s10, h11, s12
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          facgt d20, d21, s22
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Scalar Signed Saturating Accumulated of Unsigned Value
//----------------------------------------------------------------------

        suqadd b0, h1
        suqadd h0, s1
        suqadd s0, d1
        suqadd d0, b0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        suqadd b0, h1
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        suqadd h0, s1
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        suqadd s0, d1
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        suqadd d0, b0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Unsigned Saturating Accumulated of Signed Value
//----------------------------------------------------------------------

        usqadd b0, h1
        usqadd h0, s1
        usqadd s0, d1
        usqadd d0, b1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usqadd b0, h1
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usqadd h0, s1
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usqadd s0, d1
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        usqadd d0, b1
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Absolute Value
//----------------------------------------------------------------------

    abs d29, s24

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        abs d29, s24
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Scalar Negate
//----------------------------------------------------------------------

    neg d29, s24

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        neg d29, s24
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Signed Saturating Doubling Multiply-Add Long
//----------------------------------------------------------------------

    sqdmlal s17, h27, s12
    sqdmlal d19, s24, d12

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal s17, h27, s12
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlal d19, s24, d12
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Signed Saturating Doubling Multiply-Subtract Long
//----------------------------------------------------------------------

    sqdmlsl s14, h12, s25
    sqdmlsl d12, s23, d13

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl s14, h12, s25
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmlsl d12, s23, d13
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Signed Saturating Doubling Multiply Long
//----------------------------------------------------------------------

    sqdmull s12, h22, s12
    sqdmull d15, s22, d12

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull s12, h22, s12
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqdmull d15, s22, d12
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Scalar Signed Saturating Extract Unsigned Narrow
//----------------------------------------------------------------------

    sqxtun b19, b14
    sqxtun h21, h15
    sqxtun s20, s12

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqxtun b19, b14
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqxtun h21, h15
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqxtun s20, s12
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Signed Saturating Extract Signed Narrow
//----------------------------------------------------------------------

    sqxtn b18, b18
    sqxtn h20, h17
    sqxtn s19, s14

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqxtn b18, b18
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqxtn h20, h17
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sqxtn s19, s14
// CHECK-ERROR:                   ^


//----------------------------------------------------------------------
// Scalar Unsigned Saturating Extract Narrow
//----------------------------------------------------------------------

    uqxtn b18, b18
    uqxtn h20, h17
    uqxtn s19, s14

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqxtn b18, b18
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqxtn h20, h17
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        uqxtn s19, s14
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Signed Shift Right (Immediate)
//----------------------------------------------------------------------
        sshr d15, d16, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        sshr d15, d16, #99
// CHECK-ERROR:                       ^

        sshr d15, s16, #31

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        sshr d15, s16, #31
// CHECK-ERROR:                  ^

//----------------------------------------------------------------------
// Scalar Unsigned Shift Right (Immediate)
//----------------------------------------------------------------------

        ushr d10, d17, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        ushr d10, d17, #99
// CHECK-ERROR:                       ^

//----------------------------------------------------------------------
// Scalar Signed Rounding Shift Right (Immediate)
//----------------------------------------------------------------------

        srshr d19, d18, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        srshr d19, d18, #99
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Scalar Unigned Rounding Shift Right (Immediate)
//----------------------------------------------------------------------

        urshr d20, d23, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        urshr d20, d23, #99
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Scalar Signed Shift Right and Accumulate (Immediate)
//----------------------------------------------------------------------

        ssra d18, d12, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        ssra d18, d12, #99
// CHECK-ERROR:                       ^

//----------------------------------------------------------------------
// Scalar Unsigned Shift Right and Accumulate (Immediate)
//----------------------------------------------------------------------

        usra d20, d13, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        usra d20, d13, #99
// CHECK-ERROR:                       ^

//----------------------------------------------------------------------
// Scalar Signed Rounding Shift Right and Accumulate (Immediate)
//----------------------------------------------------------------------

        srsra d15, d11, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        srsra d15, d11, #99
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Scalar Unsigned Rounding Shift Right and Accumulate (Immediate)
//----------------------------------------------------------------------

        ursra d18, d10, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        ursra d18, d10, #99
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Scalar Shift Left (Immediate)
//----------------------------------------------------------------------

        shl d7, d10, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:        shl d7, d10, #99
// CHECK-ERROR:                     ^

        shl d7, s16, #31

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        shl d7, s16, #31
// CHECK-ERROR:                ^

//----------------------------------------------------------------------
// Signed Saturating Shift Left (Immediate)
//----------------------------------------------------------------------

        sqshl b11, b19, #99
        sqshl h13, h18, #99
        sqshl s14, s17, #99
        sqshl d15, d16, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:        sqshl b11, b19, #99
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:        sqshl h13, h18, #99
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:        sqshl s14, s17, #99
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:        sqshl d15, d16, #99
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Unsigned Saturating Shift Left (Immediate)
//----------------------------------------------------------------------

        uqshl b18, b15, #99
        uqshl h11, h18, #99
        uqshl s14, s19, #99
        uqshl d15, d12, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:        uqshl b18, b15, #99
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:        uqshl h11, h18, #99
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:        uqshl s14, s19, #99
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:        uqshl d15, d12, #99
// CHECK-ERROR:                        ^

//----------------------------------------------------------------------
// Signed Saturating Shift Left Unsigned (Immediate)
//----------------------------------------------------------------------

        sqshlu b15, b18, #99
        sqshlu h19, h17, #99
        sqshlu s16, s14, #99
        sqshlu d11, d13, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 7]
// CHECK-ERROR:        sqshlu  b15, b18, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 15]
// CHECK-ERROR:        sqshlu  h19, h17, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 31]
// CHECK-ERROR:        sqshlu  s16, s14, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:        sqshlu  d11, d13, #99
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Shift Right And Insert (Immediate)
//----------------------------------------------------------------------

        sri d10, d12, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        sri d10, d12, #99
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Shift Left And Insert (Immediate)
//----------------------------------------------------------------------

        sli d10, d14, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [0, 63]
// CHECK-ERROR:        sli d10, d14, #99
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Signed Saturating Shift Right Narrow (Immediate)
//----------------------------------------------------------------------

        sqshrn b10, h15, #99
        sqshrn h17, s10, #99
        sqshrn s18, d10, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:        sqshrn  b10, h15, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:        sqshrn  h17, s10, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        sqshrn  s18, d10, #99
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Unsigned Saturating Shift Right Narrow (Immediate)
//----------------------------------------------------------------------

        uqshrn b12, h10, #99
        uqshrn h10, s14, #99
        uqshrn s10, d12, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:        uqshrn  b12, h10, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:        uqshrn  h10, s14, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        uqshrn  s10, d12, #99
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Signed Saturating Rounded Shift Right Narrow (Immediate)
//----------------------------------------------------------------------

        sqrshrn b10, h13, #99
        sqrshrn h15, s10, #99
        sqrshrn s15, d12, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:        sqrshrn b10, h13, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:        sqrshrn h15, s10, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        sqrshrn s15, d12, #99
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Unsigned Saturating Rounded Shift Right Narrow (Immediate)
//----------------------------------------------------------------------

        uqrshrn b10, h12, #99
        uqrshrn h12, s10, #99
        uqrshrn s10, d10, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:        uqrshrn b10, h12, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:        uqrshrn h12, s10, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        uqrshrn s10, d10, #99
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Signed Saturating Shift Right Unsigned Narrow (Immediate)
//----------------------------------------------------------------------

        sqshrun b15, h10, #99
        sqshrun h20, s14, #99
        sqshrun s10, d15, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:        sqshrun b15, h10, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:        sqshrun h20, s14, #99
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        sqshrun s10, d15, #99
// CHECK-ERROR:                          ^

//----------------------------------------------------------------------
// Signed Saturating Rounded Shift Right Unsigned Narrow (Immediate)
//----------------------------------------------------------------------

        sqrshrun b17, h10, #99
        sqrshrun h10, s13, #99
        sqrshrun s22, d16, #99

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 8]
// CHECK-ERROR:        sqrshrun b17, h10, #99
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 16]
// CHECK-ERROR:        sqrshrun h10, s13, #99
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        sqrshrun s22, d16, #99
// CHECK-ERROR:                           ^

//----------------------------------------------------------------------
// Scalar Signed Fixed-point Convert To Floating-Point (Immediate)
//----------------------------------------------------------------------

    scvtf s22, s13, #0
    scvtf s22, s13, #33
    scvtf d21, d12, #65
    scvtf d21, s12, #31

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        scvtf s22, s13, #0
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        scvtf s22, s13, #33
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        scvtf d21, d12, #65
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        scvtf d21, s12, #31
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Unsigned Fixed-point Convert To Floating-Point (Immediate)
//----------------------------------------------------------------------

    ucvtf s22, s13, #34
    ucvtf d21, d14, #65
    ucvtf d21, s14, #64

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        ucvtf s22, s13, #34
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        ucvtf d21, d14, #65
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        ucvtf d21, s14, #64
// CHECK-ERROR:                   ^

//------------------------------------------------------------------------------
// Element reverse
//------------------------------------------------------------------------------
         rev64 v6.2d, v8.2d
         rev32 v30.2s, v31.2s
         rev32 v30.4s, v31.4s
         rev32 v30.2d, v31.2d
         rev16 v21.4h, v1.4h
         rev16 v21.8h, v1.8h
         rev16 v21.2s, v1.2s
         rev16 v21.4s, v1.4s
         rev16 v21.2d, v1.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev64 v6.2d, v8.2d
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev32 v30.2s, v31.2s
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev32 v30.4s, v31.4s
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev32 v30.2d, v31.2d
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev16 v21.4h, v1.4h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev16 v21.8h, v1.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev16 v21.2s, v1.2s
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev16 v21.4s, v1.4s
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rev16 v21.2d, v1.2d
// CHECK-ERROR:                   ^

//------------------------------------------------------------------------------
// Signed integer pairwise add long
//------------------------------------------------------------------------------

         saddlp v3.8h, v21.8h
         saddlp v8.8b, v5.8b
         saddlp v9.8h, v1.4s
         saddlp v0.4s, v1.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         saddlp v3.8h, v21.8h
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         saddlp v8.8b, v5.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         saddlp v9.8h, v1.4s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         saddlp v0.4s, v1.2d
// CHECK-ERROR:                          ^

//------------------------------------------------------------------------------
// Unsigned integer pairwise add long
//------------------------------------------------------------------------------

         uaddlp v3.8h, v21.8h
         uaddlp v8.8b, v5.8b
         uaddlp v9.8h, v1.4s
         uaddlp v0.4s, v1.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uaddlp v3.8h, v21.8h
// CHECK-ERROR:                           ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uaddlp v8.8b, v5.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uaddlp v9.8h, v1.4s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uaddlp v0.4s, v1.2d
// CHECK-ERROR:                          ^

//------------------------------------------------------------------------------
// Signed integer pairwise add and accumulate long
//------------------------------------------------------------------------------

         sadalp v3.16b, v21.16b
         sadalp v8.4h, v5.4h
         sadalp v9.4s, v1.4s
         sadalp v0.4h, v1.2s
         sadalp v12.2d, v4.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sadalp v3.16b, v21.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sadalp v8.4h, v5.4h
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sadalp v9.4s, v1.4s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sadalp v0.4h, v1.2s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sadalp v12.2d, v4.8h
// CHECK-ERROR:                           ^

//------------------------------------------------------------------------------
// Unsigned integer pairwise add and accumulate long
//------------------------------------------------------------------------------

         uadalp v3.16b, v21.16b
         uadalp v8.4h, v5.4h
         uadalp v9.4s, v1.4s
         uadalp v0.4h, v1.2s
         uadalp v12.2d, v4.8h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uadalp v3.16b, v21.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uadalp v8.4h, v5.4h
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uadalp v9.4s, v1.4s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uadalp v0.4h, v1.2s
// CHECK-ERROR:                          ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uadalp v12.2d, v4.8h
// CHECK-ERROR:                           ^

//------------------------------------------------------------------------------
// Signed integer saturating accumulate of unsigned value
//------------------------------------------------------------------------------

         suqadd v0.16b, v31.8b
         suqadd v1.8b, v9.8h
         suqadd v13.4h, v21.4s
         suqadd v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         suqadd v0.16b, v31.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         suqadd v1.8b, v9.8h
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         suqadd v13.4h, v21.4s
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         suqadd v4.2s, v0.2d
// CHECK-ERROR:                       ^

//------------------------------------------------------------------------------
// Unsigned integer saturating accumulate of signed value
//------------------------------------------------------------------------------

         usqadd v0.16b, v31.8b
         usqadd v2.8h, v4.4h
         usqadd v13.4h, v21.4s
         usqadd v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         usqadd v0.16b, v31.8b
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         usqadd v2.8h, v4.4h
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         usqadd v13.4h, v21.4s
// CHECK-ERROR:                        ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         usqadd v4.2s, v0.2d
// CHECK-ERROR:                       ^

//------------------------------------------------------------------------------
// Integer saturating absolute
//------------------------------------------------------------------------------

         sqabs v0.16b, v31.8b
         sqabs v2.8h, v4.4h
         sqabs v6.4s, v8.2s
         sqabs v6.2d, v8.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqabs v0.16b, v31.8b
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqabs v2.8h, v4.4h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqabs v6.4s, v8.2s
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqabs v6.2d, v8.2s
// CHECK-ERROR:                      ^

//------------------------------------------------------------------------------
// Signed integer saturating negate
//------------------------------------------------------------------------------

         sqneg v0.16b, v31.8b
         sqneg v2.8h, v4.4h
         sqneg v6.4s, v8.2s
         sqneg v6.2d, v8.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqneg v0.16b, v31.8b
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqneg v2.8h, v4.4h
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqneg v6.4s, v8.2s
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqneg v6.2d, v8.2s
// CHECK-ERROR:                      ^

//------------------------------------------------------------------------------
// Integer absolute
//------------------------------------------------------------------------------

         abs v0.16b, v31.8b
         abs v2.8h, v4.4h
         abs v6.4s, v8.2s
         abs v6.2d, v8.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         abs v0.16b, v31.8b
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         abs v2.8h, v4.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         abs v6.4s, v8.2s
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         abs v6.2d, v8.2s
// CHECK-ERROR:                    ^

//------------------------------------------------------------------------------
// Integer count leading sign bits
//------------------------------------------------------------------------------

         cls v0.2d, v31.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cls v0.2d, v31.2d
// CHECK-ERROR:                ^

//------------------------------------------------------------------------------
// Integer count leading zeros
//------------------------------------------------------------------------------

         clz v0.2d, v31.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         clz v0.2d, v31.2d
// CHECK-ERROR:                ^

//------------------------------------------------------------------------------
// Population count
//------------------------------------------------------------------------------

         cnt v2.8h, v4.8h
         cnt v6.4s, v8.4s
         cnt v6.2d, v8.2d
         cnt v13.4h, v21.4h
         cnt v4.2s, v0.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cnt v2.8h, v4.8h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cnt v6.4s, v8.4s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cnt v6.2d, v8.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cnt v13.4h, v21.4h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         cnt v4.2s, v0.2s
// CHECK-ERROR:                ^


//------------------------------------------------------------------------------
// Bitwise NOT
//------------------------------------------------------------------------------

         not v2.8h, v4.8h
         not v6.4s, v8.4s
         not v6.2d, v8.2d
         not v13.4h, v21.4h
         not v4.2s, v0.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         not v2.8h, v4.8h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         not v6.4s, v8.4s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         not v6.2d, v8.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         not v13.4h, v21.4h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         not v4.2s, v0.2s
// CHECK-ERROR:                ^

//------------------------------------------------------------------------------
// Bitwise reverse
//------------------------------------------------------------------------------

         rbit v2.8h, v4.8h
         rbit v6.4s, v8.4s
         rbit v6.2d, v8.2d
         rbit v13.4h, v21.4h
         rbit v4.2s, v0.2s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rbit v2.8h, v4.8h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rbit v6.4s, v8.4s
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rbit v6.2d, v8.2d
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rbit v13.4h, v21.4h
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         rbit v4.2s, v0.2s
// CHECK-ERROR:                 ^

//------------------------------------------------------------------------------
// Floating-point absolute
//------------------------------------------------------------------------------

         fabs v0.16b, v31.16b
         fabs v2.8h, v4.8h
         fabs v1.8b, v9.8b
         fabs v13.4h, v21.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fabs v0.16b, v31.16b
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fabs v2.8h, v4.8h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fabs v1.8b, v9.8b
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fabs v13.4h, v21.4h
// CHECK-ERROR:                  ^

//------------------------------------------------------------------------------
// Floating-point negate
//------------------------------------------------------------------------------

         fneg v0.16b, v31.16b
         fneg v2.8h, v4.8h
         fneg v1.8b, v9.8b
         fneg v13.4h, v21.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fneg v0.16b, v31.16b
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fneg v2.8h, v4.8h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fneg v1.8b, v9.8b
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fneg v13.4h, v21.4h
// CHECK-ERROR:                  ^

//------------------------------------------------------------------------------
// Integer extract and narrow
//------------------------------------------------------------------------------

         xtn v0.16b, v31.8h
         xtn v2.8h, v4.4s
         xtn v6.4s, v8.2d
         xtn2 v1.8b, v9.8h
         xtn2 v13.4h, v21.4s
         xtn2 v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         xtn v0.16b, v31.8h
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         xtn v2.8h, v4.4s
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         xtn v6.4s, v8.2d
// CHECK-ERROR:             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         xtn2 v1.8b, v9.8h
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         xtn2 v13.4h, v21.4s
// CHECK-ERROR:              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         xtn2 v4.2s, v0.2d
// CHECK-ERROR:              ^

//------------------------------------------------------------------------------
// Signed integer saturating extract and unsigned narrow
//------------------------------------------------------------------------------

         sqxtun v0.16b, v31.8h
         sqxtun v2.8h, v4.4s
         sqxtun v6.4s, v8.2d
         sqxtun2 v1.8b, v9.8h
         sqxtun2 v13.4h, v21.4s
         sqxtun2 v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtun v0.16b, v31.8h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtun v2.8h, v4.4s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtun v6.4s, v8.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtun2 v1.8b, v9.8h
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtun2 v13.4h, v21.4s
// CHECK-ERROR:                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtun2 v4.2s, v0.2d
// CHECK-ERROR:                 ^

//------------------------------------------------------------------------------
// Signed integer saturating extract and narrow
//------------------------------------------------------------------------------

         sqxtn v0.16b, v31.8h
         sqxtn v2.8h, v4.4s
         sqxtn v6.4s, v8.2d
         sqxtn2 v1.8b, v9.8h
         sqxtn2 v13.4h, v21.4s
         sqxtn2 v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtn v0.16b, v31.8h
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtn v2.8h, v4.4s
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtn v6.4s, v8.2d
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtn2 v1.8b, v9.8h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtn2 v13.4h, v21.4s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         sqxtn2 v4.2s, v0.2d
// CHECK-ERROR:                ^

//------------------------------------------------------------------------------
// Unsigned integer saturating extract and narrow
//------------------------------------------------------------------------------

         uqxtn v0.16b, v31.8h
         uqxtn v2.8h, v4.4s
         uqxtn v6.4s, v8.2d
         uqxtn2 v1.8b, v9.8h
         uqxtn2 v13.4h, v21.4s
         uqxtn2 v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqxtn v0.16b, v31.8h
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqxtn v2.8h, v4.4s
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqxtn v6.4s, v8.2d
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqxtn2 v1.8b, v9.8h
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqxtn2 v13.4h, v21.4s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         uqxtn2 v4.2s, v0.2d
// CHECK-ERROR:                ^

//------------------------------------------------------------------------------
// Integer shift left long
//------------------------------------------------------------------------------

         shll2 v2.8h, v4.16b, #7
         shll2 v6.4s, v8.8h, #15
         shll2 v6.2d, v8.4s, #31
         shll v2.8h, v4.16b, #8
         shll v6.4s, v8.8h, #16
         shll v6.2d, v8.4s, #32
         shll v2.8h, v4.8b, #8
         shll v6.4s, v8.4h, #16
         shll v6.2d, v8.2s, #32
         shll2 v2.8h, v4.8b, #5
         shll2 v6.4s, v8.4h, #14
         shll2 v6.2d, v8.2s, #1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll2 v2.8h, v4.16b, #7
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll2 v6.4s, v8.8h, #15
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll2 v6.2d, v8.4s, #31
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll v2.8h, v4.16b, #8
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll v6.4s, v8.8h, #16
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll v6.2d, v8.4s, #32
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll2 v2.8h, v4.8b, #5
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll2 v6.4s, v8.4h, #14
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         shll2 v6.2d, v8.2s, #1
// CHECK-ERROR:                      ^

//------------------------------------------------------------------------------
// Floating-point convert downsize
//------------------------------------------------------------------------------

         fcvtn v2.8h, v4.4s
         fcvtn v6.4s, v8.2d
         fcvtn2 v13.4h, v21.4s
         fcvtn2 v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtn v2.8h, v4.4s
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtn v6.4s, v8.2d
// CHECK-ERROR:               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtn2 v13.4h, v21.4s
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtn2 v4.2s, v0.2d
// CHECK-ERROR:                ^

//------------------------------------------------------------------------------
// Floating-point convert downsize with inexact
//------------------------------------------------------------------------------

         fcvtxn v6.4s, v8.2d
         fcvtxn2 v4.2s, v0.2d

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtxn v6.4s, v8.2d
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtxn2 v4.2s, v0.2d
// CHECK-ERROR:                 ^

//------------------------------------------------------------------------------
// Floating-point convert upsize
//------------------------------------------------------------------------------

         fcvtl2 v9.4s, v1.4h
         fcvtl2 v0.2d, v1.2s
         fcvtl v12.4s, v4.8h
         fcvtl v17.2d, v28.4s

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtl2 v9.4s, v1.4h
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtl2 v0.2d, v1.2s
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtl v12.4s, v4.8h
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtl v17.2d, v28.4s
// CHECK-ERROR:                       ^

//------------------------------------------------------------------------------
// Floating-point round to integral
//------------------------------------------------------------------------------

         frintn v0.16b, v31.16b
         frintn v2.8h, v4.8h
         frintn v1.8b, v9.8b
         frintn v13.4h, v21.4h

         frinta v0.16b, v31.16b
         frinta v2.8h, v4.8h
         frinta v1.8b, v9.8b
         frinta v13.4h, v21.4h

         frintp v0.16b, v31.16b
         frintp v2.8h, v4.8h
         frintp v1.8b, v9.8b
         frintp v13.4h, v21.4h

         frintm v0.16b, v31.16b
         frintm v2.8h, v4.8h
         frintm v1.8b, v9.8b
         frintm v13.4h, v21.4h

         frintx v0.16b, v31.16b
         frintx v2.8h, v4.8h
         frintx v1.8b, v9.8b
         frintx v13.4h, v21.4h

         frintz v0.16b, v31.16b
         frintz v2.8h, v4.8h
         frintz v1.8b, v9.8b
         frintz v13.4h, v21.4h

         frinti v0.16b, v31.16b
         frinti v2.8h, v4.8h
         frinti v1.8b, v9.8b
         frinti v13.4h, v21.4h

         fcvtns v0.16b, v31.16b
         fcvtns v2.8h, v4.8h
         fcvtns v1.8b, v9.8b
         fcvtns v13.4h, v21.4h

         fcvtnu v0.16b, v31.16b
         fcvtnu v2.8h, v4.8h
         fcvtnu v1.8b, v9.8b
         fcvtnu v13.4h, v21.4h

         fcvtps v0.16b, v31.16b
         fcvtps v2.8h, v4.8h
         fcvtps v1.8b, v9.8b
         fcvtps v13.4h, v21.4h

         fcvtpu v0.16b, v31.16b
         fcvtpu v2.8h, v4.8h
         fcvtpu v1.8b, v9.8b
         fcvtpu v13.4h, v21.4h

         fcvtms v0.16b, v31.16b
         fcvtms v2.8h, v4.8h
         fcvtms v1.8b, v9.8b
         fcvtms v13.4h, v21.4h

         fcvtmu v0.16b, v31.16b
         fcvtmu v2.8h, v4.8h
         fcvtmu v1.8b, v9.8b
         fcvtmu v13.4h, v21.4h

         fcvtzs v0.16b, v31.16b
         fcvtzs v2.8h, v4.8h
         fcvtzs v1.8b, v9.8b
         fcvtzs v13.4h, v21.4h

         fcvtzu v0.16b, v31.16b
         fcvtzu v2.8h, v4.8h
         fcvtzu v1.8b, v9.8b
         fcvtzu v13.4h, v21.4h

         fcvtas v0.16b, v31.16b
         fcvtas v2.8h, v4.8h
         fcvtas v1.8b, v9.8b
         fcvtas v13.4h, v21.4h

         fcvtau v0.16b, v31.16b
         fcvtau v2.8h, v4.8h
         fcvtau v1.8b, v9.8b
         fcvtau v13.4h, v21.4h

         urecpe v0.16b, v31.16b
         urecpe v2.8h, v4.8h
         urecpe v1.8b, v9.8b
         urecpe v13.4h, v21.4h
         urecpe v1.2d, v9.2d

         ursqrte v0.16b, v31.16b
         ursqrte v2.8h, v4.8h
         ursqrte v1.8b, v9.8b
         ursqrte v13.4h, v21.4h
         ursqrte v1.2d, v9.2d

         scvtf v0.16b, v31.16b
         scvtf v2.8h, v4.8h
         scvtf v1.8b, v9.8b
         scvtf v13.4h, v21.4h

         ucvtf v0.16b, v31.16b
         ucvtf v2.8h, v4.8h
         ucvtf v1.8b, v9.8b
         ucvtf v13.4h, v21.4h

         frecpe v0.16b, v31.16b
         frecpe v2.8h, v4.8h
         frecpe v1.8b, v9.8b
         frecpe v13.4h, v21.4h

         frsqrte v0.16b, v31.16b
         frsqrte v2.8h, v4.8h
         frsqrte v1.8b, v9.8b
         frsqrte v13.4h, v21.4h

         fsqrt v0.16b, v31.16b
         fsqrt v2.8h, v4.8h
         fsqrt v1.8b, v9.8b
         fsqrt v13.4h, v21.4h

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintn v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintn v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintn v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintn v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frinta v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frinta v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frinta v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frinta v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintp v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintp v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintp v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintp v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintm v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintm v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintm v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintm v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintx v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintx v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintx v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintx v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintz v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintz v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frintz v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frintz v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frinti v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frinti v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frinti v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frinti v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtns v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtns v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtns v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtns v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtnu v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtnu v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtnu v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtnu v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtps v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtps v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtps v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtps v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtpu v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtpu v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtpu v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtpu v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtms v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtms v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtms v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtms v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtmu v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtmu v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtmu v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtmu v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtzs v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtzs v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtzs v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtzs v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtzu v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtzu v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtzu v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtzu v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtas v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtas v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtas v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtas v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtau v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtau v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fcvtau v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fcvtau v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urecpe v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urecpe v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urecpe v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urecpe v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         urecpe v1.2d, v9.2d
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursqrte v0.16b, v31.16b
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursqrte v2.8h, v4.8h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursqrte v1.8b, v9.8b
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursqrte v13.4h, v21.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ursqrte v1.2d, v9.2d
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         scvtf v0.16b, v31.16b
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         scvtf v2.8h, v4.8h
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         scvtf v1.8b, v9.8b
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         scvtf v13.4h, v21.4h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ucvtf v0.16b, v31.16b
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         ucvtf v2.8h, v4.8h
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ucvtf v1.8b, v9.8b
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         ucvtf v13.4h, v21.4h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frecpe v0.16b, v31.16b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frecpe v2.8h, v4.8h
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frecpe v1.8b, v9.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frecpe v13.4h, v21.4h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frsqrte v0.16b, v31.16b
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frsqrte v2.8h, v4.8h
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         frsqrte v1.8b, v9.8b
// CHECK-ERROR:                    ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         frsqrte v13.4h, v21.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fsqrt v0.16b, v31.16b
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fsqrt v2.8h, v4.8h
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         fsqrt v1.8b, v9.8b
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: instruction requires: fullfp16
// CHECK-ERROR:         fsqrt v13.4h, v21.4h
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Signed Fixed-point (Immediate)
//----------------------------------------------------------------------

    fcvtzs s21, s12, #0
    fcvtzs d21, d12, #65
    fcvtzs s21, d12, #1

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        fcvtzs s21, s12, #0
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        fcvtzs d21, d12, #65
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtzs s21, d12, #1
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Unsigned Fixed-point (Immediate)
//----------------------------------------------------------------------

    fcvtzu s21, s12, #33
    fcvtzu d21, d12, #0
    fcvtzu s21, d12, #1

// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 32]
// CHECK-ERROR:        fcvtzu s21, s12, #33
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: {{expected|immediate must be an}} integer in range [1, 64]
// CHECK-ERROR:        fcvtzu d21, d12, #0
// CHECK-ERROR:                         ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtzu s21, d12, #1
// CHECK-ERROR:                    ^

//----------------------------------------------------------------------
// Scalar Unsigned Saturating Extract Narrow
//----------------------------------------------------------------------

        aese v0.8h, v1.8h
        aese v0.4s, v1.4s
        aese v0.2d, v1.2d
        aesd v0.8h, v1.8h
        aesmc v0.8h, v1.8h
        aesimc v0.8h, v1.8h

// CHECK:  error: invalid operand for instruction
// CHECK:         aese v0.8h, v1.8h
// CHECK:                 ^
// CHECK:  error: invalid operand for instruction
// CHECK:         aese v0.4s, v1.4s
// CHECK:                 ^
// CHECK:  error: invalid operand for instruction
// CHECK:         aese v0.2d, v1.2d
// CHECK:                 ^
// CHECK:  error: invalid operand for instruction
// CHECK:         aesd v0.8h, v1.8h
// CHECK:                 ^
// CHECK:  error: invalid operand for instruction
// CHECK:         aesmc v0.8h, v1.8h
// CHECK:                  ^
// CHECK:  error: invalid operand for instruction
// CHECK:         aesimc v0.8h, v1.8h
// CHECK:                   ^

        sha1h b0, b1
        sha1h h0, h1
        sha1h d0, d1
        sha1h q0, q1
        sha1su1 v0.16b, v1.16b
        sha1su1 v0.8h, v1.8h
        sha1su1 v0.2d, v1.2d
        sha256su0 v0.16b, v1.16b

// CHECK:  error: invalid operand for instruction
// CHECK:         sha1h b0, b1
// CHECK:               ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1h h0, h1
// CHECK:               ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1h d0, d1
// CHECK:               ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1h q0, q1
// CHECK:               ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1su1 v0.16b, v1.16b
// CHECK:                    ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1su1 v0.8h, v1.8h
// CHECK:                    ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1su1 v0.2d, v1.2d
// CHECK:                    ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha256su0 v0.16b, v1.16b
// CHECK:                      ^

        sha1c q0, q1, v2.4s
        sha1p q0, q1, v2.4s
        sha1m q0, q1, v2.4s
        sha1su0 v0.16b, v1.16b, v2.16b
        sha1su0 v0.8h, v1.8h, v2.8h
        sha1su0 v0.2d, v1.2d, v2.2d
        sha256h q0, q1, q2
        sha256h v0.4s, v1.4s, v2.4s
        sha256h2 q0, q1, q2
        sha256su1 v0.16b, v1.16b, v2.16b

// CHECK:  error: invalid operand for instruction
// CHECK:         sha1c q0, q1, v2.4s
// CHECK:                   ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1p q0, q1, v2.4s
// CHECK:                   ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1m q0, q1, v2.4s
// CHECK:                   ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1su0 v0.16b, v1.16b, v2.16b
// CHECK:                    ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1su0 v0.8h, v1.8h, v2.8h
// CHECK:                    ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha1su0 v0.2d, v1.2d, v2.2d
// CHECK:                    ^
// CHECK:  error: too few operands for instruction
// CHECK:         sha256h q0, q1, q2
// CHECK:         ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha256h v0.4s, v1.4s, v2.4s
// CHECK:                    ^
// CHECK:  error: too few operands for instruction
// CHECK:         sha256h2 q0, q1, q2
// CHECK:         ^
// CHECK:  error: invalid operand for instruction
// CHECK:         sha256su1 v0.16b, v1.16b, v2.16b
// CHECK:                      ^

//----------------------------------------------------------------------
// Bitwise extract
//----------------------------------------------------------------------

        ext v0.8b, v1.8b, v2.4h, #0x3
        ext v0.4h, v1.4h, v2.4h, #0x3
        ext v0.2s, v1.2s, v2.2s, #0x1
        ext v0.1d, v1.1d, v2.1d, #0x0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.8b, v1.8b, v2.4h, #0x3
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.4h, v1.4h, v2.4h, #0x3
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.2s, v1.2s, v2.2s, #0x1
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.1d, v1.1d, v2.1d, #0x0
// CHECK-ERROR:                ^

        ext v0.16b, v1.16b, v2.8h, #0x3
        ext v0.8h, v1.8h, v2.8h, #0x3
        ext v0.4s, v1.4s, v2.4s, #0x1
        ext v0.2d, v1.2d, v2.2d, #0x0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.16b, v1.16b, v2.8h, #0x3
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.8h, v1.8h, v2.8h, #0x3
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.4s, v1.4s, v2.4s, #0x1
// CHECK-ERROR:                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:         ext v0.2d, v1.2d, v2.2d, #0x0
// CHECK-ERROR:                ^


//----------------------------------------------------------------------
// Permutation with 3 vectors
//----------------------------------------------------------------------

        uzp1 v0.16b, v1.8b, v2.8b
        uzp1 v0.8b, v1.4b, v2.4b
        uzp1 v0.8h, v1.4h, v2.4h
        uzp1 v0.4h, v1.2h, v2.2h
        uzp1 v0.4s, v1.2s, v2.2s
        uzp1 v0.2s, v1.1s, v2.1s
        uzp1 v0.2d, v1.1d, v2.1d
        uzp1 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        uzp2 v0.16b, v1.8b, v2.8b
        uzp2 v0.8b, v1.4b, v2.4b
        uzp2 v0.8h, v1.4h, v2.4h
        uzp2 v0.4h, v1.2h, v2.2h
        uzp2 v0.4s, v1.2s, v2.2s
        uzp2 v0.2s, v1.1s, v2.1s
        uzp2 v0.2d, v1.1d, v2.1d
        uzp2 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        zip1 v0.16b, v1.8b, v2.8b
        zip1 v0.8b, v1.4b, v2.4b
        zip1 v0.8h, v1.4h, v2.4h
        zip1 v0.4h, v1.2h, v2.2h
        zip1 v0.4s, v1.2s, v2.2s
        zip1 v0.2s, v1.1s, v2.1s
        zip1 v0.2d, v1.1d, v2.1d
        zip1 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        zip2 v0.16b, v1.8b, v2.8b
        zip2 v0.8b, v1.4b, v2.4b
        zip2 v0.8h, v1.4h, v2.4h
        zip2 v0.4h, v1.2h, v2.2h
        zip2 v0.4s, v1.2s, v2.2s
        zip2 v0.2s, v1.1s, v2.1s
        zip2 v0.2d, v1.1d, v2.1d
        zip2 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        trn1 v0.16b, v1.8b, v2.8b
        trn1 v0.8b, v1.4b, v2.4b
        trn1 v0.8h, v1.4h, v2.4h
        trn1 v0.4h, v1.2h, v2.2h
        trn1 v0.4s, v1.2s, v2.2s
        trn1 v0.2s, v1.1s, v2.1s
        trn1 v0.2d, v1.1d, v2.1d
        trn1 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        trn2 v0.16b, v1.8b, v2.8b
        trn2 v0.8b, v1.4b, v2.4b
        trn2 v0.8h, v1.4h, v2.4h
        trn2 v0.4h, v1.2h, v2.2h
        trn2 v0.4s, v1.2s, v2.2s
        trn2 v0.2s, v1.1s, v2.1s
        trn2 v0.2d, v1.1d, v2.1d
        trn2 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Permutation with 3 vectors
//----------------------------------------------------------------------

        uzp1 v0.16b, v1.8b, v2.8b
        uzp1 v0.8b, v1.4b, v2.4b
        uzp1 v0.8h, v1.4h, v2.4h
        uzp1 v0.4h, v1.2h, v2.2h
        uzp1 v0.4s, v1.2s, v2.2s
        uzp1 v0.2s, v1.1s, v2.1s
        uzp1 v0.2d, v1.1d, v2.1d
        uzp1 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp1 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        uzp2 v0.16b, v1.8b, v2.8b
        uzp2 v0.8b, v1.4b, v2.4b
        uzp2 v0.8h, v1.4h, v2.4h
        uzp2 v0.4h, v1.2h, v2.2h
        uzp2 v0.4s, v1.2s, v2.2s
        uzp2 v0.2s, v1.1s, v2.1s
        uzp2 v0.2d, v1.1d, v2.1d
        uzp2 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         uzp2 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        zip1 v0.16b, v1.8b, v2.8b
        zip1 v0.8b, v1.4b, v2.4b
        zip1 v0.8h, v1.4h, v2.4h
        zip1 v0.4h, v1.2h, v2.2h
        zip1 v0.4s, v1.2s, v2.2s
        zip1 v0.2s, v1.1s, v2.1s
        zip1 v0.2d, v1.1d, v2.1d
        zip1 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip1 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        zip2 v0.16b, v1.8b, v2.8b
        zip2 v0.8b, v1.4b, v2.4b
        zip2 v0.8h, v1.4h, v2.4h
        zip2 v0.4h, v1.2h, v2.2h
        zip2 v0.4s, v1.2s, v2.2s
        zip2 v0.2s, v1.1s, v2.1s
        zip2 v0.2d, v1.1d, v2.1d
        zip2 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         zip2 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        trn1 v0.16b, v1.8b, v2.8b
        trn1 v0.8b, v1.4b, v2.4b
        trn1 v0.8h, v1.4h, v2.4h
        trn1 v0.4h, v1.2h, v2.2h
        trn1 v0.4s, v1.2s, v2.2s
        trn1 v0.2s, v1.1s, v2.1s
        trn1 v0.2d, v1.1d, v2.1d
        trn1 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn1 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

        trn2 v0.16b, v1.8b, v2.8b
        trn2 v0.8b, v1.4b, v2.4b
        trn2 v0.8h, v1.4h, v2.4h
        trn2 v0.4h, v1.2h, v2.2h
        trn2 v0.4s, v1.2s, v2.2s
        trn2 v0.2s, v1.1s, v2.1s
        trn2 v0.2d, v1.1d, v2.1d
        trn2 v0.1d, v1.1d, v2.1d

// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.16b, v1.8b, v2.8b
// CHECK-ERROR:                      ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.8b, v1.4b, v2.4b
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.8h, v1.4h, v2.4h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.4h, v1.2h, v2.2h
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.4s, v1.2s, v2.2s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.2s, v1.1s, v2.1s
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.2d, v1.1d, v2.1d
// CHECK-ERROR:                     ^
// CHECK-ERROR:  error: invalid operand for instruction
// CHECK-ERROR:         trn2 v0.1d, v1.1d, v2.1d
// CHECK-ERROR:                 ^

//----------------------------------------------------------------------
// Floating Point  multiply (scalar, by element)
//----------------------------------------------------------------------
      // mismatched and invalid vector types
      fmul    s0, s1, v1.h[0]
      fmul    h0, h1, v1.s[0]
      // invalid lane
      fmul    s2, s29, v10.s[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmul    s0, s1, v1.h[0]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmul    h0, h1, v1.s[0]
// CHECK-ERROR:                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          fmul    s2, s29, v10.s[4]
// CHECK-ERROR:                                 ^

//----------------------------------------------------------------------
// Floating Point  multiply extended (scalar, by element)
//----------------------------------------------------------------------
      // mismatched and invalid vector types
      fmulx    d0, d1, v1.b[0]
      fmulx    h0, h1, v1.d[0]
      // invalid lane
      fmulx    d2, d29, v10.d[3]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmulx    d0, d1, v1.b[0]
// CHECK-ERROR:                              ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmulx    h0, h1, v1.d[0]
// CHECK-ERROR:                   ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          fmulx    d2, d29, v10.d[3]
// CHECK-ERROR:                                  ^

//----------------------------------------------------------------------
// Floating Point fused multiply-add (scalar, by element)
//----------------------------------------------------------------------
      // mismatched and invalid vector types
      fmla    b0, b1, v1.b[0]
      fmla    d30, s11, v1.d[1]
      // invalid lane
      fmla    s16, s22, v16.s[5]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmla    b0, b1, v1.b[0]
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmla    d30, s11, v1.d[1]
// CHECK-ERROR:                       ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          fmla    s16, s22, v16.s[5]
// CHECK-ERROR:                                  ^

//----------------------------------------------------------------------
// Floating Point fused multiply-subtract (scalar, by element)
//----------------------------------------------------------------------
    // mismatched and invalid vector types
    fmls    s29, h10, v28.s[1]
    fmls    h7, h17, v26.s[2]
    // invalid lane
    fmls    d16, d22, v16.d[-1]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmls    s29, h10, v28.s[1]
// CHECK-ERROR:                       ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          fmls    h7, h17, v26.s[2]
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: vector lane must be an integer in range [0, 1]
// CHECK-ERROR:          fmls    d16, d22, v16.d[-1]
// CHECK-ERROR:                                  ^

//----------------------------------------------------------------------
// Scalar Signed saturating doubling multiply-add long
// (scalar, by element)
//----------------------------------------------------------------------
    // mismatched and invalid vector types
    sqdmlal s0, h0, v0.s[0]
    sqdmlal s8, s9, v14.s[1]
    // invalid lane
    sqdmlal d4, s5, v1.s[5]
    // invalid vector index
    sqdmlal s0, h0, v17.h[0]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmlal s0, h0, v0.s[0]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmlal s8, s9, v14.s[1]
// CHECK-ERROR:                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          sqdmlal d4, s5, v1.s[5]
// CHECK-ERROR:                               ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmlal s0, h0, v17.h[0]
// CHECK-ERROR:                           ^

//----------------------------------------------------------------------
// Scalar Signed saturating doubling multiply-subtract long
// (scalar, by element)
//----------------------------------------------------------------------
    // mismatched and invalid vector types
    sqdmlsl s1, h1, v1.d[0]
    sqdmlsl d1, h1, v13.s[0]
    // invalid lane
    sqdmlsl d1, s1, v13.s[4]
    // invalid vector index
    sqdmlsl s1, h1, v20.h[7]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmlsl s1, h1, v1.d[0]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmlsl d1, h1, v13.s[0]
// CHECK-ERROR:                      ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          sqdmlsl d1, s1, v13.s[4]
// CHECK-ERROR:                                ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmlsl s1, h1, v20.h[7]
// CHECK-ERROR:                           ^

//----------------------------------------------------------------------
// Scalar Signed saturating doubling multiply long (scalar, by element)
//----------------------------------------------------------------------
    // mismatched and invalid vector types
    // invalid lane
    // invalid vector index
    // mismatched and invalid vector types
    sqdmull s1, h1, v1.s[1]
    sqdmull s1, s1, v4.s[0]
    // invalid lane
    sqdmull s12, h17, v9.h[9]
    // invalid vector index
    sqdmull s1, h1, v16.h[5]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmull s1, h1, v1.s[1]
// CHECK-ERROR:                             ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmull s1, s1, v4.s[0]
// CHECK-ERROR:                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          sqdmull s12, h17, v9.h[9]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmull s1, h1, v16.h[5]
// CHECK-ERROR:                           ^

//----------------------------------------------------------------------
// Scalar Signed saturating doubling multiply returning
// high half (scalar, by element)
//----------------------------------------------------------------------
    // mismatched and invalid vector types
    sqdmulh h0, s1, v0.h[0]
    sqdmulh s25, s26, v27.h[3]
    // invalid lane
    sqdmulh s25, s26, v27.s[4]
    // invalid vector index
    sqdmulh s0, h1, v30.h[0]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmulh h0, s1, v0.h[0]
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmulh s25, s26, v27.h[3]
// CHECK-ERROR:                  ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          sqdmulh s25, s26, v27.s[4]
// CHECK-ERROR:                                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqdmulh s0, h1, v30.h[0]
// CHECK-ERROR:                      ^

//----------------------------------------------------------------------
// Scalar Signed saturating rounding doubling multiply
// returning high half (scalar, by element)
//----------------------------------------------------------------------
    // mismatched and invalid vector types
    sqrdmulh h31, h30, v14.s[2]
    sqrdmulh s5, h6, v7.s[2]
    // invalid lane
    sqrdmulh h31, h30, v14.h[9]
    // invalid vector index
    sqrdmulh h31, h30, v20.h[4]

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqrdmulh h31, h30, v14.s[2]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqrdmulh s5, h6, v7.s[2]
// CHECK-ERROR:                       ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          sqrdmulh h31, h30, v14.h[9]
// CHECK-ERROR:                                 ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          sqrdmulh h31, h30, v20.h[4]
// CHECK-ERROR:                              ^

//----------------------------------------------------------------------
// Scalar Duplicate element (scalar)
//----------------------------------------------------------------------
      // mismatched and invalid vector types
      dup b0, v1.d[0]
      dup h0, v31.b[8]
      dup s0, v2.h[4]
      dup d0, v17.s[3]
      // invalid  lane
      dup d0, v17.d[4]
      dup s0, v1.s[7]
      dup h0, v31.h[16]
      dup b1, v3.b[16]
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          dup b0, v1.d[0]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          dup h0, v31.b[8]
// CHECK-ERROR:                      ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          dup s0, v2.h[4]
// CHECK-ERROR:                     ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:          dup d0, v17.s[3]
// CHECK-ERROR:                      ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          dup d0, v17.d[4]
// CHECK-ERROR:                        ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          dup s0, v1.s[7]
// CHECK-ERROR:                       ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          dup h0, v31.h[16]
// CHECK-ERROR:                        ^
// CHECK-ERROR: vector lane must be an integer in range
// CHECK-ERROR:          dup b1, v3.b[16]
// CHECK-ERROR:                       ^

//----------------------------------------------------------------------
// Table look up
//----------------------------------------------------------------------

        tbl v0.8b, {v1.8b}, v2.8b
        tbl v0.8b, {v1.8b, v2.8b}, v2.8b
        tbl v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
        tbl v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
        tbl v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbl v0.8b, {v1.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbl v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        tbl v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
// CHECK-ERROR:                                                    ^

        tbx v0.8b, {v1.8b}, v2.8b
        tbx v0.8b, {v1.8b, v2.8b}, v2.8b
        tbx v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
        tbx v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
        tbx v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbx v0.8b, {v1.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b, v3.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        tbx v0.8b, {v1.8b, v2.8b, v3.8b, v4.8b}, v2.8b
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid number of vectors
// CHECK-ERROR:        tbx v0.8b, {v1.16b, v2.16b, v3.16b, v4.16b, v5.16b}, v2.8b
// CHECK-ERROR:                                                    ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Lower Precision Narrow, Rounding To
// Odd
//----------------------------------------------------------------------

    fcvtxn s0, s1

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtxn s0, s1
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Signed Integer, Rounding To Nearest
// With Ties To Away
//----------------------------------------------------------------------

    fcvtas s0, d0
    fcvtas d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtas s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtas d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Unsigned Integer, Rounding To
// Nearest With Ties To Away
//----------------------------------------------------------------------

    fcvtau s0, d0
    fcvtau d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtau s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtau d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Signed Integer, Rounding Toward
// Minus Infinity
//----------------------------------------------------------------------

    fcvtms s0, d0
    fcvtms d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtms s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtms d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
// Minus Infinity
//----------------------------------------------------------------------

    fcvtmu s0, d0
    fcvtmu d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtmu s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtmu d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Signed Integer, Rounding To Nearest
// With Ties To Even
//----------------------------------------------------------------------

    fcvtns s0, d0
    fcvtns d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtns s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtns d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Unsigned Integer, Rounding To
// Nearest With Ties To Even
//----------------------------------------------------------------------

    fcvtnu s0, d0
    fcvtnu d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtnu s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtnu d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Signed Integer, Rounding Toward
// Positive Infinity
//----------------------------------------------------------------------

    fcvtps s0, d0
    fcvtps d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtps s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtps d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
// Positive Infinity
//----------------------------------------------------------------------

    fcvtpu s0, d0
    fcvtpu d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtpu s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtpu d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Signed Integer, Rounding Toward Zero
//----------------------------------------------------------------------

    fcvtzs s0, d0
    fcvtzs d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtzs s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtzs d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Convert To Unsigned Integer, Rounding Toward
// Zero
//----------------------------------------------------------------------

    fcvtzu s0, d0
    fcvtzu d0, s0

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtzu s0, d0
// CHECK-ERROR:                   ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fcvtzu d0, s0
// CHECK-ERROR:                   ^

//----------------------------------------------------------------------
// Scalar Floating-point Absolute Difference
//----------------------------------------------------------------------


    fabd s29, d24, s20
    fabd d29, s24, d20

// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fabd s29, d24, s20
// CHECK-ERROR:                  ^
// CHECK-ERROR: error: invalid operand for instruction
// CHECK-ERROR:        fabd d29, s24, d20
// CHECK-ERROR:                  ^