data-vec-sve2.json

[
 {
  "instr": "insertelement",
  "ty": "<8 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.b[0], w0\nret",
  "giasm": "mov v0.b[0], w0\nret",
  "ll": "define <8 x i8> @test(<8 x i8> %a, i8 %bs) {\n  %r = insertelement <8 x i8> %a, i8 %bs, i32 0\n  ret <8 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i8> %a, i8 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.b[1], w0\nret",
  "giasm": "mov v0.b[1], w0\nret",
  "ll": "define <8 x i8> @test(<8 x i8> %a, i8 %bs) {\n  %r = insertelement <8 x i8> %a, i8 %bs, i32 1\n  ret <8 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i8> %a, i8 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 7,
  "gisize": 10,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfxil x8, x1, #0, #3\nstrb w0, [x8]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w1\nmov w8, #1                          // =0x1\nstr d0, [sp, #8]\nand x9, x9, #0x7\nmul x8, x9, x8\nadd x9, sp, #8\nstrb w0, [x9, x8]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "ll": "define <8 x i8> @test(<8 x i8> %a, i8 %bs, i32 %c) {\n  %r = insertelement <8 x i8> %a, i8 %bs, i32 %c\n  ret <8 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i8> %a, i8 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.b[0], w0\nret",
  "giasm": "mov v0.b[0], w0\nret",
  "ll": "define <16 x i8> @test(<16 x i8> %a, i8 %bs) {\n  %r = insertelement <16 x i8> %a, i8 %bs, i32 0\n  ret <16 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x i8> %a, i8 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.b[1], w0\nret",
  "giasm": "mov v0.b[1], w0\nret",
  "ll": "define <16 x i8> @test(<16 x i8> %a, i8 %bs) {\n  %r = insertelement <16 x i8> %a, i8 %bs, i32 1\n  ret <16 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x i8> %a, i8 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 9,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfxil x8, x1, #0, #4\nstrb w0, [x8]\nldr q0, [sp], #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w1\nmov w8, #1                          // =0x1\nstr q0, [sp]\nand x9, x9, #0xf\nmul x8, x9, x8\nmov x9, sp\nstrb w0, [x9, x8]\nldr q0, [sp], #16\nret",
  "ll": "define <16 x i8> @test(<16 x i8> %a, i8 %bs, i32 %c) {\n  %r = insertelement <16 x i8> %a, i8 %bs, i32 %c\n  ret <16 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x i8> %a, i8 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<32 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.b[0], w0\nret",
  "giasm": "mov v0.b[0], w0\nret",
  "ll": "define <32 x i8> @test(<32 x i8> %a, i8 %bs) {\n  %r = insertelement <32 x i8> %a, i8 %bs, i32 0\n  ret <32 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <32 x i8> %a, i8 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <32 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<32 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.b[1], w0\nret",
  "giasm": "mov v0.b[1], w0\nret",
  "ll": "define <32 x i8> @test(<32 x i8> %a, i8 %bs) {\n  %r = insertelement <32 x i8> %a, i8 %bs, i32 1\n  ret <32 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <32 x i8> %a, i8 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <32 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<32 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 14,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x1, #0x1f\nmov x9, sp\nstrb w0, [x9, x8]\nldp q0, q1, [sp], #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w1\nmov x10, sp\nstp q0, q1, [sp]\nand x8, x8, #0x1f\nlsl x9, x8, #1\nsub x8, x9, x8\nstrb w0, [x10, x8]\nldp q0, q1, [sp]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define <32 x i8> @test(<32 x i8> %a, i8 %bs, i32 %c) {\n  %r = insertelement <32 x i8> %a, i8 %bs, i32 %c\n  ret <32 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <32 x i8> %a, i8 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <32 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[0], w0\nret",
  "giasm": "mov v0.h[0], w0\nret",
  "ll": "define <4 x i16> @test(<4 x i16> %a, i16 %bs) {\n  %r = insertelement <4 x i16> %a, i16 %bs, i32 0\n  ret <4 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i16> %a, i16 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[1], w0\nret",
  "giasm": "mov v0.h[1], w0\nret",
  "ll": "define <4 x i16> @test(<4 x i16> %a, i16 %bs) {\n  %r = insertelement <4 x i16> %a, i16 %bs, i32 1\n  ret <4 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i16> %a, i16 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 7,
  "gisize": 8,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x1, #1, #2\nstrh w0, [x8]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w1\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x3\nstrh w0, [x8, x9, lsl #1]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "ll": "define <4 x i16> @test(<4 x i16> %a, i16 %bs, i32 %c) {\n  %r = insertelement <4 x i16> %a, i16 %bs, i32 %c\n  ret <4 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i16> %a, i16 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[0], w0\nret",
  "giasm": "mov v0.h[0], w0\nret",
  "ll": "define <8 x i16> @test(<8 x i16> %a, i16 %bs) {\n  %r = insertelement <8 x i16> %a, i16 %bs, i32 0\n  ret <8 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i16> %a, i16 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[1], w0\nret",
  "giasm": "mov v0.h[1], w0\nret",
  "ll": "define <8 x i16> @test(<8 x i16> %a, i16 %bs) {\n  %r = insertelement <8 x i16> %a, i16 %bs, i32 1\n  ret <8 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i16> %a, i16 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x1, #1, #3\nstrh w0, [x8]\nldr q0, [sp], #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w1\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x7\nstrh w0, [x8, x9, lsl #1]\nldr q0, [sp], #16\nret",
  "ll": "define <8 x i16> @test(<8 x i16> %a, i16 %bs, i32 %c) {\n  %r = insertelement <8 x i16> %a, i16 %bs, i32 %c\n  ret <8 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i16> %a, i16 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[0], w0\nret",
  "giasm": "mov v0.h[0], w0\nret",
  "ll": "define <16 x i16> @test(<16 x i16> %a, i16 %bs) {\n  %r = insertelement <16 x i16> %a, i16 %bs, i32 0\n  ret <16 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x i16> %a, i16 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[1], w0\nret",
  "giasm": "mov v0.h[1], w0\nret",
  "ll": "define <16 x i16> @test(<16 x i16> %a, i16 %bs) {\n  %r = insertelement <16 x i16> %a, i16 %bs, i32 1\n  ret <16 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x i16> %a, i16 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 12,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x1, #0xf\nmov x9, sp\nstrh w0, [x9, x8, lsl #1]\nldp q0, q1, [sp], #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w1\nmov x9, sp\nstp q0, q1, [sp]\nand x8, x8, #0xf\nstrh w0, [x9, x8, lsl #1]\nldp q0, q1, [sp]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define <16 x i16> @test(<16 x i16> %a, i16 %bs, i32 %c) {\n  %r = insertelement <16 x i16> %a, i16 %bs, i32 %c\n  ret <16 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x i16> %a, i16 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[0], w0\nret",
  "giasm": "mov v0.s[0], w0\nret",
  "ll": "define <2 x i32> @test(<2 x i32> %a, i32 %bs) {\n  %r = insertelement <2 x i32> %a, i32 %bs, i32 0\n  ret <2 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x i32> %a, i32 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[1], w0\nret",
  "giasm": "mov v0.s[1], w0\nret",
  "ll": "define <2 x i32> @test(<2 x i32> %a, i32 %bs) {\n  %r = insertelement <2 x i32> %a, i32 %bs, i32 1\n  ret <2 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x i32> %a, i32 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 7,
  "gisize": 8,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x1, #2, #1\nstr w0, [x8]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w1\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x1\nstr w0, [x8, x9, lsl #2]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "ll": "define <2 x i32> @test(<2 x i32> %a, i32 %bs, i32 %c) {\n  %r = insertelement <2 x i32> %a, i32 %bs, i32 %c\n  ret <2 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x i32> %a, i32 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[0], w0\nret",
  "giasm": "mov v0.s[0], w0\nret",
  "ll": "define <4 x i32> @test(<4 x i32> %a, i32 %bs) {\n  %r = insertelement <4 x i32> %a, i32 %bs, i32 0\n  ret <4 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i32> %a, i32 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[1], w0\nret",
  "giasm": "mov v0.s[1], w0\nret",
  "ll": "define <4 x i32> @test(<4 x i32> %a, i32 %bs) {\n  %r = insertelement <4 x i32> %a, i32 %bs, i32 1\n  ret <4 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i32> %a, i32 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x1, #2, #2\nstr w0, [x8]\nldr q0, [sp], #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w1\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x3\nstr w0, [x8, x9, lsl #2]\nldr q0, [sp], #16\nret",
  "ll": "define <4 x i32> @test(<4 x i32> %a, i32 %bs, i32 %c) {\n  %r = insertelement <4 x i32> %a, i32 %bs, i32 %c\n  ret <4 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i32> %a, i32 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[0], w0\nret",
  "giasm": "mov v0.s[0], w0\nret",
  "ll": "define <8 x i32> @test(<8 x i32> %a, i32 %bs) {\n  %r = insertelement <8 x i32> %a, i32 %bs, i32 0\n  ret <8 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i32> %a, i32 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[1], w0\nret",
  "giasm": "mov v0.s[1], w0\nret",
  "ll": "define <8 x i32> @test(<8 x i32> %a, i32 %bs) {\n  %r = insertelement <8 x i32> %a, i32 %bs, i32 1\n  ret <8 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i32> %a, i32 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 12,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x1, #0x7\nmov x9, sp\nstr w0, [x9, x8, lsl #2]\nldp q0, q1, [sp], #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w1\nmov x9, sp\nstp q0, q1, [sp]\nand x8, x8, #0x7\nstr w0, [x9, x8, lsl #2]\nldp q0, q1, [sp]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define <8 x i32> @test(<8 x i32> %a, i32 %bs, i32 %c) {\n  %r = insertelement <8 x i32> %a, i32 %bs, i32 %c\n  ret <8 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x i32> %a, i32 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[0], x0\nret",
  "giasm": "mov v0.d[0], x0\nret",
  "ll": "define <2 x i64> @test(<2 x i64> %a, i64 %bs) {\n  %r = insertelement <2 x i64> %a, i64 %bs, i32 0\n  ret <2 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x i64> %a, i64 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[1], x0\nret",
  "giasm": "mov v0.d[1], x0\nret",
  "ll": "define <2 x i64> @test(<2 x i64> %a, i64 %bs) {\n  %r = insertelement <2 x i64> %a, i64 %bs, i32 1\n  ret <2 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x i64> %a, i64 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x1, #3, #1\nstr x0, [x8]\nldr q0, [sp], #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w1\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x1\nstr x0, [x8, x9, lsl #3]\nldr q0, [sp], #16\nret",
  "ll": "define <2 x i64> @test(<2 x i64> %a, i64 %bs, i32 %c) {\n  %r = insertelement <2 x i64> %a, i64 %bs, i32 %c\n  ret <2 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x i64> %a, i64 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[0], x0\nret",
  "giasm": "mov v0.d[0], x0\nret",
  "ll": "define <4 x i64> @test(<4 x i64> %a, i64 %bs) {\n  %r = insertelement <4 x i64> %a, i64 %bs, i32 0\n  ret <4 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i64> %a, i64 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[1], x0\nret",
  "giasm": "mov v0.d[1], x0\nret",
  "ll": "define <4 x i64> @test(<4 x i64> %a, i64 %bs) {\n  %r = insertelement <4 x i64> %a, i64 %bs, i32 1\n  ret <4 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i64> %a, i64 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 12,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x1, #0x3\nmov x9, sp\nstr x0, [x9, x8, lsl #3]\nldp q0, q1, [sp], #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w1\nmov x9, sp\nstp q0, q1, [sp]\nand x8, x8, #0x3\nstr x0, [x9, x8, lsl #3]\nldp q0, q1, [sp]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define <4 x i64> @test(<4 x i64> %a, i64 %bs, i32 %c) {\n  %r = insertelement <4 x i64> %a, i64 %bs, i32 %c\n  ret <4 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x i64> %a, i64 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.h, vl1\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i8> (<vscale x 8 x i8>, i8) (in function: test)",
  "ll": "define <vscale x 8 x i8> @test(<vscale x 8 x i8> %a, i8 %bs) {\n  %r = insertelement <vscale x 8 x i8> %a, i8 %bs, i32 0\n  ret <vscale x 8 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i8> %a, i8 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z1.h, #0, #1\nptrue p0.h\nmov z2.h, w8\ncmpeq p0.h, p0/z, z1.h, z2.h\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i8> (<vscale x 8 x i8>, i8) (in function: test)",
  "ll": "define <vscale x 8 x i8> @test(<vscale x 8 x i8> %a, i8 %bs) {\n  %r = insertelement <vscale x 8 x i8> %a, i8 %bs, i32 1\n  ret <vscale x 8 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i8> %a, i8 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z1.h, #0, #1\nmov w8, w1\nptrue p0.h\nmov z2.h, w8\ncmpeq p0.h, p0/z, z1.h, z2.h\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i8> (<vscale x 8 x i8>, i8, i32) (in function: test)",
  "ll": "define <vscale x 8 x i8> @test(<vscale x 8 x i8> %a, i8 %bs, i32 %c) {\n  %r = insertelement <vscale x 8 x i8> %a, i8 %bs, i32 %c\n  ret <vscale x 8 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i8> %a, i8 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.b, vl1\nmov z0.b, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x i8> (<vscale x 16 x i8>, i8) (in function: test)",
  "ll": "define <vscale x 16 x i8> @test(<vscale x 16 x i8> %a, i8 %bs) {\n  %r = insertelement <vscale x 16 x i8> %a, i8 %bs, i32 0\n  ret <vscale x 16 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x i8> %a, i8 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z1.b, #0, #1\nptrue p0.b\nmov z2.b, w8\ncmpeq p0.b, p0/z, z1.b, z2.b\nmov z0.b, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x i8> (<vscale x 16 x i8>, i8) (in function: test)",
  "ll": "define <vscale x 16 x i8> @test(<vscale x 16 x i8> %a, i8 %bs) {\n  %r = insertelement <vscale x 16 x i8> %a, i8 %bs, i32 1\n  ret <vscale x 16 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x i8> %a, i8 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z1.b, #0, #1\nmov w8, w1\nptrue p0.b\nmov z2.b, w8\ncmpeq p0.b, p0/z, z1.b, z2.b\nmov z0.b, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x i8> (<vscale x 16 x i8>, i8, i32) (in function: test)",
  "ll": "define <vscale x 16 x i8> @test(<vscale x 16 x i8> %a, i8 %bs, i32 %c) {\n  %r = insertelement <vscale x 16 x i8> %a, i8 %bs, i32 %c\n  ret <vscale x 16 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x i8> %a, i8 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 32 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.b, vl1\nmov z0.b, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 32 x i8> (<vscale x 32 x i8>, i8) (in function: test)",
  "ll": "define <vscale x 32 x i8> @test(<vscale x 32 x i8> %a, i8 %bs) {\n  %r = insertelement <vscale x 32 x i8> %a, i8 %bs, i32 0\n  ret <vscale x 32 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 32 x i8> %a, i8 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 32 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 32 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.b, #0, #1\nptrue p0.b\nmov z3.b, w8\ncmpeq p0.b, p0/z, z2.b, z3.b\nmov z0.b, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 32 x i8> (<vscale x 32 x i8>, i8) (in function: test)",
  "ll": "define <vscale x 32 x i8> @test(<vscale x 32 x i8> %a, i8 %bs) {\n  %r = insertelement <vscale x 32 x i8> %a, i8 %bs, i32 1\n  ret <vscale x 32 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 32 x i8> %a, i8 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 32 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 32 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 15,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w1\nstr z1, [sp, #1, mul vl]\naddvl x8, x8, #2\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nstrb w0, [x9, x8]\nldr z0, [sp]\nldr z1, [sp, #1, mul vl]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 32 x i8> (<vscale x 32 x i8>, i8, i32) (in function: test)",
  "ll": "define <vscale x 32 x i8> @test(<vscale x 32 x i8> %a, i8 %bs, i32 %c) {\n  %r = insertelement <vscale x 32 x i8> %a, i8 %bs, i32 %c\n  ret <vscale x 32 x i8> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 32 x i8> %a, i8 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 32 x i8> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.s, vl1\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i16> (<vscale x 4 x i16>, i16) (in function: test)",
  "ll": "define <vscale x 4 x i16> @test(<vscale x 4 x i16> %a, i16 %bs) {\n  %r = insertelement <vscale x 4 x i16> %a, i16 %bs, i32 0\n  ret <vscale x 4 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i16> %a, i16 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z1.s, #0, #1\nptrue p0.s\nmov z2.s, w8\ncmpeq p0.s, p0/z, z1.s, z2.s\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i16> (<vscale x 4 x i16>, i16) (in function: test)",
  "ll": "define <vscale x 4 x i16> @test(<vscale x 4 x i16> %a, i16 %bs) {\n  %r = insertelement <vscale x 4 x i16> %a, i16 %bs, i32 1\n  ret <vscale x 4 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i16> %a, i16 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z1.s, #0, #1\nmov w8, w1\nptrue p0.s\nmov z2.s, w8\ncmpeq p0.s, p0/z, z1.s, z2.s\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i16> (<vscale x 4 x i16>, i16, i32) (in function: test)",
  "ll": "define <vscale x 4 x i16> @test(<vscale x 4 x i16> %a, i16 %bs, i32 %c) {\n  %r = insertelement <vscale x 4 x i16> %a, i16 %bs, i32 %c\n  ret <vscale x 4 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i16> %a, i16 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.h, vl1\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i16> (<vscale x 8 x i16>, i16) (in function: test)",
  "ll": "define <vscale x 8 x i16> @test(<vscale x 8 x i16> %a, i16 %bs) {\n  %r = insertelement <vscale x 8 x i16> %a, i16 %bs, i32 0\n  ret <vscale x 8 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i16> %a, i16 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z1.h, #0, #1\nptrue p0.h\nmov z2.h, w8\ncmpeq p0.h, p0/z, z1.h, z2.h\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i16> (<vscale x 8 x i16>, i16) (in function: test)",
  "ll": "define <vscale x 8 x i16> @test(<vscale x 8 x i16> %a, i16 %bs) {\n  %r = insertelement <vscale x 8 x i16> %a, i16 %bs, i32 1\n  ret <vscale x 8 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i16> %a, i16 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z1.h, #0, #1\nmov w8, w1\nptrue p0.h\nmov z2.h, w8\ncmpeq p0.h, p0/z, z1.h, z2.h\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i16> (<vscale x 8 x i16>, i16, i32) (in function: test)",
  "ll": "define <vscale x 8 x i16> @test(<vscale x 8 x i16> %a, i16 %bs, i32 %c) {\n  %r = insertelement <vscale x 8 x i16> %a, i16 %bs, i32 %c\n  ret <vscale x 8 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i16> %a, i16 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.h, vl1\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x i16> (<vscale x 16 x i16>, i16) (in function: test)",
  "ll": "define <vscale x 16 x i16> @test(<vscale x 16 x i16> %a, i16 %bs) {\n  %r = insertelement <vscale x 16 x i16> %a, i16 %bs, i32 0\n  ret <vscale x 16 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x i16> %a, i16 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.h, #0, #1\nptrue p0.h\nmov z3.h, w8\ncmpeq p0.h, p0/z, z2.h, z3.h\nmov z0.h, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x i16> (<vscale x 16 x i16>, i16) (in function: test)",
  "ll": "define <vscale x 16 x i16> @test(<vscale x 16 x i16> %a, i16 %bs) {\n  %r = insertelement <vscale x 16 x i16> %a, i16 %bs, i32 1\n  ret <vscale x 16 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x i16> %a, i16 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 15,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w1\nstr z1, [sp, #1, mul vl]\naddvl x8, x8, #1\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nstrh w0, [x9, x8, lsl #1]\nldr z0, [sp]\nldr z1, [sp, #1, mul vl]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x i16> (<vscale x 16 x i16>, i16, i32) (in function: test)",
  "ll": "define <vscale x 16 x i16> @test(<vscale x 16 x i16> %a, i16 %bs, i32 %c) {\n  %r = insertelement <vscale x 16 x i16> %a, i16 %bs, i32 %c\n  ret <vscale x 16 x i16> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x i16> %a, i16 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x i16> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.d, vl1\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x i32> (<vscale x 2 x i32>, i32) (in function: test)",
  "ll": "define <vscale x 2 x i32> @test(<vscale x 2 x i32> %a, i32 %bs) {\n  %r = insertelement <vscale x 2 x i32> %a, i32 %bs, i32 0\n  ret <vscale x 2 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x i32> %a, i32 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z1.d, #0, #1\nptrue p0.d\nmov z2.d, x8\ncmpeq p0.d, p0/z, z1.d, z2.d\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x i32> (<vscale x 2 x i32>, i32) (in function: test)",
  "ll": "define <vscale x 2 x i32> @test(<vscale x 2 x i32> %a, i32 %bs) {\n  %r = insertelement <vscale x 2 x i32> %a, i32 %bs, i32 1\n  ret <vscale x 2 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x i32> %a, i32 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z1.d, #0, #1\nmov w8, w1\nptrue p0.d\nmov z2.d, x8\ncmpeq p0.d, p0/z, z1.d, z2.d\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x i32> (<vscale x 2 x i32>, i32, i32) (in function: test)",
  "ll": "define <vscale x 2 x i32> @test(<vscale x 2 x i32> %a, i32 %bs, i32 %c) {\n  %r = insertelement <vscale x 2 x i32> %a, i32 %bs, i32 %c\n  ret <vscale x 2 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x i32> %a, i32 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.s, vl1\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i32> (<vscale x 4 x i32>, i32) (in function: test)",
  "ll": "define <vscale x 4 x i32> @test(<vscale x 4 x i32> %a, i32 %bs) {\n  %r = insertelement <vscale x 4 x i32> %a, i32 %bs, i32 0\n  ret <vscale x 4 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i32> %a, i32 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z1.s, #0, #1\nptrue p0.s\nmov z2.s, w8\ncmpeq p0.s, p0/z, z1.s, z2.s\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i32> (<vscale x 4 x i32>, i32) (in function: test)",
  "ll": "define <vscale x 4 x i32> @test(<vscale x 4 x i32> %a, i32 %bs) {\n  %r = insertelement <vscale x 4 x i32> %a, i32 %bs, i32 1\n  ret <vscale x 4 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i32> %a, i32 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z1.s, #0, #1\nmov w8, w1\nptrue p0.s\nmov z2.s, w8\ncmpeq p0.s, p0/z, z1.s, z2.s\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i32> (<vscale x 4 x i32>, i32, i32) (in function: test)",
  "ll": "define <vscale x 4 x i32> @test(<vscale x 4 x i32> %a, i32 %bs, i32 %c) {\n  %r = insertelement <vscale x 4 x i32> %a, i32 %bs, i32 %c\n  ret <vscale x 4 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i32> %a, i32 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.s, vl1\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i32> (<vscale x 8 x i32>, i32) (in function: test)",
  "ll": "define <vscale x 8 x i32> @test(<vscale x 8 x i32> %a, i32 %bs) {\n  %r = insertelement <vscale x 8 x i32> %a, i32 %bs, i32 0\n  ret <vscale x 8 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i32> %a, i32 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.s, #0, #1\nptrue p0.s\nmov z3.s, w8\ncmpeq p0.s, p0/z, z2.s, z3.s\nmov z0.s, p0/m, w0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i32> (<vscale x 8 x i32>, i32) (in function: test)",
  "ll": "define <vscale x 8 x i32> @test(<vscale x 8 x i32> %a, i32 %bs) {\n  %r = insertelement <vscale x 8 x i32> %a, i32 %bs, i32 1\n  ret <vscale x 8 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i32> %a, i32 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 15,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w1\nstr z1, [sp, #1, mul vl]\ninch x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nstr w0, [x9, x8, lsl #2]\nldr z0, [sp]\nldr z1, [sp, #1, mul vl]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x i32> (<vscale x 8 x i32>, i32, i32) (in function: test)",
  "ll": "define <vscale x 8 x i32> @test(<vscale x 8 x i32> %a, i32 %bs, i32 %c) {\n  %r = insertelement <vscale x 8 x i32> %a, i32 %bs, i32 %c\n  ret <vscale x 8 x i32> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x i32> %a, i32 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x i32> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.d, vl1\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x i64> (<vscale x 2 x i64>, i64) (in function: test)",
  "ll": "define <vscale x 2 x i64> @test(<vscale x 2 x i64> %a, i64 %bs) {\n  %r = insertelement <vscale x 2 x i64> %a, i64 %bs, i32 0\n  ret <vscale x 2 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x i64> %a, i64 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z1.d, #0, #1\nptrue p0.d\nmov z2.d, x8\ncmpeq p0.d, p0/z, z1.d, z2.d\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x i64> (<vscale x 2 x i64>, i64) (in function: test)",
  "ll": "define <vscale x 2 x i64> @test(<vscale x 2 x i64> %a, i64 %bs) {\n  %r = insertelement <vscale x 2 x i64> %a, i64 %bs, i32 1\n  ret <vscale x 2 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x i64> %a, i64 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z1.d, #0, #1\nmov w8, w1\nptrue p0.d\nmov z2.d, x8\ncmpeq p0.d, p0/z, z1.d, z2.d\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x i64> (<vscale x 2 x i64>, i64, i32) (in function: test)",
  "ll": "define <vscale x 2 x i64> @test(<vscale x 2 x i64> %a, i64 %bs, i32 %c) {\n  %r = insertelement <vscale x 2 x i64> %a, i64 %bs, i32 %c\n  ret <vscale x 2 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x i64> %a, i64 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.d, vl1\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i64> (<vscale x 4 x i64>, i64) (in function: test)",
  "ll": "define <vscale x 4 x i64> @test(<vscale x 4 x i64> %a, i64 %bs) {\n  %r = insertelement <vscale x 4 x i64> %a, i64 %bs, i32 0\n  ret <vscale x 4 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i64> %a, i64 %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.d, #0, #1\nptrue p0.d\nmov z3.d, x8\ncmpeq p0.d, p0/z, z2.d, z3.d\nmov z0.d, p0/m, x0\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i64> (<vscale x 4 x i64>, i64) (in function: test)",
  "ll": "define <vscale x 4 x i64> @test(<vscale x 4 x i64> %a, i64 %bs) {\n  %r = insertelement <vscale x 4 x i64> %a, i64 %bs, i32 1\n  ret <vscale x 4 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i64> %a, i64 %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 15,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w1\nstr z1, [sp, #1, mul vl]\nincw x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nstr x0, [x9, x8, lsl #3]\nldr z0, [sp]\nldr z1, [sp, #1, mul vl]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x i64> (<vscale x 4 x i64>, i64, i32) (in function: test)",
  "ll": "define <vscale x 4 x i64> @test(<vscale x 4 x i64> %a, i64 %bs, i32 %c) {\n  %r = insertelement <vscale x 4 x i64> %a, i64 %bs, i32 %c\n  ret <vscale x 4 x i64> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x i64> %a, i64 %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x i64> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[0], v1.h[0]\nret",
  "giasm": "mov v0.h[0], v1.h[0]\nret",
  "ll": "define <4 x half> @test(<4 x half> %a, half %bs) {\n  %r = insertelement <4 x half> %a, half %bs, i32 0\n  ret <4 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <4 x half> %a, half %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[1], v1.h[0]\nret",
  "giasm": "mov v0.h[1], v1.h[0]\nret",
  "ll": "define <4 x half> @test(<4 x half> %a, half %bs) {\n  %r = insertelement <4 x half> %a, half %bs, i32 1\n  ret <4 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x half> %a, half %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 7,
  "gisize": 8,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x0, #1, #2\nstr h1, [x8]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x3\nstr h1, [x8, x9, lsl #1]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "ll": "define <4 x half> @test(<4 x half> %a, half %bs, i32 %c) {\n  %r = insertelement <4 x half> %a, half %bs, i32 %c\n  ret <4 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x half> %a, half %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[0], v1.h[0]\nret",
  "giasm": "mov v0.h[0], v1.h[0]\nret",
  "ll": "define <8 x half> @test(<8 x half> %a, half %bs) {\n  %r = insertelement <8 x half> %a, half %bs, i32 0\n  ret <8 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <8 x half> %a, half %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[1], v1.h[0]\nret",
  "giasm": "mov v0.h[1], v1.h[0]\nret",
  "ll": "define <8 x half> @test(<8 x half> %a, half %bs) {\n  %r = insertelement <8 x half> %a, half %bs, i32 1\n  ret <8 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x half> %a, half %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #1, #3\nstr h1, [x8]\nldr q0, [sp], #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x7\nstr h1, [x8, x9, lsl #1]\nldr q0, [sp], #16\nret",
  "ll": "define <8 x half> @test(<8 x half> %a, half %bs, i32 %c) {\n  %r = insertelement <8 x half> %a, half %bs, i32 %c\n  ret <8 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x half> %a, half %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[0], v2.h[0]\nret",
  "giasm": "mov v0.h[0], v2.h[0]\nret",
  "ll": "define <16 x half> @test(<16 x half> %a, half %bs) {\n  %r = insertelement <16 x half> %a, half %bs, i32 0\n  ret <16 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <16 x half> %a, half %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.h[1], v2.h[0]\nret",
  "giasm": "mov v0.h[1], v2.h[0]\nret",
  "ll": "define <16 x half> @test(<16 x half> %a, half %bs) {\n  %r = insertelement <16 x half> %a, half %bs, i32 1\n  ret <16 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x half> %a, half %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<16 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 12,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0xf\nmov x9, sp\nstr h2, [x9, x8, lsl #1]\nldp q0, q1, [sp], #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nmov x9, sp\nstp q0, q1, [sp]\nand x8, x8, #0xf\nstr h2, [x9, x8, lsl #1]\nldp q0, q1, [sp]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define <16 x half> @test(<16 x half> %a, half %bs, i32 %c) {\n  %r = insertelement <16 x half> %a, half %bs, i32 %c\n  ret <16 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <16 x half> %a, half %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <16 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[0], v1.s[0]\nret",
  "giasm": "mov v0.s[0], v1.s[0]\nret",
  "ll": "define <2 x float> @test(<2 x float> %a, float %bs) {\n  %r = insertelement <2 x float> %a, float %bs, i32 0\n  ret <2 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <2 x float> %a, float %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[1], v1.s[0]\nret",
  "giasm": "mov v0.s[1], v1.s[0]\nret",
  "ll": "define <2 x float> @test(<2 x float> %a, float %bs) {\n  %r = insertelement <2 x float> %a, float %bs, i32 1\n  ret <2 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x float> %a, float %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 7,
  "gisize": 8,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x0, #2, #1\nstr s1, [x8]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x1\nstr s1, [x8, x9, lsl #2]\nldr d0, [sp, #8]\nadd sp, sp, #16\nret",
  "ll": "define <2 x float> @test(<2 x float> %a, float %bs, i32 %c) {\n  %r = insertelement <2 x float> %a, float %bs, i32 %c\n  ret <2 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x float> %a, float %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[0], v1.s[0]\nret",
  "giasm": "mov v0.s[0], v1.s[0]\nret",
  "ll": "define <4 x float> @test(<4 x float> %a, float %bs) {\n  %r = insertelement <4 x float> %a, float %bs, i32 0\n  ret <4 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <4 x float> %a, float %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[1], v1.s[0]\nret",
  "giasm": "mov v0.s[1], v1.s[0]\nret",
  "ll": "define <4 x float> @test(<4 x float> %a, float %bs) {\n  %r = insertelement <4 x float> %a, float %bs, i32 1\n  ret <4 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x float> %a, float %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #2, #2\nstr s1, [x8]\nldr q0, [sp], #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x3\nstr s1, [x8, x9, lsl #2]\nldr q0, [sp], #16\nret",
  "ll": "define <4 x float> @test(<4 x float> %a, float %bs, i32 %c) {\n  %r = insertelement <4 x float> %a, float %bs, i32 %c\n  ret <4 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x float> %a, float %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[0], v2.s[0]\nret",
  "giasm": "mov v0.s[0], v2.s[0]\nret",
  "ll": "define <8 x float> @test(<8 x float> %a, float %bs) {\n  %r = insertelement <8 x float> %a, float %bs, i32 0\n  ret <8 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <8 x float> %a, float %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.s[1], v2.s[0]\nret",
  "giasm": "mov v0.s[1], v2.s[0]\nret",
  "ll": "define <8 x float> @test(<8 x float> %a, float %bs) {\n  %r = insertelement <8 x float> %a, float %bs, i32 1\n  ret <8 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x float> %a, float %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<8 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 12,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0x7\nmov x9, sp\nstr s2, [x9, x8, lsl #2]\nldp q0, q1, [sp], #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nmov x9, sp\nstp q0, q1, [sp]\nand x8, x8, #0x7\nstr s2, [x9, x8, lsl #2]\nldp q0, q1, [sp]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define <8 x float> @test(<8 x float> %a, float %bs, i32 %c) {\n  %r = insertelement <8 x float> %a, float %bs, i32 %c\n  ret <8 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <8 x float> %a, float %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <8 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[0], v1.d[0]\nret",
  "giasm": "mov v0.d[0], v1.d[0]\nret",
  "ll": "define <2 x double> @test(<2 x double> %a, double %bs) {\n  %r = insertelement <2 x double> %a, double %bs, i32 0\n  ret <2 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <2 x double> %a, double %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[1], v1.d[0]\nret",
  "giasm": "mov v0.d[1], v1.d[0]\nret",
  "ll": "define <2 x double> @test(<2 x double> %a, double %bs) {\n  %r = insertelement <2 x double> %a, double %bs, i32 1\n  ret <2 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x double> %a, double %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<2 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #3, #1\nstr d1, [x8]\nldr q0, [sp], #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x1\nstr d1, [x8, x9, lsl #3]\nldr q0, [sp], #16\nret",
  "ll": "define <2 x double> @test(<2 x double> %a, double %bs, i32 %c) {\n  %r = insertelement <2 x double> %a, double %bs, i32 %c\n  ret <2 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <2 x double> %a, double %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <2 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[0], v2.d[0]\nret",
  "giasm": "mov v0.d[0], v2.d[0]\nret",
  "ll": "define <4 x double> @test(<4 x double> %a, double %bs) {\n  %r = insertelement <4 x double> %a, double %bs, i32 0\n  ret <4 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <4 x double> %a, double %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov v0.d[1], v2.d[0]\nret",
  "giasm": "mov v0.d[1], v2.d[0]\nret",
  "ll": "define <4 x double> @test(<4 x double> %a, double %bs) {\n  %r = insertelement <4 x double> %a, double %bs, i32 1\n  ret <4 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x double> %a, double %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<4 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 12,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0x3\nmov x9, sp\nstr d2, [x9, x8, lsl #3]\nldp q0, q1, [sp], #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nmov x9, sp\nstp q0, q1, [sp]\nand x8, x8, #0x3\nstr d2, [x9, x8, lsl #3]\nldp q0, q1, [sp]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define <4 x double> @test(<4 x double> %a, double %bs, i32 %c) {\n  %r = insertelement <4 x double> %a, double %bs, i32 %c\n  ret <4 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <4 x double> %a, double %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <4 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, wzr\nindex z2.s, #0, #1\nptrue p0.s\nmov z3.s, w8\ncmpeq p0.s, p0/z, z2.s, z3.s\nmov z0.h, p0/m, h1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x half> (<vscale x 4 x half>, half) (in function: test)",
  "ll": "define <vscale x 4 x half> @test(<vscale x 4 x half> %a, half %bs) {\n  %r = insertelement <vscale x 4 x half> %a, half %bs, i32 0\n  ret <vscale x 4 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 4 x half> %a, half %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.s, #0, #1\nptrue p0.s\nmov z3.s, w8\ncmpeq p0.s, p0/z, z2.s, z3.s\nmov z0.h, p0/m, h1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x half> (<vscale x 4 x half>, half) (in function: test)",
  "ll": "define <vscale x 4 x half> @test(<vscale x 4 x half> %a, half %bs) {\n  %r = insertelement <vscale x 4 x half> %a, half %bs, i32 1\n  ret <vscale x 4 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x half> %a, half %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z2.s, #0, #1\nmov w8, w0\nptrue p0.s\nmov z3.s, w8\ncmpeq p0.s, p0/z, z2.s, z3.s\nmov z0.h, p0/m, h1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x half> (<vscale x 4 x half>, half, i32) (in function: test)",
  "ll": "define <vscale x 4 x half> @test(<vscale x 4 x half> %a, half %bs, i32 %c) {\n  %r = insertelement <vscale x 4 x half> %a, half %bs, i32 %c\n  ret <vscale x 4 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x half> %a, half %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.h, vl1\nmov z0.h, p0/m, z1.h\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x half> (<vscale x 8 x half>, half) (in function: test)",
  "ll": "define <vscale x 8 x half> @test(<vscale x 8 x half> %a, half %bs) {\n  %r = insertelement <vscale x 8 x half> %a, half %bs, i32 0\n  ret <vscale x 8 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 8 x half> %a, half %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.h, #0, #1\nptrue p0.h\nmov z3.h, w8\ncmpeq p0.h, p0/z, z2.h, z3.h\nmov z0.h, p0/m, h1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x half> (<vscale x 8 x half>, half) (in function: test)",
  "ll": "define <vscale x 8 x half> @test(<vscale x 8 x half> %a, half %bs) {\n  %r = insertelement <vscale x 8 x half> %a, half %bs, i32 1\n  ret <vscale x 8 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x half> %a, half %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z2.h, #0, #1\nmov w8, w0\nptrue p0.h\nmov z3.h, w8\ncmpeq p0.h, p0/z, z2.h, z3.h\nmov z0.h, p0/m, h1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x half> (<vscale x 8 x half>, half, i32) (in function: test)",
  "ll": "define <vscale x 8 x half> @test(<vscale x 8 x half> %a, half %bs, i32 %c) {\n  %r = insertelement <vscale x 8 x half> %a, half %bs, i32 %c\n  ret <vscale x 8 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x half> %a, half %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.h, vl1\nmov z0.h, p0/m, z2.h\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x half> (<vscale x 16 x half>, half) (in function: test)",
  "ll": "define <vscale x 16 x half> @test(<vscale x 16 x half> %a, half %bs) {\n  %r = insertelement <vscale x 16 x half> %a, half %bs, i32 0\n  ret <vscale x 16 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 16 x half> %a, half %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z3.h, #0, #1\nptrue p0.h\nmov z4.h, w8\ncmpeq p0.h, p0/z, z3.h, z4.h\nmov z0.h, p0/m, h2\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x half> (<vscale x 16 x half>, half) (in function: test)",
  "ll": "define <vscale x 16 x half> @test(<vscale x 16 x half> %a, half %bs) {\n  %r = insertelement <vscale x 16 x half> %a, half %bs, i32 1\n  ret <vscale x 16 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x half> %a, half %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 16 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 15,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\naddvl x8, x8, #1\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nstr h2, [x9, x8, lsl #1]\nldr z0, [sp]\nldr z1, [sp, #1, mul vl]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 16 x half> (<vscale x 16 x half>, half, i32) (in function: test)",
  "ll": "define <vscale x 16 x half> @test(<vscale x 16 x half> %a, half %bs, i32 %c) {\n  %r = insertelement <vscale x 16 x half> %a, half %bs, i32 %c\n  ret <vscale x 16 x half> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 16 x half> %a, half %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 16 x half> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov x8, xzr\nindex z2.d, #0, #1\nptrue p0.d\nmov z3.d, x8\ncmpeq p0.d, p0/z, z2.d, z3.d\nmov z0.s, p0/m, s1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x float> (<vscale x 2 x float>, float) (in function: test)",
  "ll": "define <vscale x 2 x float> @test(<vscale x 2 x float> %a, float %bs) {\n  %r = insertelement <vscale x 2 x float> %a, float %bs, i32 0\n  ret <vscale x 2 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 2 x float> %a, float %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.d, #0, #1\nptrue p0.d\nmov z3.d, x8\ncmpeq p0.d, p0/z, z2.d, z3.d\nmov z0.s, p0/m, s1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x float> (<vscale x 2 x float>, float) (in function: test)",
  "ll": "define <vscale x 2 x float> @test(<vscale x 2 x float> %a, float %bs) {\n  %r = insertelement <vscale x 2 x float> %a, float %bs, i32 1\n  ret <vscale x 2 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x float> %a, float %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z2.d, #0, #1\nmov w8, w0\nptrue p0.d\nmov z3.d, x8\ncmpeq p0.d, p0/z, z2.d, z3.d\nmov z0.s, p0/m, s1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x float> (<vscale x 2 x float>, float, i32) (in function: test)",
  "ll": "define <vscale x 2 x float> @test(<vscale x 2 x float> %a, float %bs, i32 %c) {\n  %r = insertelement <vscale x 2 x float> %a, float %bs, i32 %c\n  ret <vscale x 2 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x float> %a, float %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.s, vl1\nmov z0.s, p0/m, z1.s\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x float> (<vscale x 4 x float>, float) (in function: test)",
  "ll": "define <vscale x 4 x float> @test(<vscale x 4 x float> %a, float %bs) {\n  %r = insertelement <vscale x 4 x float> %a, float %bs, i32 0\n  ret <vscale x 4 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 4 x float> %a, float %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.s, #0, #1\nptrue p0.s\nmov z3.s, w8\ncmpeq p0.s, p0/z, z2.s, z3.s\nmov z0.s, p0/m, s1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x float> (<vscale x 4 x float>, float) (in function: test)",
  "ll": "define <vscale x 4 x float> @test(<vscale x 4 x float> %a, float %bs) {\n  %r = insertelement <vscale x 4 x float> %a, float %bs, i32 1\n  ret <vscale x 4 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x float> %a, float %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z2.s, #0, #1\nmov w8, w0\nptrue p0.s\nmov z3.s, w8\ncmpeq p0.s, p0/z, z2.s, z3.s\nmov z0.s, p0/m, s1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x float> (<vscale x 4 x float>, float, i32) (in function: test)",
  "ll": "define <vscale x 4 x float> @test(<vscale x 4 x float> %a, float %bs, i32 %c) {\n  %r = insertelement <vscale x 4 x float> %a, float %bs, i32 %c\n  ret <vscale x 4 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x float> %a, float %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.s, vl1\nmov z0.s, p0/m, z2.s\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x float> (<vscale x 8 x float>, float) (in function: test)",
  "ll": "define <vscale x 8 x float> @test(<vscale x 8 x float> %a, float %bs) {\n  %r = insertelement <vscale x 8 x float> %a, float %bs, i32 0\n  ret <vscale x 8 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 8 x float> %a, float %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z3.s, #0, #1\nptrue p0.s\nmov z4.s, w8\ncmpeq p0.s, p0/z, z3.s, z4.s\nmov z0.s, p0/m, s2\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x float> (<vscale x 8 x float>, float) (in function: test)",
  "ll": "define <vscale x 8 x float> @test(<vscale x 8 x float> %a, float %bs) {\n  %r = insertelement <vscale x 8 x float> %a, float %bs, i32 1\n  ret <vscale x 8 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x float> %a, float %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 8 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 15,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\ninch x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nstr s2, [x9, x8, lsl #2]\nldr z0, [sp]\nldr z1, [sp, #1, mul vl]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 8 x float> (<vscale x 8 x float>, float, i32) (in function: test)",
  "ll": "define <vscale x 8 x float> @test(<vscale x 8 x float> %a, float %bs, i32 %c) {\n  %r = insertelement <vscale x 8 x float> %a, float %bs, i32 %c\n  ret <vscale x 8 x float> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 8 x float> %a, float %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 8 x float> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.d, vl1\nmov z0.d, p0/m, z1.d\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x double> (<vscale x 2 x double>, double) (in function: test)",
  "ll": "define <vscale x 2 x double> @test(<vscale x 2 x double> %a, double %bs) {\n  %r = insertelement <vscale x 2 x double> %a, double %bs, i32 0\n  ret <vscale x 2 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 2 x double> %a, double %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z2.d, #0, #1\nptrue p0.d\nmov z3.d, x8\ncmpeq p0.d, p0/z, z2.d, z3.d\nmov z0.d, p0/m, d1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x double> (<vscale x 2 x double>, double) (in function: test)",
  "ll": "define <vscale x 2 x double> @test(<vscale x 2 x double> %a, double %bs) {\n  %r = insertelement <vscale x 2 x double> %a, double %bs, i32 1\n  ret <vscale x 2 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x double> %a, double %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 2 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "index z2.d, #0, #1\nmov w8, w0\nptrue p0.d\nmov z3.d, x8\ncmpeq p0.d, p0/z, z2.d, z3.d\nmov z0.d, p0/m, d1\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 2 x double> (<vscale x 2 x double>, double, i32) (in function: test)",
  "ll": "define <vscale x 2 x double> @test(<vscale x 2 x double> %a, double %bs, i32 %c) {\n  %r = insertelement <vscale x 2 x double> %a, double %bs, i32 %c\n  ret <vscale x 2 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 2 x double> %a, double %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 2 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ptrue p0.d, vl1\nmov z0.d, p0/m, z2.d\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x double> (<vscale x 4 x double>, double) (in function: test)",
  "ll": "define <vscale x 4 x double> @test(<vscale x 4 x double> %a, double %bs) {\n  %r = insertelement <vscale x 4 x double> %a, double %bs, i32 0\n  ret <vscale x 4 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = insertelement <vscale x 4 x double> %a, double %bs, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, #1                          // =0x1\nindex z3.d, #0, #1\nptrue p0.d\nmov z4.d, x8\ncmpeq p0.d, p0/z, z3.d, z4.d\nmov z0.d, p0/m, d2\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x double> (<vscale x 4 x double>, double) (in function: test)",
  "ll": "define <vscale x 4 x double> @test(<vscale x 4 x double> %a, double %bs) {\n  %r = insertelement <vscale x 4 x double> %a, double %bs, i32 1\n  ret <vscale x 4 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x double> %a, double %bs, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x double> %r"
 },
 {
  "instr": "insertelement",
  "ty": "<vscale x 4 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 15,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\nincw x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nstr d2, [x9, x8, lsl #3]\nldr z0, [sp]\nldr z1, [sp, #1, mul vl]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: <vscale x 4 x double> (<vscale x 4 x double>, double, i32) (in function: test)",
  "ll": "define <vscale x 4 x double> @test(<vscale x 4 x double> %a, double %bs, i32 %c) {\n  %r = insertelement <vscale x 4 x double> %a, double %bs, i32 %c\n  ret <vscale x 4 x double> %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = insertelement <vscale x 4 x double> %a, double %bs, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret <vscale x 4 x double> %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[0]\nret",
  "giasm": "umov w0, v0.b[0]\nret",
  "ll": "define i8 @test(<8 x i8> %a) {\n  %r = extractelement <8 x i8> %a, i32 0\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i8> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[1]\nret",
  "giasm": "umov w0, v0.b[1]\nret",
  "ll": "define i8 @test(<8 x i8> %a) {\n  %r = extractelement <8 x i8> %a, i32 1\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i8> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 9,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfxil x8, x0, #0, #3\nldrb w0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x7\nlsl x10, x9, #1\nsub x9, x10, x9\nldrb w0, [x8, x9]\nadd sp, sp, #16\nret",
  "ll": "define i8 @test(<8 x i8> %a, i32 %c) {\n  %r = extractelement <8 x i8> %a, i32 %c\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i8> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[0]\nret",
  "giasm": "umov w0, v0.b[0]\nret",
  "ll": "define i8 @test(<16 x i8> %a) {\n  %r = extractelement <16 x i8> %a, i32 0\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x i8> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[1]\nret",
  "giasm": "umov w0, v0.b[1]\nret",
  "ll": "define i8 @test(<16 x i8> %a) {\n  %r = extractelement <16 x i8> %a, i32 1\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x i8> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 9,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfxil x8, x0, #0, #4\nldrb w0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0xf\nlsl x10, x9, #1\nsub x9, x10, x9\nldrb w0, [x8, x9]\nadd sp, sp, #16\nret",
  "ll": "define i8 @test(<16 x i8> %a, i32 %c) {\n  %r = extractelement <16 x i8> %a, i32 %c\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x i8> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<32 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[0]\nret",
  "giasm": "umov w0, v0.b[0]\nret",
  "ll": "define i8 @test(<32 x i8> %a) {\n  %r = extractelement <32 x i8> %a, i32 0\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <32 x i8> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<32 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[1]\nret",
  "giasm": "umov w0, v0.b[1]\nret",
  "ll": "define i8 @test(<32 x i8> %a) {\n  %r = extractelement <32 x i8> %a, i32 1\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <32 x i8> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<32 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 13,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0x1f\nmov x9, sp\nldrb w0, [x9, x8]\nadd sp, sp, #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nstp q0, q1, [sp]\nmov x10, sp\nand x8, x8, #0x1f\nlsl x9, x8, #1\nsub x8, x9, x8\nldrb w0, [x10, x8]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define i8 @test(<32 x i8> %a, i32 %c) {\n  %r = extractelement <32 x i8> %a, i32 %c\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <32 x i8> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[0]\nret",
  "giasm": "umov w0, v0.h[0]\nret",
  "ll": "define i16 @test(<4 x i16> %a) {\n  %r = extractelement <4 x i16> %a, i32 0\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i16> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[1]\nret",
  "giasm": "umov w0, v0.h[1]\nret",
  "ll": "define i16 @test(<4 x i16> %a) {\n  %r = extractelement <4 x i16> %a, i32 1\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i16> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x0, #1, #2\nldrh w0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x3\nldrh w0, [x8, x9, lsl #1]\nadd sp, sp, #16\nret",
  "ll": "define i16 @test(<4 x i16> %a, i32 %c) {\n  %r = extractelement <4 x i16> %a, i32 %c\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i16> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[0]\nret",
  "giasm": "umov w0, v0.h[0]\nret",
  "ll": "define i16 @test(<8 x i16> %a) {\n  %r = extractelement <8 x i16> %a, i32 0\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i16> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[1]\nret",
  "giasm": "umov w0, v0.h[1]\nret",
  "ll": "define i16 @test(<8 x i16> %a) {\n  %r = extractelement <8 x i16> %a, i32 1\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i16> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #1, #3\nldrh w0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x7\nldrh w0, [x8, x9, lsl #1]\nadd sp, sp, #16\nret",
  "ll": "define i16 @test(<8 x i16> %a, i32 %c) {\n  %r = extractelement <8 x i16> %a, i32 %c\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i16> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[0]\nret",
  "giasm": "umov w0, v0.h[0]\nret",
  "ll": "define i16 @test(<16 x i16> %a) {\n  %r = extractelement <16 x i16> %a, i32 0\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x i16> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[1]\nret",
  "giasm": "umov w0, v0.h[1]\nret",
  "ll": "define i16 @test(<16 x i16> %a) {\n  %r = extractelement <16 x i16> %a, i32 1\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x i16> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 11,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0xf\nmov x9, sp\nldrh w0, [x9, x8, lsl #1]\nadd sp, sp, #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nstp q0, q1, [sp]\nmov x9, sp\nand x8, x8, #0xf\nldrh w0, [x9, x8, lsl #1]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define i16 @test(<16 x i16> %a, i32 %c) {\n  %r = extractelement <16 x i16> %a, i32 %c\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x i16> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "fmov w0, s0\nret",
  "ll": "define i32 @test(<2 x i32> %a) {\n  %r = extractelement <2 x i32> %a, i32 0\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x i32> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 2,
  "extrasize": 0,
  "asm": "mov w0, v0.s[1]\nret",
  "giasm": "mov s0, v0.s[1]\nfmov w0, s0\nret",
  "ll": "define i32 @test(<2 x i32> %a) {\n  %r = extractelement <2 x i32> %a, i32 1\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x i32> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x0, #2, #1\nldr w0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x1\nldr w0, [x8, x9, lsl #2]\nadd sp, sp, #16\nret",
  "ll": "define i32 @test(<2 x i32> %a, i32 %c) {\n  %r = extractelement <2 x i32> %a, i32 %c\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x i32> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "fmov w0, s0\nret",
  "ll": "define i32 @test(<4 x i32> %a) {\n  %r = extractelement <4 x i32> %a, i32 0\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i32> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 2,
  "extrasize": 0,
  "asm": "mov w0, v0.s[1]\nret",
  "giasm": "mov s0, v0.s[1]\nfmov w0, s0\nret",
  "ll": "define i32 @test(<4 x i32> %a) {\n  %r = extractelement <4 x i32> %a, i32 1\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i32> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #2, #2\nldr w0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x3\nldr w0, [x8, x9, lsl #2]\nadd sp, sp, #16\nret",
  "ll": "define i32 @test(<4 x i32> %a, i32 %c) {\n  %r = extractelement <4 x i32> %a, i32 %c\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i32> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "fmov w0, s0\nret",
  "ll": "define i32 @test(<8 x i32> %a) {\n  %r = extractelement <8 x i32> %a, i32 0\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i32> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 2,
  "extrasize": 0,
  "asm": "mov w0, v0.s[1]\nret",
  "giasm": "mov s0, v0.s[1]\nfmov w0, s0\nret",
  "ll": "define i32 @test(<8 x i32> %a) {\n  %r = extractelement <8 x i32> %a, i32 1\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i32> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 11,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0x7\nmov x9, sp\nldr w0, [x9, x8, lsl #2]\nadd sp, sp, #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nstp q0, q1, [sp]\nmov x9, sp\nand x8, x8, #0x7\nldr w0, [x9, x8, lsl #2]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define i32 @test(<8 x i32> %a, i32 %c) {\n  %r = extractelement <8 x i32> %a, i32 %c\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x i32> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "fmov x0, d0\nret",
  "giasm": "fmov x0, d0\nret",
  "ll": "define i64 @test(<2 x i64> %a) {\n  %r = extractelement <2 x i64> %a, i32 0\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x i64> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 2,
  "extrasize": 0,
  "asm": "mov x0, v0.d[1]\nret",
  "giasm": "mov d0, v0.d[1]\nfmov x0, d0\nret",
  "ll": "define i64 @test(<2 x i64> %a) {\n  %r = extractelement <2 x i64> %a, i32 1\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x i64> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #3, #1\nldr x0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x1\nldr x0, [x8, x9, lsl #3]\nadd sp, sp, #16\nret",
  "ll": "define i64 @test(<2 x i64> %a, i32 %c) {\n  %r = extractelement <2 x i64> %a, i32 %c\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x i64> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "fmov x0, d0\nret",
  "giasm": "fmov x0, d0\nret",
  "ll": "define i64 @test(<4 x i64> %a) {\n  %r = extractelement <4 x i64> %a, i32 0\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i64> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 2,
  "extrasize": 0,
  "asm": "mov x0, v0.d[1]\nret",
  "giasm": "mov d0, v0.d[1]\nfmov x0, d0\nret",
  "ll": "define i64 @test(<4 x i64> %a) {\n  %r = extractelement <4 x i64> %a, i32 1\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i64> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 11,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0x3\nmov x9, sp\nldr x0, [x9, x8, lsl #3]\nadd sp, sp, #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nstp q0, q1, [sp]\nmov x9, sp\nand x8, x8, #0x3\nldr x0, [x9, x8, lsl #3]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define i64 @test(<4 x i64> %a, i32 %c) {\n  %r = extractelement <4 x i64> %a, i32 %c\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x i64> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 8 x i8>) (in function: test)",
  "ll": "define i8 @test(<vscale x 8 x i8> %a) {\n  %r = extractelement <vscale x 8 x i8> %a, i32 0\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i8> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 8 x i8>) (in function: test)",
  "ll": "define i8 @test(<vscale x 8 x i8> %a) {\n  %r = extractelement <vscale x 8 x i8> %a, i32 1\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i8> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.h, xzr, x8\nlastb w0, p0, z0.h\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 8 x i8>, i32) (in function: test)",
  "ll": "define i8 @test(<vscale x 8 x i8> %a, i32 %c) {\n  %r = extractelement <vscale x 8 x i8> %a, i32 %c\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i8> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 16 x i8>) (in function: test)",
  "ll": "define i8 @test(<vscale x 16 x i8> %a) {\n  %r = extractelement <vscale x 16 x i8> %a, i32 0\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x i8> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 16 x i8>) (in function: test)",
  "ll": "define i8 @test(<vscale x 16 x i8> %a) {\n  %r = extractelement <vscale x 16 x i8> %a, i32 1\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x i8> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.b, xzr, x8\nlastb w0, p0, z0.b\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 16 x i8>, i32) (in function: test)",
  "ll": "define i8 @test(<vscale x 16 x i8> %a, i32 %c) {\n  %r = extractelement <vscale x 16 x i8> %a, i32 %c\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x i8> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 32 x i8>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 32 x i8>) (in function: test)",
  "ll": "define i8 @test(<vscale x 32 x i8> %a) {\n  %r = extractelement <vscale x 32 x i8> %a, i32 0\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 32 x i8> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 32 x i8>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "umov w0, v0.b[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 32 x i8>) (in function: test)",
  "ll": "define i8 @test(<vscale x 32 x i8> %a) {\n  %r = extractelement <vscale x 32 x i8> %a, i32 1\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 32 x i8> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 32 x i8>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 13,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\naddvl x8, x8, #2\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nldrb w0, [x9, x8]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: i8 (<vscale x 32 x i8>, i32) (in function: test)",
  "ll": "define i8 @test(<vscale x 32 x i8> %a, i32 %c) {\n  %r = extractelement <vscale x 32 x i8> %a, i32 %c\n  ret i8 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 32 x i8> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i8 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 4 x i16>) (in function: test)",
  "ll": "define i16 @test(<vscale x 4 x i16> %a) {\n  %r = extractelement <vscale x 4 x i16> %a, i32 0\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i16> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w0, v0.s[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 4 x i16>) (in function: test)",
  "ll": "define i16 @test(<vscale x 4 x i16> %a) {\n  %r = extractelement <vscale x 4 x i16> %a, i32 1\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i16> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.s, xzr, x8\nlastb w0, p0, z0.s\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 4 x i16>, i32) (in function: test)",
  "ll": "define i16 @test(<vscale x 4 x i16> %a, i32 %c) {\n  %r = extractelement <vscale x 4 x i16> %a, i32 %c\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i16> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 8 x i16>) (in function: test)",
  "ll": "define i16 @test(<vscale x 8 x i16> %a) {\n  %r = extractelement <vscale x 8 x i16> %a, i32 0\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i16> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 8 x i16>) (in function: test)",
  "ll": "define i16 @test(<vscale x 8 x i16> %a) {\n  %r = extractelement <vscale x 8 x i16> %a, i32 1\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i16> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.h, xzr, x8\nlastb w0, p0, z0.h\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 8 x i16>, i32) (in function: test)",
  "ll": "define i16 @test(<vscale x 8 x i16> %a, i32 %c) {\n  %r = extractelement <vscale x 8 x i16> %a, i32 %c\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i16> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x i16>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 16 x i16>) (in function: test)",
  "ll": "define i16 @test(<vscale x 16 x i16> %a) {\n  %r = extractelement <vscale x 16 x i16> %a, i32 0\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x i16> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x i16>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "umov w0, v0.h[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 16 x i16>) (in function: test)",
  "ll": "define i16 @test(<vscale x 16 x i16> %a) {\n  %r = extractelement <vscale x 16 x i16> %a, i32 1\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x i16> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x i16>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 13,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\naddvl x8, x8, #1\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nldrh w0, [x9, x8, lsl #1]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: i16 (<vscale x 16 x i16>, i32) (in function: test)",
  "ll": "define i16 @test(<vscale x 16 x i16> %a, i32 %c) {\n  %r = extractelement <vscale x 16 x i16> %a, i32 %c\n  ret i16 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x i16> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i16 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 2 x i32>) (in function: test)",
  "ll": "define i32 @test(<vscale x 2 x i32> %a) {\n  %r = extractelement <vscale x 2 x i32> %a, i32 0\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x i32> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w0, v0.s[2]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 2 x i32>) (in function: test)",
  "ll": "define i32 @test(<vscale x 2 x i32> %a) {\n  %r = extractelement <vscale x 2 x i32> %a, i32 1\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x i32> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.d, xzr, x8\nlastb x0, p0, z0.d\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 2 x i32>, i32) (in function: test)",
  "ll": "define i32 @test(<vscale x 2 x i32> %a, i32 %c) {\n  %r = extractelement <vscale x 2 x i32> %a, i32 %c\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x i32> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 4 x i32>) (in function: test)",
  "ll": "define i32 @test(<vscale x 4 x i32> %a) {\n  %r = extractelement <vscale x 4 x i32> %a, i32 0\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i32> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w0, v0.s[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 4 x i32>) (in function: test)",
  "ll": "define i32 @test(<vscale x 4 x i32> %a) {\n  %r = extractelement <vscale x 4 x i32> %a, i32 1\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i32> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.s, xzr, x8\nlastb w0, p0, z0.s\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 4 x i32>, i32) (in function: test)",
  "ll": "define i32 @test(<vscale x 4 x i32> %a, i32 %c) {\n  %r = extractelement <vscale x 4 x i32> %a, i32 %c\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i32> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i32>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov w0, s0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 8 x i32>) (in function: test)",
  "ll": "define i32 @test(<vscale x 8 x i32> %a) {\n  %r = extractelement <vscale x 8 x i32> %a, i32 0\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i32> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i32>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w0, v0.s[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 8 x i32>) (in function: test)",
  "ll": "define i32 @test(<vscale x 8 x i32> %a) {\n  %r = extractelement <vscale x 8 x i32> %a, i32 1\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i32> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x i32>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 13,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\ninch x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nldr w0, [x9, x8, lsl #2]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: i32 (<vscale x 8 x i32>, i32) (in function: test)",
  "ll": "define i32 @test(<vscale x 8 x i32> %a, i32 %c) {\n  %r = extractelement <vscale x 8 x i32> %a, i32 %c\n  ret i32 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x i32> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i32 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov x0, d0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i64 (<vscale x 2 x i64>) (in function: test)",
  "ll": "define i64 @test(<vscale x 2 x i64> %a) {\n  %r = extractelement <vscale x 2 x i64> %a, i32 0\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x i64> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov x0, v0.d[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i64 (<vscale x 2 x i64>) (in function: test)",
  "ll": "define i64 @test(<vscale x 2 x i64> %a) {\n  %r = extractelement <vscale x 2 x i64> %a, i32 1\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x i64> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.d, xzr, x8\nlastb x0, p0, z0.d\nret",
  "giasm": "LLVM ERROR: unable to lower function: i64 (<vscale x 2 x i64>, i32) (in function: test)",
  "ll": "define i64 @test(<vscale x 2 x i64> %a, i32 %c) {\n  %r = extractelement <vscale x 2 x i64> %a, i32 %c\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x i64> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i64>",
  "variant": "vecop0",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "fmov x0, d0\nret",
  "giasm": "LLVM ERROR: unable to lower function: i64 (<vscale x 4 x i64>) (in function: test)",
  "ll": "define i64 @test(<vscale x 4 x i64> %a) {\n  %r = extractelement <vscale x 4 x i64> %a, i32 0\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i64> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i64>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov x0, v0.d[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: i64 (<vscale x 4 x i64>) (in function: test)",
  "ll": "define i64 @test(<vscale x 4 x i64> %a) {\n  %r = extractelement <vscale x 4 x i64> %a, i32 1\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i64> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x i64>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 13,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\nincw x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nldr x0, [x9, x8, lsl #3]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: i64 (<vscale x 4 x i64>, i32) (in function: test)",
  "ll": "define i64 @test(<vscale x 4 x i64> %a, i32 %c) {\n  %r = extractelement <vscale x 4 x i64> %a, i32 %c\n  ret i64 %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x i64> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret i64 %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define half @test(<4 x half> %a) {\n  %r = extractelement <4 x half> %a, i32 0\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <4 x half> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov h0, v0.h[1]\nret",
  "giasm": "mov h0, v0.h[1]\nret",
  "ll": "define half @test(<4 x half> %a) {\n  %r = extractelement <4 x half> %a, i32 1\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x half> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x0, #1, #2\nldr h0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x3\nldr h0, [x8, x9, lsl #1]\nadd sp, sp, #16\nret",
  "ll": "define half @test(<4 x half> %a, i32 %c) {\n  %r = extractelement <4 x half> %a, i32 %c\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x half> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define half @test(<8 x half> %a) {\n  %r = extractelement <8 x half> %a, i32 0\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <8 x half> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov h0, v0.h[1]\nret",
  "giasm": "mov h0, v0.h[1]\nret",
  "ll": "define half @test(<8 x half> %a) {\n  %r = extractelement <8 x half> %a, i32 1\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x half> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #1, #3\nldr h0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x7\nldr h0, [x8, x9, lsl #1]\nadd sp, sp, #16\nret",
  "ll": "define half @test(<8 x half> %a, i32 %c) {\n  %r = extractelement <8 x half> %a, i32 %c\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x half> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define half @test(<16 x half> %a) {\n  %r = extractelement <16 x half> %a, i32 0\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <16 x half> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov h0, v0.h[1]\nret",
  "giasm": "mov h0, v0.h[1]\nret",
  "ll": "define half @test(<16 x half> %a) {\n  %r = extractelement <16 x half> %a, i32 1\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x half> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<16 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 11,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0xf\nmov x9, sp\nldr h0, [x9, x8, lsl #1]\nadd sp, sp, #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nstp q0, q1, [sp]\nmov x9, sp\nand x8, x8, #0xf\nldr h0, [x9, x8, lsl #1]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define half @test(<16 x half> %a, i32 %c) {\n  %r = extractelement <16 x half> %a, i32 %c\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <16 x half> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define float @test(<2 x float> %a) {\n  %r = extractelement <2 x float> %a, i32 0\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <2 x float> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov s0, v0.s[1]\nret",
  "giasm": "mov s0, v0.s[1]\nret",
  "ll": "define float @test(<2 x float> %a) {\n  %r = extractelement <2 x float> %a, i32 1\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x float> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nadd x8, sp, #8\nstr d0, [sp, #8]\nbfi x8, x0, #2, #1\nldr s0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nadd x8, sp, #8\nstr d0, [sp, #8]\nand x9, x9, #0x1\nldr s0, [x8, x9, lsl #2]\nadd sp, sp, #16\nret",
  "ll": "define float @test(<2 x float> %a, i32 %c) {\n  %r = extractelement <2 x float> %a, i32 %c\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x float> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define float @test(<4 x float> %a) {\n  %r = extractelement <4 x float> %a, i32 0\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <4 x float> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov s0, v0.s[1]\nret",
  "giasm": "mov s0, v0.s[1]\nret",
  "ll": "define float @test(<4 x float> %a) {\n  %r = extractelement <4 x float> %a, i32 1\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x float> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #2, #2\nldr s0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x3\nldr s0, [x8, x9, lsl #2]\nadd sp, sp, #16\nret",
  "ll": "define float @test(<4 x float> %a, i32 %c) {\n  %r = extractelement <4 x float> %a, i32 %c\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x float> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define float @test(<8 x float> %a) {\n  %r = extractelement <8 x float> %a, i32 0\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <8 x float> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov s0, v0.s[1]\nret",
  "giasm": "mov s0, v0.s[1]\nret",
  "ll": "define float @test(<8 x float> %a) {\n  %r = extractelement <8 x float> %a, i32 1\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x float> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<8 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 11,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0x7\nmov x9, sp\nldr s0, [x9, x8, lsl #2]\nadd sp, sp, #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nstp q0, q1, [sp]\nmov x9, sp\nand x8, x8, #0x7\nldr s0, [x9, x8, lsl #2]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define float @test(<8 x float> %a, i32 %c) {\n  %r = extractelement <8 x float> %a, i32 %c\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <8 x float> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define double @test(<2 x double> %a) {\n  %r = extractelement <2 x double> %a, i32 0\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <2 x double> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov d0, v0.d[1]\nret",
  "giasm": "mov d0, v0.d[1]\nret",
  "ll": "define double @test(<2 x double> %a) {\n  %r = extractelement <2 x double> %a, i32 1\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x double> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<2 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 6,
  "gisize": 7,
  "extrasize": 0,
  "asm": "sub sp, sp, #16\nmov x8, sp\nstr q0, [sp]\nbfi x8, x0, #3, #1\nldr d0, [x8]\nadd sp, sp, #16\nret",
  "giasm": "sub sp, sp, #16\nmov w9, w0\nmov x8, sp\nstr q0, [sp]\nand x9, x9, #0x1\nldr d0, [x8, x9, lsl #3]\nadd sp, sp, #16\nret",
  "ll": "define double @test(<2 x double> %a, i32 %c) {\n  %r = extractelement <2 x double> %a, i32 %c\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <2 x double> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": 0,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "ret",
  "ll": "define double @test(<4 x double> %a) {\n  %r = extractelement <4 x double> %a, i32 0\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <4 x double> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": 1,
  "extrasize": 0,
  "asm": "mov d0, v0.d[1]\nret",
  "giasm": "mov d0, v0.d[1]\nret",
  "ll": "define double @test(<4 x double> %a) {\n  %r = extractelement <4 x double> %a, i32 1\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x double> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<4 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 5,
  "gisize": 11,
  "extrasize": 0,
  "asm": "stp q0, q1, [sp, #-32]!\nand x8, x0, #0x3\nmov x9, sp\nldr d0, [x9, x8, lsl #3]\nadd sp, sp, #32\nret",
  "giasm": "stp x29, x30, [sp, #-16]!           // 16-byte Folded Spill\nsub x9, sp, #48\nmov x29, sp\nand sp, x9, #0xffffffffffffffe0\nmov w8, w0\nstp q0, q1, [sp]\nmov x9, sp\nand x8, x8, #0x3\nldr d0, [x9, x8, lsl #3]\nmov sp, x29\nldp x29, x30, [sp], #16             // 16-byte Folded Reload\nret",
  "ll": "define double @test(<4 x double> %a, i32 %c) {\n  %r = extractelement <4 x double> %a, i32 %c\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <4 x double> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 4 x half>) (in function: test)",
  "ll": "define half @test(<vscale x 4 x half> %a) {\n  %r = extractelement <vscale x 4 x half> %a, i32 0\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 4 x half> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.s, z0.s[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 4 x half>) (in function: test)",
  "ll": "define half @test(<vscale x 4 x half> %a) {\n  %r = extractelement <vscale x 4 x half> %a, i32 1\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x half> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.s, xzr, x8\nlastb h0, p0, z0.h\nret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 4 x half>, i32) (in function: test)",
  "ll": "define half @test(<vscale x 4 x half> %a, i32 %c) {\n  %r = extractelement <vscale x 4 x half> %a, i32 %c\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x half> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 8 x half>) (in function: test)",
  "ll": "define half @test(<vscale x 8 x half> %a) {\n  %r = extractelement <vscale x 8 x half> %a, i32 0\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 8 x half> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.h, z0.h[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 8 x half>) (in function: test)",
  "ll": "define half @test(<vscale x 8 x half> %a) {\n  %r = extractelement <vscale x 8 x half> %a, i32 1\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x half> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.h, xzr, x8\nlastb h0, p0, z0.h\nret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 8 x half>, i32) (in function: test)",
  "ll": "define half @test(<vscale x 8 x half> %a, i32 %c) {\n  %r = extractelement <vscale x 8 x half> %a, i32 %c\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x half> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x half>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 16 x half>) (in function: test)",
  "ll": "define half @test(<vscale x 16 x half> %a) {\n  %r = extractelement <vscale x 16 x half> %a, i32 0\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 16 x half> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x half>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.h, z0.h[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 16 x half>) (in function: test)",
  "ll": "define half @test(<vscale x 16 x half> %a) {\n  %r = extractelement <vscale x 16 x half> %a, i32 1\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x half> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 16 x half>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 13,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\naddvl x8, x8, #1\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nldr h0, [x9, x8, lsl #1]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: half (<vscale x 16 x half>, i32) (in function: test)",
  "ll": "define half @test(<vscale x 16 x half> %a, i32 %c) {\n  %r = extractelement <vscale x 16 x half> %a, i32 %c\n  ret half %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 16 x half> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret half %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 2 x float>) (in function: test)",
  "ll": "define float @test(<vscale x 2 x float> %a) {\n  %r = extractelement <vscale x 2 x float> %a, i32 0\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 2 x float> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.d, z0.d[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 2 x float>) (in function: test)",
  "ll": "define float @test(<vscale x 2 x float> %a) {\n  %r = extractelement <vscale x 2 x float> %a, i32 1\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x float> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.d, xzr, x8\nlastb s0, p0, z0.s\nret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 2 x float>, i32) (in function: test)",
  "ll": "define float @test(<vscale x 2 x float> %a, i32 %c) {\n  %r = extractelement <vscale x 2 x float> %a, i32 %c\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x float> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 4 x float>) (in function: test)",
  "ll": "define float @test(<vscale x 4 x float> %a) {\n  %r = extractelement <vscale x 4 x float> %a, i32 0\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 4 x float> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.s, z0.s[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 4 x float>) (in function: test)",
  "ll": "define float @test(<vscale x 4 x float> %a) {\n  %r = extractelement <vscale x 4 x float> %a, i32 1\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x float> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.s, xzr, x8\nlastb s0, p0, z0.s\nret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 4 x float>, i32) (in function: test)",
  "ll": "define float @test(<vscale x 4 x float> %a, i32 %c) {\n  %r = extractelement <vscale x 4 x float> %a, i32 %c\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x float> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x float>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 8 x float>) (in function: test)",
  "ll": "define float @test(<vscale x 8 x float> %a) {\n  %r = extractelement <vscale x 8 x float> %a, i32 0\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 8 x float> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x float>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.s, z0.s[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 8 x float>) (in function: test)",
  "ll": "define float @test(<vscale x 8 x float> %a) {\n  %r = extractelement <vscale x 8 x float> %a, i32 1\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x float> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 8 x float>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 13,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\ninch x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nldr s0, [x9, x8, lsl #2]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: float (<vscale x 8 x float>, i32) (in function: test)",
  "ll": "define float @test(<vscale x 8 x float> %a, i32 %c) {\n  %r = extractelement <vscale x 8 x float> %a, i32 %c\n  ret float %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 8 x float> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret float %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: double (<vscale x 2 x double>) (in function: test)",
  "ll": "define double @test(<vscale x 2 x double> %a) {\n  %r = extractelement <vscale x 2 x double> %a, i32 0\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 2 x double> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.d, z0.d[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: double (<vscale x 2 x double>) (in function: test)",
  "ll": "define double @test(<vscale x 2 x double> %a) {\n  %r = extractelement <vscale x 2 x double> %a, i32 1\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x double> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 2 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 3,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov w8, w0\nwhilels p0.d, xzr, x8\nlastb d0, p0, z0.d\nret",
  "giasm": "LLVM ERROR: unable to lower function: double (<vscale x 2 x double>, i32) (in function: test)",
  "ll": "define double @test(<vscale x 2 x double> %a, i32 %c) {\n  %r = extractelement <vscale x 2 x double> %a, i32 %c\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 2 x double> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x double>",
  "variant": "vecop0",
  "codesize": 0,
  "thru": 0,
  "lat": 0,
  "sizelat": 0,
  "size": 0,
  "gisize": -1,
  "extrasize": 0,
  "asm": "ret",
  "giasm": "LLVM ERROR: unable to lower function: double (<vscale x 4 x double>) (in function: test)",
  "ll": "define double @test(<vscale x 4 x double> %a) {\n  %r = extractelement <vscale x 4 x double> %a, i32 0\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 0 for instruction:   %r = extractelement <vscale x 4 x double> %a, i32 0\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x double>",
  "variant": "vecop1",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 1,
  "gisize": -1,
  "extrasize": 0,
  "asm": "mov z0.d, z0.d[1]\nret",
  "giasm": "LLVM ERROR: unable to lower function: double (<vscale x 4 x double>) (in function: test)",
  "ll": "define double @test(<vscale x 4 x double> %a) {\n  %r = extractelement <vscale x 4 x double> %a, i32 1\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x double> %a, i32 1\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 },
 {
  "instr": "extractelement",
  "ty": "<vscale x 4 x double>",
  "variant": "vecopvar",
  "codesize": 1,
  "thru": 2,
  "lat": 2,
  "sizelat": 2,
  "size": 13,
  "gisize": -1,
  "extrasize": 0,
  "asm": "str x29, [sp, #-16]!                // 8-byte Folded Spill\naddvl sp, sp, #-2\nmov x8, #-1                         // =0xffffffffffffffff\nmov w9, w0\nstr z1, [sp, #1, mul vl]\nincw x8\nstr z0, [sp]\ncmp x9, x8\ncsel x8, x9, x8, lo\nmov x9, sp\nldr d0, [x9, x8, lsl #3]\naddvl sp, sp, #2\nldr x29, [sp], #16                  // 8-byte Folded Reload\nret",
  "giasm": "LLVM ERROR: unable to lower function: double (<vscale x 4 x double>, i32) (in function: test)",
  "ll": "define double @test(<vscale x 4 x double> %a, i32 %c) {\n  %r = extractelement <vscale x 4 x double> %a, i32 %c\n  ret double %r\n}",
  "costoutput": "Printing analysis 'Cost Model Analysis' for function 'test':\nCost Model: Found an estimated cost of 1 for instruction:   %r = extractelement <vscale x 4 x double> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 }
]