data-vec.json

[
 {
  "instr": "insertelement",
  "ty": "<8 x i8>",
  "variant": "vecop0",
  "codesize": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": "<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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": "extractelement",
  "ty": "<8 x i8>",
  "variant": "vecop0",
  "codesize": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": "<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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 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": 2,
  "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 2 for instruction:   %r = extractelement <4 x double> %a, i32 %c\nCost Model: Found an estimated cost of 1 for instruction:   ret double %r"
 }
]