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

#ifndef SkSplicer_generated_DEFINED
#define SkSplicer_generated_DEFINED

// This file is generated semi-automatically with this command:
//   $ src/splicer/build_stages.py > src/splicer/SkSplicer_generated.h

#if defined(__aarch64__)

static const unsigned int kSplice_clear[] = {
    0x6f00e400,                                 //  movi          v0.2d, #0x0
    0x6f00e401,                                 //  movi          v1.2d, #0x0
    0x6f00e402,                                 //  movi          v2.2d, #0x0
    0x6f00e403,                                 //  movi          v3.2d, #0x0
};
static const unsigned int kSplice_plus[] = {
    0x4e24d400,                                 //  fadd          v0.4s, v0.4s, v4.4s
    0x4e25d421,                                 //  fadd          v1.4s, v1.4s, v5.4s
    0x4e26d442,                                 //  fadd          v2.4s, v2.4s, v6.4s
    0x4e27d463,                                 //  fadd          v3.4s, v3.4s, v7.4s
};
static const unsigned int kSplice_srcover[] = {
    0x91001068,                                 //  add           x8, x3, #0x4
    0x4d40c910,                                 //  ld1r          {v16.4s}, [x8]
    0x4ea3d610,                                 //  fsub          v16.4s, v16.4s, v3.4s
    0x4e24ce00,                                 //  fmla          v0.4s, v16.4s, v4.4s
    0x4e25ce01,                                 //  fmla          v1.4s, v16.4s, v5.4s
    0x4e26ce02,                                 //  fmla          v2.4s, v16.4s, v6.4s
    0x4e27ce03,                                 //  fmla          v3.4s, v16.4s, v7.4s
};
static const unsigned int kSplice_dstover[] = {
    0x91001068,                                 //  add           x8, x3, #0x4
    0x4d40c910,                                 //  ld1r          {v16.4s}, [x8]
    0x4ea7d610,                                 //  fsub          v16.4s, v16.4s, v7.4s
    0x4e20ce04,                                 //  fmla          v4.4s, v16.4s, v0.4s
    0x4e21ce05,                                 //  fmla          v5.4s, v16.4s, v1.4s
    0x4e22ce06,                                 //  fmla          v6.4s, v16.4s, v2.4s
    0x4e23ce07,                                 //  fmla          v7.4s, v16.4s, v3.4s
};
static const unsigned int kSplice_clamp_0[] = {
    0x6f00e410,                                 //  movi          v16.2d, #0x0
    0x4e30f400,                                 //  fmax          v0.4s, v0.4s, v16.4s
    0x4e30f421,                                 //  fmax          v1.4s, v1.4s, v16.4s
    0x4e30f442,                                 //  fmax          v2.4s, v2.4s, v16.4s
    0x4e30f463,                                 //  fmax          v3.4s, v3.4s, v16.4s
};
static const unsigned int kSplice_clamp_1[] = {
    0x91001068,                                 //  add           x8, x3, #0x4
    0x4d40c910,                                 //  ld1r          {v16.4s}, [x8]
    0x4eb0f400,                                 //  fmin          v0.4s, v0.4s, v16.4s
    0x4eb0f421,                                 //  fmin          v1.4s, v1.4s, v16.4s
    0x4eb0f442,                                 //  fmin          v2.4s, v2.4s, v16.4s
    0x4eb0f463,                                 //  fmin          v3.4s, v3.4s, v16.4s
};
static const unsigned int kSplice_clamp_a[] = {
    0x91001068,                                 //  add           x8, x3, #0x4
    0x4d40c910,                                 //  ld1r          {v16.4s}, [x8]
    0x4eb0f463,                                 //  fmin          v3.4s, v3.4s, v16.4s
    0x4ea3f400,                                 //  fmin          v0.4s, v0.4s, v3.4s
    0x4ea3f421,                                 //  fmin          v1.4s, v1.4s, v3.4s
    0x4ea3f442,                                 //  fmin          v2.4s, v2.4s, v3.4s
};
static const unsigned int kSplice_swap[] = {
    0x4ea31c70,                                 //  mov           v16.16b, v3.16b
    0x4ea21c51,                                 //  mov           v17.16b, v2.16b
    0x4ea11c32,                                 //  mov           v18.16b, v1.16b
    0x4ea01c13,                                 //  mov           v19.16b, v0.16b
    0x4ea41c80,                                 //  mov           v0.16b, v4.16b
    0x4ea51ca1,                                 //  mov           v1.16b, v5.16b
    0x4ea61cc2,                                 //  mov           v2.16b, v6.16b
    0x4ea71ce3,                                 //  mov           v3.16b, v7.16b
    0x4eb31e64,                                 //  mov           v4.16b, v19.16b
    0x4eb21e45,                                 //  mov           v5.16b, v18.16b
    0x4eb11e26,                                 //  mov           v6.16b, v17.16b
    0x4eb01e07,                                 //  mov           v7.16b, v16.16b
};
static const unsigned int kSplice_move_src_dst[] = {
    0x4ea01c04,                                 //  mov           v4.16b, v0.16b
    0x4ea11c25,                                 //  mov           v5.16b, v1.16b
    0x4ea21c46,                                 //  mov           v6.16b, v2.16b
    0x4ea31c67,                                 //  mov           v7.16b, v3.16b
};
static const unsigned int kSplice_move_dst_src[] = {
    0x4ea41c80,                                 //  mov           v0.16b, v4.16b
    0x4ea51ca1,                                 //  mov           v1.16b, v5.16b
    0x4ea61cc2,                                 //  mov           v2.16b, v6.16b
    0x4ea71ce3,                                 //  mov           v3.16b, v7.16b
};
static const unsigned int kSplice_premul[] = {
    0x6e23dc00,                                 //  fmul          v0.4s, v0.4s, v3.4s
    0x6e23dc21,                                 //  fmul          v1.4s, v1.4s, v3.4s
    0x6e23dc42,                                 //  fmul          v2.4s, v2.4s, v3.4s
};
static const unsigned int kSplice_unpremul[] = {
    0x91001068,                                 //  add           x8, x3, #0x4
    0x4d40c910,                                 //  ld1r          {v16.4s}, [x8]
    0x4ea0d871,                                 //  fcmeq         v17.4s, v3.4s, #0.0
    0x6e23fe10,                                 //  fdiv          v16.4s, v16.4s, v3.4s
    0x4e711e10,                                 //  bic           v16.16b, v16.16b, v17.16b
    0x6e20de00,                                 //  fmul          v0.4s, v16.4s, v0.4s
    0x6e21de01,                                 //  fmul          v1.4s, v16.4s, v1.4s
    0x6e22de02,                                 //  fmul          v2.4s, v16.4s, v2.4s
};
static const unsigned int kSplice_from_srgb[] = {
    0x91005068,                                 //  add           x8, x3, #0x14
    0x4d40c910,                                 //  ld1r          {v16.4s}, [x8]
    0x91004068,                                 //  add           x8, x3, #0x10
    0x4d40c911,                                 //  ld1r          {v17.4s}, [x8]
    0x2d434c72,                                 //  ldp           s18, s19, [x3,#24]
    0x6e22dc54,                                 //  fmul          v20.4s, v2.4s, v2.4s
    0x4eb01e15,                                 //  mov           v21.16b, v16.16b
    0x4eb01e17,                                 //  mov           v23.16b, v16.16b
    0x4f921050,                                 //  fmla          v16.4s, v2.4s, v18.s[0]
    0x4eb11e36,                                 //  mov           v22.16b, v17.16b
    0x4eb11e38,                                 //  mov           v24.16b, v17.16b
    0x4e34ce11,                                 //  fmla          v17.4s, v16.4s, v20.4s
    0x6e20dc10,                                 //  fmul          v16.4s, v0.4s, v0.4s
    0x91008068,                                 //  add           x8, x3, #0x20
    0x4f921015,                                 //  fmla          v21.4s, v0.4s, v18.s[0]
    0x4e30ceb6,                                 //  fmla          v22.4s, v21.4s, v16.4s
    0x4d40c910,                                 //  ld1r          {v16.4s}, [x8]
    0x6e21dc34,                                 //  fmul          v20.4s, v1.4s, v1.4s
    0x4f921037,                                 //  fmla          v23.4s, v1.4s, v18.s[0]
    0x4f939015,                                 //  fmul          v21.4s, v0.4s, v19.s[0]
    0x4f939032,                                 //  fmul          v18.4s, v1.4s, v19.s[0]
    0x4f939053,                                 //  fmul          v19.4s, v2.4s, v19.s[0]
    0x6ea0e600,                                 //  fcmgt         v0.4s, v16.4s, v0.4s
    0x6ea1e601,                                 //  fcmgt         v1.4s, v16.4s, v1.4s
    0x6ea2e602,                                 //  fcmgt         v2.4s, v16.4s, v2.4s
    0x4e34cef8,                                 //  fmla          v24.4s, v23.4s, v20.4s
    0x6e761ea0,                                 //  bsl           v0.16b, v21.16b, v22.16b
    0x6e781e41,                                 //  bsl           v1.16b, v18.16b, v24.16b
    0x6e711e62,                                 //  bsl           v2.16b, v19.16b, v17.16b
};
static const unsigned int kSplice_to_srgb[] = {
    0x6ea1d810,                                 //  frsqrte       v16.4s, v0.4s
    0x6ea1d835,                                 //  frsqrte       v21.4s, v1.4s
    0x6e30de17,                                 //  fmul          v23.4s, v16.4s, v16.4s
    0x6ea1d856,                                 //  frsqrte       v22.4s, v2.4s
    0x6e35deb9,                                 //  fmul          v25.4s, v21.4s, v21.4s
    0x4eb7fc17,                                 //  frsqrts       v23.4s, v0.4s, v23.4s
    0x9100c068,                                 //  add           x8, x3, #0x30
    0x6e36deda,                                 //  fmul          v26.4s, v22.4s, v22.4s
    0x4eb9fc39,                                 //  frsqrts       v25.4s, v1.4s, v25.4s
    0x6e37de10,                                 //  fmul          v16.4s, v16.4s, v23.4s
    0x2d44c871,                                 //  ldp           s17, s18, [x3,#36]
    0x4d40c914,                                 //  ld1r          {v20.4s}, [x8]
    0x4ebafc5a,                                 //  frsqrts       v26.4s, v2.4s, v26.4s
    0x6e39deb5,                                 //  fmul          v21.4s, v21.4s, v25.4s
    0x4ea1da17,                                 //  frecpe        v23.4s, v16.4s
    0xbd402c73,                                 //  ldr           s19, [x3,#44]
    0x9100d068,                                 //  add           x8, x3, #0x34
    0x6e3aded6,                                 //  fmul          v22.4s, v22.4s, v26.4s
    0x4ea1dabb,                                 //  frecpe        v27.4s, v21.4s
    0x4e37fe1d,                                 //  frecps        v29.4s, v16.4s, v23.4s
    0x4d40c918,                                 //  ld1r          {v24.4s}, [x8]
    0x4ea1dadc,                                 //  frecpe        v28.4s, v22.4s
    0x6e3ddef7,                                 //  fmul          v23.4s, v23.4s, v29.4s
    0x4e3bfebd,                                 //  frecps        v29.4s, v21.4s, v27.4s
    0x6e3ddf7b,                                 //  fmul          v27.4s, v27.4s, v29.4s
    0x4e3cfedd,                                 //  frecps        v29.4s, v22.4s, v28.4s
    0x6e3ddf9c,                                 //  fmul          v28.4s, v28.4s, v29.4s
    0x4eb41e9d,                                 //  mov           v29.16b, v20.16b
    0x6ea1da19,                                 //  frsqrte       v25.4s, v16.4s
    0x4f9312fd,                                 //  fmla          v29.4s, v23.4s, v19.s[0]
    0x4eb41e97,                                 //  mov           v23.16b, v20.16b
    0x4f91901a,                                 //  fmul          v26.4s, v0.4s, v17.s[0]
    0x4f931377,                                 //  fmla          v23.4s, v27.4s, v19.s[0]
    0x6ea1dabb,                                 //  frsqrte       v27.4s, v21.4s
    0x4f931394,                                 //  fmla          v20.4s, v28.4s, v19.s[0]
    0x4f919033,                                 //  fmul          v19.4s, v1.4s, v17.s[0]
    0x4f919051,                                 //  fmul          v17.4s, v2.4s, v17.s[0]
    0x6ea0e700,                                 //  fcmgt         v0.4s, v24.4s, v0.4s
    0x6ea1e701,                                 //  fcmgt         v1.4s, v24.4s, v1.4s
    0x6ea2e702,                                 //  fcmgt         v2.4s, v24.4s, v2.4s
    0x6e39df38,                                 //  fmul          v24.4s, v25.4s, v25.4s
    0x6ea1dadc,                                 //  frsqrte       v28.4s, v22.4s
    0x4eb8fe10,                                 //  frsqrts       v16.4s, v16.4s, v24.4s
    0x6e3bdf78,                                 //  fmul          v24.4s, v27.4s, v27.4s
    0x4eb8feb5,                                 //  frsqrts       v21.4s, v21.4s, v24.4s
    0x6e3cdf98,                                 //  fmul          v24.4s, v28.4s, v28.4s
    0x91001068,                                 //  add           x8, x3, #0x4
    0x4eb8fed6,                                 //  frsqrts       v22.4s, v22.4s, v24.4s
    0x4d40c918,                                 //  ld1r          {v24.4s}, [x8]
    0x6e30df30,                                 //  fmul          v16.4s, v25.4s, v16.4s
    0x6e35df75,                                 //  fmul          v21.4s, v27.4s, v21.4s
    0x6e36df96,                                 //  fmul          v22.4s, v28.4s, v22.4s
    0x4f92121d,                                 //  fmla          v29.4s, v16.4s, v18.s[0]
    0x4f9212b7,                                 //  fmla          v23.4s, v21.4s, v18.s[0]
    0x4f9212d4,                                 //  fmla          v20.4s, v22.4s, v18.s[0]
    0x4ebdf710,                                 //  fmin          v16.4s, v24.4s, v29.4s
    0x4eb7f712,                                 //  fmin          v18.4s, v24.4s, v23.4s
    0x4eb4f714,                                 //  fmin          v20.4s, v24.4s, v20.4s
    0x6e701f40,                                 //  bsl           v0.16b, v26.16b, v16.16b
    0x6e721e61,                                 //  bsl           v1.16b, v19.16b, v18.16b
    0x6e741e22,                                 //  bsl           v2.16b, v17.16b, v20.16b
};
static const unsigned int kSplice_scale_u8[] = {
    0xf9400048,                                 //  ldr           x8, [x2]
    0xbd400c71,                                 //  ldr           s17, [x3,#12]
    0x8b000108,                                 //  add           x8, x8, x0
    0x39400109,                                 //  ldrb          w9, [x8]
    0x3940050a,                                 //  ldrb          w10, [x8,#1]
    0x4e021d30,                                 //  mov           v16.h[0], w9
    0x39400909,                                 //  ldrb          w9, [x8,#2]
    0x39400d08,                                 //  ldrb          w8, [x8,#3]
    0x4e061d50,                                 //  mov           v16.h[1], w10
    0x4e0a1d30,                                 //  mov           v16.h[2], w9
    0x4e0e1d10,                                 //  mov           v16.h[3], w8
    0x2f07b7f0,                                 //  bic           v16.4h, #0xff, lsl #8
    0x2f10a610,                                 //  uxtl          v16.4s, v16.4h
    0x6e21da10,                                 //  ucvtf         v16.4s, v16.4s
    0x4f919210,                                 //  fmul          v16.4s, v16.4s, v17.s[0]
    0x6e20de00,                                 //  fmul          v0.4s, v16.4s, v0.4s
    0x6e21de01,                                 //  fmul          v1.4s, v16.4s, v1.4s
    0x6e22de02,                                 //  fmul          v2.4s, v16.4s, v2.4s
    0x6e23de03,                                 //  fmul          v3.4s, v16.4s, v3.4s
};
static const unsigned int kSplice_load_tables[] = {
    0xa9402848,                                 //  ldp           x8, x10, [x2]
    0xd37ef409,                                 //  lsl           x9, x0, #2
    0x4d40c860,                                 //  ld1r          {v0.4s}, [x3]
    0x3ce96903,                                 //  ldr           q3, [x8,x9]
    0xa9412448,                                 //  ldp           x8, x9, [x2,#16]
    0x4e231c01,                                 //  and           v1.16b, v0.16b, v3.16b
    0x1e26002e,                                 //  fmov          w14, s1
    0x6f380462,                                 //  ushr          v2.4s, v3.4s, #8
    0x6f300470,                                 //  ushr          v16.4s, v3.4s, #16
    0x8b2e494e,                                 //  add           x14, x10, w14, uxtw #2
    0x0e0c3c2b,                                 //  mov           w11, v1.s[1]
    0x0e143c2c,                                 //  mov           w12, v1.s[2]
    0x0e1c3c2d,                                 //  mov           w13, v1.s[3]
    0x4e221c01,                                 //  and           v1.16b, v0.16b, v2.16b
    0x4e301c02,                                 //  and           v2.16b, v0.16b, v16.16b
    0x0d4081c0,                                 //  ld1           {v0.s}[0], [x14]
    0x1e26002e,                                 //  fmov          w14, s1
    0x8b2e490e,                                 //  add           x14, x8, w14, uxtw #2
    0x8b2b494b,                                 //  add           x11, x10, w11, uxtw #2
    0xbc6c5950,                                 //  ldr           s16, [x10,w12,uxtw #2]
    0xbc6d5951,                                 //  ldr           s17, [x10,w13,uxtw #2]
    0x0e0c3c2a,                                 //  mov           w10, v1.s[1]
    0x0e143c2c,                                 //  mov           w12, v1.s[2]
    0x0e1c3c2d,                                 //  mov           w13, v1.s[3]
    0x0d4081c1,                                 //  ld1           {v1.s}[0], [x14]
    0x0d409160,                                 //  ld1           {v0.s}[1], [x11]
    0xbc6c5912,                                 //  ldr           s18, [x8,w12,uxtw #2]
    0x0e143c4c,                                 //  mov           w12, v2.s[2]
    0x1e26004e,                                 //  fmov          w14, s2
    0xbc6c5933,                                 //  ldr           s19, [x9,w12,uxtw #2]
    0x8b2e492c,                                 //  add           x12, x9, w14, uxtw #2
    0x8b2a490a,                                 //  add           x10, x8, w10, uxtw #2
    0x0e0c3c4f,                                 //  mov           w15, v2.s[1]
    0x0e1c3c4b,                                 //  mov           w11, v2.s[3]
    0x0d408182,                                 //  ld1           {v2.s}[0], [x12]
    0x0d409141,                                 //  ld1           {v1.s}[1], [x10]
    0x6e140600,                                 //  mov           v0.s[2], v16.s[0]
    0xbc6d5910,                                 //  ldr           s16, [x8,w13,uxtw #2]
    0x8b2f492a,                                 //  add           x10, x9, w15, uxtw #2
    0x0d409142,                                 //  ld1           {v2.s}[1], [x10]
    0x6e140641,                                 //  mov           v1.s[2], v18.s[0]
    0x6e1c0620,                                 //  mov           v0.s[3], v17.s[0]
    0xbc6b5931,                                 //  ldr           s17, [x9,w11,uxtw #2]
    0x6e1c0601,                                 //  mov           v1.s[3], v16.s[0]
    0xbd400c70,                                 //  ldr           s16, [x3,#12]
    0x6f280463,                                 //  ushr          v3.4s, v3.4s, #24
    0x6e140662,                                 //  mov           v2.s[2], v19.s[0]
    0x4e21d863,                                 //  scvtf         v3.4s, v3.4s
    0x6e1c0622,                                 //  mov           v2.s[3], v17.s[0]
    0x4f909063,                                 //  fmul          v3.4s, v3.4s, v16.s[0]
};
static const unsigned int kSplice_load_8888[] = {
    0xf9400048,                                 //  ldr           x8, [x2]
    0xd37ef409,                                 //  lsl           x9, x0, #2
    0x4d40c860,                                 //  ld1r          {v0.4s}, [x3]
    0xbd400c63,                                 //  ldr           s3, [x3,#12]
    0x3ce96901,                                 //  ldr           q1, [x8,x9]
    0x4e211c02,                                 //  and           v2.16b, v0.16b, v1.16b
    0x6f380430,                                 //  ushr          v16.4s, v1.4s, #8
    0x6f300431,                                 //  ushr          v17.4s, v1.4s, #16
    0x6f280421,                                 //  ushr          v1.4s, v1.4s, #24
    0x4e21d842,                                 //  scvtf         v2.4s, v2.4s
    0x4e301c10,                                 //  and           v16.16b, v0.16b, v16.16b
    0x4e311c11,                                 //  and           v17.16b, v0.16b, v17.16b
    0x4e21d832,                                 //  scvtf         v18.4s, v1.4s
    0x4f839040,                                 //  fmul          v0.4s, v2.4s, v3.s[0]
    0x4e21da01,                                 //  scvtf         v1.4s, v16.4s
    0x4e21da22,                                 //  scvtf         v2.4s, v17.4s
    0x4f839021,                                 //  fmul          v1.4s, v1.4s, v3.s[0]
    0x4f839042,                                 //  fmul          v2.4s, v2.4s, v3.s[0]
    0x4f839243,                                 //  fmul          v3.4s, v18.4s, v3.s[0]
};
static const unsigned int kSplice_store_8888[] = {
    0xbd400870,                                 //  ldr           s16, [x3,#8]
    0xf9400048,                                 //  ldr           x8, [x2]
    0xd37ef409,                                 //  lsl           x9, x0, #2
    0x4f909032,                                 //  fmul          v18.4s, v1.4s, v16.s[0]
    0x4f909011,                                 //  fmul          v17.4s, v0.4s, v16.s[0]
    0x6e21aa52,                                 //  fcvtnu        v18.4s, v18.4s
    0x6e21aa31,                                 //  fcvtnu        v17.4s, v17.4s
    0x4f285652,                                 //  shl           v18.4s, v18.4s, #8
    0x4eb11e51,                                 //  orr           v17.16b, v18.16b, v17.16b
    0x4f909052,                                 //  fmul          v18.4s, v2.4s, v16.s[0]
    0x4f909070,                                 //  fmul          v16.4s, v3.4s, v16.s[0]
    0x6e21aa52,                                 //  fcvtnu        v18.4s, v18.4s
    0x6e21aa10,                                 //  fcvtnu        v16.4s, v16.4s
    0x4f305652,                                 //  shl           v18.4s, v18.4s, #16
    0x4eb21e31,                                 //  orr           v17.16b, v17.16b, v18.16b
    0x4f385610,                                 //  shl           v16.4s, v16.4s, #24
    0x4eb01e30,                                 //  orr           v16.16b, v17.16b, v16.16b
    0x3ca96910,                                 //  str           q16, [x8,x9]
};
static const unsigned int kSplice_load_f16[] = {
    0xf9400048,                                 //  ldr           x8, [x2]
    0x8b000d08,                                 //  add           x8, x8, x0, lsl #3
    0x0c400510,                                 //  ld4           {v16.4h-v19.4h}, [x8]
    0x0e217a00,                                 //  fcvtl         v0.4s, v16.4h
    0x0e217a21,                                 //  fcvtl         v1.4s, v17.4h
    0x0e217a42,                                 //  fcvtl         v2.4s, v18.4h
    0x0e217a63,                                 //  fcvtl         v3.4s, v19.4h
};
static const unsigned int kSplice_store_f16[] = {
    0xf9400048,                                 //  ldr           x8, [x2]
    0x0e216810,                                 //  fcvtn         v16.4h, v0.4s
    0x0e216831,                                 //  fcvtn         v17.4h, v1.4s
    0x0e216852,                                 //  fcvtn         v18.4h, v2.4s
    0x8b000d08,                                 //  add           x8, x8, x0, lsl #3
    0x0e216873,                                 //  fcvtn         v19.4h, v3.4s
    0x0c000510,                                 //  st4           {v16.4h-v19.4h}, [x8]
};
static const unsigned int kSplice_matrix_3x4[] = {
    0xaa0203e8,                                 //  mov           x8, x2
    0x91009049,                                 //  add           x9, x2, #0x24
    0x4ddfc913,                                 //  ld1r          {v19.4s}, [x8], #4
    0x4d40c930,                                 //  ld1r          {v16.4s}, [x9]
    0x9100a049,                                 //  add           x9, x2, #0x28
    0x4d40c931,                                 //  ld1r          {v17.4s}, [x9]
    0x2d435454,                                 //  ldp           s20, s21, [x2,#24]
    0x9100b049,                                 //  add           x9, x2, #0x2c
    0xbd402056,                                 //  ldr           s22, [x2,#32]
    0x4d40c932,                                 //  ld1r          {v18.4s}, [x9]
    0x4f941050,                                 //  fmla          v16.4s, v2.4s, v20.s[0]
    0x4f951051,                                 //  fmla          v17.4s, v2.4s, v21.s[0]
    0x2d415454,                                 //  ldp           s20, s21, [x2,#8]
    0x4f961052,                                 //  fmla          v18.4s, v2.4s, v22.s[0]
    0x2d425842,                                 //  ldp           s2, s22, [x2,#16]
    0x4f951030,                                 //  fmla          v16.4s, v1.4s, v21.s[0]
    0xbd400115,                                 //  ldr           s21, [x8]
    0x4f821031,                                 //  fmla          v17.4s, v1.4s, v2.s[0]
    0x4f961032,                                 //  fmla          v18.4s, v1.4s, v22.s[0]
    0x4e20ce70,                                 //  fmla          v16.4s, v19.4s, v0.4s
    0x4f951011,                                 //  fmla          v17.4s, v0.4s, v21.s[0]
    0x4f941012,                                 //  fmla          v18.4s, v0.4s, v20.s[0]
    0x4eb01e00,                                 //  mov           v0.16b, v16.16b
    0x4eb11e21,                                 //  mov           v1.16b, v17.16b
    0x4eb21e42,                                 //  mov           v2.16b, v18.16b
};

#elif defined(__ARM_NEON__)

static const unsigned int kSplice_clear[] = {
    0xf2800010,                                 //  vmov.i32      d0, #0
    0xf2801010,                                 //  vmov.i32      d1, #0
    0xf2802010,                                 //  vmov.i32      d2, #0
    0xf2803010,                                 //  vmov.i32      d3, #0
};
static const unsigned int kSplice_plus[] = {
    0xf2000d04,                                 //  vadd.f32      d0, d0, d4
    0xf2011d05,                                 //  vadd.f32      d1, d1, d5
    0xf2022d06,                                 //  vadd.f32      d2, d2, d6
    0xf2033d07,                                 //  vadd.f32      d3, d3, d7
};
static const unsigned int kSplice_srcover[] = {
    0xe283c004,                                 //  add           ip, r3, #4
    0xf4ec0c9f,                                 //  vld1.32       {d16[]}, [ip :32]
    0xf2600d83,                                 //  vsub.f32      d16, d16, d3
    0xf2040c30,                                 //  vfma.f32      d0, d4, d16
    0xf2051c30,                                 //  vfma.f32      d1, d5, d16
    0xf2062c30,                                 //  vfma.f32      d2, d6, d16
    0xf2073c30,                                 //  vfma.f32      d3, d7, d16
};
static const unsigned int kSplice_dstover[] = {
    0xe283c004,                                 //  add           ip, r3, #4
    0xf4ec0c9f,                                 //  vld1.32       {d16[]}, [ip :32]
    0xf2600d87,                                 //  vsub.f32      d16, d16, d7
    0xf2004c30,                                 //  vfma.f32      d4, d0, d16
    0xf2015c30,                                 //  vfma.f32      d5, d1, d16
    0xf2026c30,                                 //  vfma.f32      d6, d2, d16
    0xf2037c30,                                 //  vfma.f32      d7, d3, d16
};
static const unsigned int kSplice_clamp_0[] = {
    0xf2c00010,                                 //  vmov.i32      d16, #0
    0xf2000f20,                                 //  vmax.f32      d0, d0, d16
    0xf2011f20,                                 //  vmax.f32      d1, d1, d16
    0xf2022f20,                                 //  vmax.f32      d2, d2, d16
    0xf2033f20,                                 //  vmax.f32      d3, d3, d16
};
static const unsigned int kSplice_clamp_1[] = {
    0xe283c004,                                 //  add           ip, r3, #4
    0xf4ec0c9f,                                 //  vld1.32       {d16[]}, [ip :32]
    0xf2200f20,                                 //  vmin.f32      d0, d0, d16
    0xf2211f20,                                 //  vmin.f32      d1, d1, d16
    0xf2222f20,                                 //  vmin.f32      d2, d2, d16
    0xf2233f20,                                 //  vmin.f32      d3, d3, d16
};
static const unsigned int kSplice_clamp_a[] = {
    0xe283c004,                                 //  add           ip, r3, #4
    0xf4ec0c9f,                                 //  vld1.32       {d16[]}, [ip :32]
    0xf2233f20,                                 //  vmin.f32      d3, d3, d16
    0xf2200f03,                                 //  vmin.f32      d0, d0, d3
    0xf2211f03,                                 //  vmin.f32      d1, d1, d3
    0xf2222f03,                                 //  vmin.f32      d2, d2, d3
};
static const unsigned int kSplice_swap[] = {
    0xeef00b43,                                 //  vmov.f64      d16, d3
    0xeef01b42,                                 //  vmov.f64      d17, d2
    0xeef02b41,                                 //  vmov.f64      d18, d1
    0xeef03b40,                                 //  vmov.f64      d19, d0
    0xeeb00b44,                                 //  vmov.f64      d0, d4
    0xeeb01b45,                                 //  vmov.f64      d1, d5
    0xeeb02b46,                                 //  vmov.f64      d2, d6
    0xeeb03b47,                                 //  vmov.f64      d3, d7
    0xeeb04b63,                                 //  vmov.f64      d4, d19
    0xeeb05b62,                                 //  vmov.f64      d5, d18
    0xeeb06b61,                                 //  vmov.f64      d6, d17
    0xeeb07b60,                                 //  vmov.f64      d7, d16
};
static const unsigned int kSplice_move_src_dst[] = {
    0xeeb04b40,                                 //  vmov.f64      d4, d0
    0xeeb05b41,                                 //  vmov.f64      d5, d1
    0xeeb06b42,                                 //  vmov.f64      d6, d2
    0xeeb07b43,                                 //  vmov.f64      d7, d3
};
static const unsigned int kSplice_move_dst_src[] = {
    0xeeb00b44,                                 //  vmov.f64      d0, d4
    0xeeb01b45,                                 //  vmov.f64      d1, d5
    0xeeb02b46,                                 //  vmov.f64      d2, d6
    0xeeb03b47,                                 //  vmov.f64      d3, d7
};
static const unsigned int kSplice_premul[] = {
    0xf3000d13,                                 //  vmul.f32      d0, d0, d3
    0xf3011d13,                                 //  vmul.f32      d1, d1, d3
    0xf3022d13,                                 //  vmul.f32      d2, d2, d3
};
static const unsigned int kSplice_unpremul[] = {
    0xed2d8b04,                                 //  vpush         {d8-d9}
    0xed938a01,                                 //  vldr          s16, [r3, #4]
    0xf2c00010,                                 //  vmov.i32      d16, #0
    0xf3f91503,                                 //  vceq.f32      d17, d3, #0
    0xeec89a23,                                 //  vdiv.f32      s19, s16, s7
    0xee889a03,                                 //  vdiv.f32      s18, s16, s6
    0xf3501199,                                 //  vbsl          d17, d16, d9
    0xf3010d90,                                 //  vmul.f32      d0, d17, d0
    0xf3011d91,                                 //  vmul.f32      d1, d17, d1
    0xf3012d92,                                 //  vmul.f32      d2, d17, d2
    0xecbd8b04,                                 //  vpop          {d8-d9}
};
static const unsigned int kSplice_from_srgb[] = {
    0xed2d8b02,                                 //  vpush         {d8}
    0xe283c018,                                 //  add           ip, r3, #24
    0xed938a07,                                 //  vldr          s16, [r3, #28]
    0xf3402d10,                                 //  vmul.f32      d18, d0, d0
    0xf4ec0c9f,                                 //  vld1.32       {d16[]}, [ip :32]
    0xe283c014,                                 //  add           ip, r3, #20
    0xf3413d11,                                 //  vmul.f32      d19, d1, d1
    0xf4ec1c9f,                                 //  vld1.32       {d17[]}, [ip :32]
    0xe283c020,                                 //  add           ip, r3, #32
    0xf26141b1,                                 //  vorr          d20, d17, d17
    0xf26171b1,                                 //  vorr          d23, d17, d17
    0xf4ec8c9f,                                 //  vld1.32       {d24[]}, [ip :32]
    0xf2404c30,                                 //  vfma.f32      d20, d0, d16
    0xe283c010,                                 //  add           ip, r3, #16
    0xf2417c30,                                 //  vfma.f32      d23, d1, d16
    0xf2421c30,                                 //  vfma.f32      d17, d2, d16
    0xf3425d12,                                 //  vmul.f32      d21, d2, d2
    0xf2e16948,                                 //  vmul.f32      d22, d1, d8[0]
    0xf2e00948,                                 //  vmul.f32      d16, d0, d8[0]
    0xf2e29948,                                 //  vmul.f32      d25, d2, d8[0]
    0xf3282e82,                                 //  vcgt.f32      d2, d24, d2
    0xf3281e81,                                 //  vcgt.f32      d1, d24, d1
    0xf3280e80,                                 //  vcgt.f32      d0, d24, d0
    0xf4ec8c9f,                                 //  vld1.32       {d24[]}, [ip :32]
    0xf268a1b8,                                 //  vorr          d26, d24, d24
    0xf242acb4,                                 //  vfma.f32      d26, d18, d20
    0xf26821b8,                                 //  vorr          d18, d24, d24
    0xf2432cb7,                                 //  vfma.f32      d18, d19, d23
    0xf2458cb1,                                 //  vfma.f32      d24, d21, d17
    0xf31001ba,                                 //  vbsl          d0, d16, d26
    0xf31611b2,                                 //  vbsl          d1, d22, d18
    0xf31921b8,                                 //  vbsl          d2, d25, d24
    0xecbd8b02,                                 //  vpop          {d8}
};
static const unsigned int kSplice_to_srgb[] = {
    0xed2d8b02,                                 //  vpush         {d8}
    0xf3fb0580,                                 //  vrsqrte.f32   d16, d0
    0xe283c02c,                                 //  add           ip, r3, #44
    0xf3fb1582,                                 //  vrsqrte.f32   d17, d2
    0xed938a09,                                 //  vldr          s16, [r3, #36]
    0xf3fb2581,                                 //  vrsqrte.f32   d18, d1
    0xf3403db0,                                 //  vmul.f32      d19, d16, d16
    0xf3414db1,                                 //  vmul.f32      d20, d17, d17
    0xf3425db2,                                 //  vmul.f32      d21, d18, d18
    0xf2603f33,                                 //  vrsqrts.f32   d19, d0, d19
    0xf2624f34,                                 //  vrsqrts.f32   d20, d2, d20
    0xf2615f35,                                 //  vrsqrts.f32   d21, d1, d21
    0xf3400db3,                                 //  vmul.f32      d16, d16, d19
    0xf3411db4,                                 //  vmul.f32      d17, d17, d20
    0xf3422db5,                                 //  vmul.f32      d18, d18, d21
    0xf3fb3520,                                 //  vrecpe.f32    d19, d16
    0xf3fb4521,                                 //  vrecpe.f32    d20, d17
    0xf3fb6522,                                 //  vrecpe.f32    d22, d18
    0xf3fb55a1,                                 //  vrsqrte.f32   d21, d17
    0xf3fb75a0,                                 //  vrsqrte.f32   d23, d16
    0xf3fb85a2,                                 //  vrsqrte.f32   d24, d18
    0xf2409fb3,                                 //  vrecps.f32    d25, d16, d19
    0xf241afb4,                                 //  vrecps.f32    d26, d17, d20
    0xf242bfb6,                                 //  vrecps.f32    d27, d18, d22
    0xf345cdb5,                                 //  vmul.f32      d28, d21, d21
    0xf347ddb7,                                 //  vmul.f32      d29, d23, d23
    0xf348edb8,                                 //  vmul.f32      d30, d24, d24
    0xf2611fbc,                                 //  vrsqrts.f32   d17, d17, d28
    0xf2600fbd,                                 //  vrsqrts.f32   d16, d16, d29
    0xf2622fbe,                                 //  vrsqrts.f32   d18, d18, d30
    0xf3433db9,                                 //  vmul.f32      d19, d19, d25
    0xf4ec9c9f,                                 //  vld1.32       {d25[]}, [ip :32]
    0xe283c030,                                 //  add           ip, r3, #48
    0xf3444dba,                                 //  vmul.f32      d20, d20, d26
    0xf3466dbb,                                 //  vmul.f32      d22, d22, d27
    0xf4ecac9f,                                 //  vld1.32       {d26[]}, [ip :32]
    0xe283c028,                                 //  add           ip, r3, #40
    0xf26ab1ba,                                 //  vorr          d27, d26, d26
    0xf249bcb3,                                 //  vfma.f32      d27, d25, d19
    0xf26a31ba,                                 //  vorr          d19, d26, d26
    0xf2493cb4,                                 //  vfma.f32      d19, d25, d20
    0xf4ec4c9f,                                 //  vld1.32       {d20[]}, [ip :32]
    0xf249acb6,                                 //  vfma.f32      d26, d25, d22
    0xe283c034,                                 //  add           ip, r3, #52
    0xf3470db0,                                 //  vmul.f32      d16, d23, d16
    0xf3482db2,                                 //  vmul.f32      d18, d24, d18
    0xf3451db1,                                 //  vmul.f32      d17, d21, d17
    0xf244bcb0,                                 //  vfma.f32      d27, d20, d16
    0xf2e20948,                                 //  vmul.f32      d16, d2, d8[0]
    0xf244acb2,                                 //  vfma.f32      d26, d20, d18
    0xf2443cb1,                                 //  vfma.f32      d19, d20, d17
    0xf4ec4c9f,                                 //  vld1.32       {d20[]}, [ip :32]
    0xf2e11948,                                 //  vmul.f32      d17, d1, d8[0]
    0xe283c004,                                 //  add           ip, r3, #4
    0xf2e02948,                                 //  vmul.f32      d18, d0, d8[0]
    0xf3241e81,                                 //  vcgt.f32      d1, d20, d1
    0xf4ec5c9f,                                 //  vld1.32       {d21[]}, [ip :32]
    0xf3240e80,                                 //  vcgt.f32      d0, d20, d0
    0xf3242e82,                                 //  vcgt.f32      d2, d20, d2
    0xf2654fab,                                 //  vmin.f32      d20, d21, d27
    0xf2656faa,                                 //  vmin.f32      d22, d21, d26
    0xf2653fa3,                                 //  vmin.f32      d19, d21, d19
    0xf31201b4,                                 //  vbsl          d0, d18, d20
    0xf31111b6,                                 //  vbsl          d1, d17, d22
    0xf31021b3,                                 //  vbsl          d2, d16, d19
    0xecbd8b02,                                 //  vpop          {d8}
};
static const unsigned int kSplice_scale_u8[] = {
    0xed2d8b02,                                 //  vpush         {d8}
    0xe24dd008,                                 //  sub           sp, sp, #8
    0xe592c000,                                 //  ldr           ip, [r2]
    0xe08cc000,                                 //  add           ip, ip, r0
    0xe1dcc0b0,                                 //  ldrh          ip, [ip]
    0xe1cdc0b4,                                 //  strh          ip, [sp, #4]
    0xe28dc004,                                 //  add           ip, sp, #4
    0xed938a03,                                 //  vldr          s16, [r3, #12]
    0xf4ec041f,                                 //  vld1.16       {d16[0]}, [ip :16]
    0xf3c80a30,                                 //  vmovl.u8      q8, d16
    0xf3d00a30,                                 //  vmovl.u16     q8, d16
    0xf3fb06a0,                                 //  vcvt.f32.u32  d16, d16
    0xf2e009c8,                                 //  vmul.f32      d16, d16, d8[0]
    0xf3000d90,                                 //  vmul.f32      d0, d16, d0
    0xf3001d91,                                 //  vmul.f32      d1, d16, d1
    0xf3002d92,                                 //  vmul.f32      d2, d16, d2
    0xf3003d93,                                 //  vmul.f32      d3, d16, d3
    0xe28dd008,                                 //  add           sp, sp, #8
    0xecbd8b02,                                 //  vpop          {d8}
};
static const unsigned int kSplice_load_tables[] = {
    0xe92d41f0,                                 //  push          {r4, r5, r6, r7, r8, lr}
    0xe592c000,                                 //  ldr           ip, [r2]
    0xf4e30c9f,                                 //  vld1.32       {d16[]}, [r3 :32]
    0xe08c5100,                                 //  add           r5, ip, r0, lsl #2
    0xe592e004,                                 //  ldr           lr, [r2, #4]
    0xedd51b00,                                 //  vldr          d17, [r5]
    0xf24021b1,                                 //  vand          d18, d16, d17
    0xe592800c,                                 //  ldr           r8, [r2, #12]
    0xf3f83031,                                 //  vshr.u32      d19, d17, #8
    0xe5924008,                                 //  ldr           r4, [r2, #8]
    0xed931a03,                                 //  vldr          s2, [r3, #12]
    0xee325b90,                                 //  vmov.32       r5, d18[1]
    0xee126b90,                                 //  vmov.32       r6, d18[0]
    0xf3f02031,                                 //  vshr.u32      d18, d17, #16
    0xf24021b2,                                 //  vand          d18, d16, d18
    0xf24001b3,                                 //  vand          d16, d16, d19
    0xee127b90,                                 //  vmov.32       r7, d18[0]
    0xe08e5105,                                 //  add           r5, lr, r5, lsl #2
    0xe08e6106,                                 //  add           r6, lr, r6, lsl #2
    0xedd50a00,                                 //  vldr          s1, [r5]
    0xee325b90,                                 //  vmov.32       r5, d18[1]
    0xed960a00,                                 //  vldr          s0, [r6]
    0xee306b90,                                 //  vmov.32       r6, d16[1]
    0xe0887107,                                 //  add           r7, r8, r7, lsl #2
    0xe088c105,                                 //  add           ip, r8, r5, lsl #2
    0xee105b90,                                 //  vmov.32       r5, d16[0]
    0xf3e80031,                                 //  vshr.u32      d16, d17, #24
    0xe0846106,                                 //  add           r6, r4, r6, lsl #2
    0xeddc2a00,                                 //  vldr          s5, [ip]
    0xf3fb0620,                                 //  vcvt.f32.s32  d16, d16
    0xed972a00,                                 //  vldr          s4, [r7]
    0xf2a039c1,                                 //  vmul.f32      d3, d16, d1[0]
    0xedd61a00,                                 //  vldr          s3, [r6]
    0xe0846105,                                 //  add           r6, r4, r5, lsl #2
    0xed961a00,                                 //  vldr          s2, [r6]
    0xe8bd41f0,                                 //  pop           {r4, r5, r6, r7, r8, lr}
};
static const unsigned int kSplice_load_8888[] = {
    0xe592c000,                                 //  ldr           ip, [r2]
    0xf4e30c9f,                                 //  vld1.32       {d16[]}, [r3 :32]
    0xe08cc100,                                 //  add           ip, ip, r0, lsl #2
    0xed932a03,                                 //  vldr          s4, [r3, #12]
    0xeddc1b00,                                 //  vldr          d17, [ip]
    0xf24021b1,                                 //  vand          d18, d16, d17
    0xf3f83031,                                 //  vshr.u32      d19, d17, #8
    0xf3e84031,                                 //  vshr.u32      d20, d17, #24
    0xf3f01031,                                 //  vshr.u32      d17, d17, #16
    0xf24031b3,                                 //  vand          d19, d16, d19
    0xf24001b1,                                 //  vand          d16, d16, d17
    0xf3fb2622,                                 //  vcvt.f32.s32  d18, d18
    0xf3fb4624,                                 //  vcvt.f32.s32  d20, d20
    0xf3fb1623,                                 //  vcvt.f32.s32  d17, d19
    0xf3fb0620,                                 //  vcvt.f32.s32  d16, d16
    0xf2a209c2,                                 //  vmul.f32      d0, d18, d2[0]
    0xf2a439c2,                                 //  vmul.f32      d3, d20, d2[0]
    0xf2a119c2,                                 //  vmul.f32      d1, d17, d2[0]
    0xf2a029c2,                                 //  vmul.f32      d2, d16, d2[0]
};
static const unsigned int kSplice_store_8888[] = {
    0xe283c008,                                 //  add           ip, r3, #8
    0xf2c3261f,                                 //  vmov.i32      d18, #1056964608
    0xf2c3361f,                                 //  vmov.i32      d19, #1056964608
    0xf4ec1c9f,                                 //  vld1.32       {d17[]}, [ip :32]
    0xf2c3061f,                                 //  vmov.i32      d16, #1056964608
    0xf2412c31,                                 //  vfma.f32      d18, d1, d17
    0xf2423c31,                                 //  vfma.f32      d19, d2, d17
    0xf2c3461f,                                 //  vmov.i32      d20, #1056964608
    0xe592c000,                                 //  ldr           ip, [r2]
    0xf2400c31,                                 //  vfma.f32      d16, d0, d17
    0xf2434c31,                                 //  vfma.f32      d20, d3, d17
    0xe08cc100,                                 //  add           ip, ip, r0, lsl #2
    0xf3fb17a2,                                 //  vcvt.u32.f32  d17, d18
    0xf3fb27a3,                                 //  vcvt.u32.f32  d18, d19
    0xf3fb07a0,                                 //  vcvt.u32.f32  d16, d16
    0xf3fb37a4,                                 //  vcvt.u32.f32  d19, d20
    0xf2e81531,                                 //  vshl.s32      d17, d17, #8
    0xf2f02532,                                 //  vshl.s32      d18, d18, #16
    0xf26101b0,                                 //  vorr          d16, d17, d16
    0xf2f81533,                                 //  vshl.s32      d17, d19, #24
    0xf26001b2,                                 //  vorr          d16, d16, d18
    0xf26001b1,                                 //  vorr          d16, d16, d17
    0xedcc0b00,                                 //  vstr          d16, [ip]
};
static const unsigned int kSplice_load_f16[] = {
    0xed2d8b04,                                 //  vpush         {d8-d9}
    0xe592c000,                                 //  ldr           ip, [r2]
    0xe08cc180,                                 //  add           ip, ip, r0, lsl #3
    0xf46c084f,                                 //  vld2.16       {d16-d17}, [ip]
    0xf3b62720,                                 //  vcvt.f32.f16  q1, d16
    0xf3b68721,                                 //  vcvt.f32.f16  q4, d17
    0xf2220112,                                 //  vorr          d0, d2, d2
    0xeef00a43,                                 //  vmov.f32      s1, s6
    0xf2281118,                                 //  vorr          d1, d8, d8
    0xeeb03a62,                                 //  vmov.f32      s6, s5
    0xeef01a49,                                 //  vmov.f32      s3, s18
    0xeeb09a68,                                 //  vmov.f32      s18, s17
    0xeeb02b43,                                 //  vmov.f64      d2, d3
    0xeeb03b49,                                 //  vmov.f64      d3, d9
    0xecbd8b04,                                 //  vpop          {d8-d9}
};
static const unsigned int kSplice_store_f16[] = {
    0xeef00b41,                                 //  vmov.f64      d16, d1
    0xf2631113,                                 //  vorr          d17, d3, d3
    0xeef02b40,                                 //  vmov.f64      d18, d0
    0xf2623112,                                 //  vorr          d19, d2, d2
    0xf3fa00a1,                                 //  vtrn.32       d16, d17
    0xf3f61620,                                 //  vcvt.f16.f32  d17, q8
    0xf3fa20a3,                                 //  vtrn.32       d18, d19
    0xe592c000,                                 //  ldr           ip, [r2]
    0xf3f60622,                                 //  vcvt.f16.f32  d16, q9
    0xe08cc180,                                 //  add           ip, ip, r0, lsl #3
    0xf44c084f,                                 //  vst2.16       {d16-d17}, [ip]
};
static const unsigned int kSplice_matrix_3x4[] = {
    0xe282c020,                                 //  add           ip, r2, #32
    0xf4ec3c9f,                                 //  vld1.32       {d19[]}, [ip :32]
    0xe282c02c,                                 //  add           ip, r2, #44
    0xf4ec0c9f,                                 //  vld1.32       {d16[]}, [ip :32]
    0xe282c01c,                                 //  add           ip, r2, #28
    0xf2420c33,                                 //  vfma.f32      d16, d2, d19
    0xf4ec4c9f,                                 //  vld1.32       {d20[]}, [ip :32]
    0xe282c018,                                 //  add           ip, r2, #24
    0xf4ec2c9f,                                 //  vld1.32       {d18[]}, [ip :32]
    0xe282c024,                                 //  add           ip, r2, #36
    0xf4ec1c9f,                                 //  vld1.32       {d17[]}, [ip :32]
    0xe282c028,                                 //  add           ip, r2, #40
    0xf2421c32,                                 //  vfma.f32      d17, d2, d18
    0xf4ec2c9f,                                 //  vld1.32       {d18[]}, [ip :32]
    0xe282c010,                                 //  add           ip, r2, #16
    0xf2422c34,                                 //  vfma.f32      d18, d2, d20
    0xf4ec3c9f,                                 //  vld1.32       {d19[]}, [ip :32]
    0xe282c00c,                                 //  add           ip, r2, #12
    0xf4ec4c9f,                                 //  vld1.32       {d20[]}, [ip :32]
    0xe282c014,                                 //  add           ip, r2, #20
    0xf2411c34,                                 //  vfma.f32      d17, d1, d20
    0xf4ec4c9f,                                 //  vld1.32       {d20[]}, [ip :32]
    0xf2410c34,                                 //  vfma.f32      d16, d1, d20
    0xe282c004,                                 //  add           ip, r2, #4
    0xf2412c33,                                 //  vfma.f32      d18, d1, d19
    0xf4e23c9f,                                 //  vld1.32       {d19[]}, [r2 :32]
    0xf4ec4c9f,                                 //  vld1.32       {d20[]}, [ip :32]
    0xe282c008,                                 //  add           ip, r2, #8
    0xf2401c33,                                 //  vfma.f32      d17, d0, d19
    0xf4ec3c9f,                                 //  vld1.32       {d19[]}, [ip :32]
    0xf2400c33,                                 //  vfma.f32      d16, d0, d19
    0xf2402c34,                                 //  vfma.f32      d18, d0, d20
    0xf22101b1,                                 //  vorr          d0, d17, d17
    0xf22021b0,                                 //  vorr          d2, d16, d16
    0xf22211b2,                                 //  vorr          d1, d18, d18
};

#else

static const unsigned char kSplice_clear[] = {
    0xc5,0xfc,0x57,0xc0,                        //  vxorps        %ymm0,%ymm0,%ymm0
    0xc5,0xf4,0x57,0xc9,                        //  vxorps        %ymm1,%ymm1,%ymm1
    0xc5,0xec,0x57,0xd2,                        //  vxorps        %ymm2,%ymm2,%ymm2
    0xc5,0xe4,0x57,0xdb,                        //  vxorps        %ymm3,%ymm3,%ymm3
};
static const unsigned char kSplice_plus[] = {
    0xc5,0xfc,0x58,0xc4,                        //  vaddps        %ymm4,%ymm0,%ymm0
    0xc5,0xf4,0x58,0xcd,                        //  vaddps        %ymm5,%ymm1,%ymm1
    0xc5,0xec,0x58,0xd6,                        //  vaddps        %ymm6,%ymm2,%ymm2
    0xc5,0xe4,0x58,0xdf,                        //  vaddps        %ymm7,%ymm3,%ymm3
};
static const unsigned char kSplice_srcover[] = {
    0xc4,0x62,0x7d,0x18,0x41,0x04,              //  vbroadcastss  0x4(%rcx),%ymm8
    0xc5,0x3c,0x5c,0xc3,                        //  vsubps        %ymm3,%ymm8,%ymm8
    0xc4,0xc2,0x5d,0xb8,0xc0,                   //  vfmadd231ps   %ymm8,%ymm4,%ymm0
    0xc4,0xc2,0x55,0xb8,0xc8,                   //  vfmadd231ps   %ymm8,%ymm5,%ymm1
    0xc4,0xc2,0x4d,0xb8,0xd0,                   //  vfmadd231ps   %ymm8,%ymm6,%ymm2
    0xc4,0xc2,0x45,0xb8,0xd8,                   //  vfmadd231ps   %ymm8,%ymm7,%ymm3
};
static const unsigned char kSplice_dstover[] = {
    0xc4,0x62,0x7d,0x18,0x41,0x04,              //  vbroadcastss  0x4(%rcx),%ymm8
    0xc5,0x3c,0x5c,0xc7,                        //  vsubps        %ymm7,%ymm8,%ymm8
    0xc4,0xc2,0x7d,0xb8,0xe0,                   //  vfmadd231ps   %ymm8,%ymm0,%ymm4
    0xc4,0xc2,0x75,0xb8,0xe8,                   //  vfmadd231ps   %ymm8,%ymm1,%ymm5
    0xc4,0xc2,0x6d,0xb8,0xf0,                   //  vfmadd231ps   %ymm8,%ymm2,%ymm6
    0xc4,0xc2,0x65,0xb8,0xf8,                   //  vfmadd231ps   %ymm8,%ymm3,%ymm7
};
static const unsigned char kSplice_clamp_0[] = {
    0xc4,0x41,0x3c,0x57,0xc0,                   //  vxorps        %ymm8,%ymm8,%ymm8
    0xc4,0xc1,0x7c,0x5f,0xc0,                   //  vmaxps        %ymm8,%ymm0,%ymm0
    0xc4,0xc1,0x74,0x5f,0xc8,                   //  vmaxps        %ymm8,%ymm1,%ymm1
    0xc4,0xc1,0x6c,0x5f,0xd0,                   //  vmaxps        %ymm8,%ymm2,%ymm2
    0xc4,0xc1,0x64,0x5f,0xd8,                   //  vmaxps        %ymm8,%ymm3,%ymm3
};
static const unsigned char kSplice_clamp_1[] = {
    0xc4,0x62,0x7d,0x18,0x41,0x04,              //  vbroadcastss  0x4(%rcx),%ymm8
    0xc4,0xc1,0x7c,0x5d,0xc0,                   //  vminps        %ymm8,%ymm0,%ymm0
    0xc4,0xc1,0x74,0x5d,0xc8,                   //  vminps        %ymm8,%ymm1,%ymm1
    0xc4,0xc1,0x6c,0x5d,0xd0,                   //  vminps        %ymm8,%ymm2,%ymm2
    0xc4,0xc1,0x64,0x5d,0xd8,                   //  vminps        %ymm8,%ymm3,%ymm3
};
static const unsigned char kSplice_clamp_a[] = {
    0xc4,0x62,0x7d,0x18,0x41,0x04,              //  vbroadcastss  0x4(%rcx),%ymm8
    0xc4,0xc1,0x64,0x5d,0xd8,                   //  vminps        %ymm8,%ymm3,%ymm3
    0xc5,0xfc,0x5d,0xc3,                        //  vminps        %ymm3,%ymm0,%ymm0
    0xc5,0xf4,0x5d,0xcb,                        //  vminps        %ymm3,%ymm1,%ymm1
    0xc5,0xec,0x5d,0xd3,                        //  vminps        %ymm3,%ymm2,%ymm2
};
static const unsigned char kSplice_swap[] = {
    0xc5,0x7c,0x28,0xc3,                        //  vmovaps       %ymm3,%ymm8
    0xc5,0x7c,0x28,0xca,                        //  vmovaps       %ymm2,%ymm9
    0xc5,0x7c,0x28,0xd1,                        //  vmovaps       %ymm1,%ymm10
    0xc5,0x7c,0x28,0xd8,                        //  vmovaps       %ymm0,%ymm11
    0xc5,0xfc,0x28,0xc4,                        //  vmovaps       %ymm4,%ymm0
    0xc5,0xfc,0x28,0xcd,                        //  vmovaps       %ymm5,%ymm1
    0xc5,0xfc,0x28,0xd6,                        //  vmovaps       %ymm6,%ymm2
    0xc5,0xfc,0x28,0xdf,                        //  vmovaps       %ymm7,%ymm3
    0xc5,0x7c,0x29,0xdc,                        //  vmovaps       %ymm11,%ymm4
    0xc5,0x7c,0x29,0xd5,                        //  vmovaps       %ymm10,%ymm5
    0xc5,0x7c,0x29,0xce,                        //  vmovaps       %ymm9,%ymm6
    0xc5,0x7c,0x29,0xc7,                        //  vmovaps       %ymm8,%ymm7
};
static const unsigned char kSplice_move_src_dst[] = {
    0xc5,0xfc,0x28,0xe0,                        //  vmovaps       %ymm0,%ymm4
    0xc5,0xfc,0x28,0xe9,                        //  vmovaps       %ymm1,%ymm5
    0xc5,0xfc,0x28,0xf2,                        //  vmovaps       %ymm2,%ymm6
    0xc5,0xfc,0x28,0xfb,                        //  vmovaps       %ymm3,%ymm7
};
static const unsigned char kSplice_move_dst_src[] = {
    0xc5,0xfc,0x28,0xc4,                        //  vmovaps       %ymm4,%ymm0
    0xc5,0xfc,0x28,0xcd,                        //  vmovaps       %ymm5,%ymm1
    0xc5,0xfc,0x28,0xd6,                        //  vmovaps       %ymm6,%ymm2
    0xc5,0xfc,0x28,0xdf,                        //  vmovaps       %ymm7,%ymm3
};
static const unsigned char kSplice_premul[] = {
    0xc5,0xfc,0x59,0xc3,                        //  vmulps        %ymm3,%ymm0,%ymm0
    0xc5,0xf4,0x59,0xcb,                        //  vmulps        %ymm3,%ymm1,%ymm1
    0xc5,0xec,0x59,0xd3,                        //  vmulps        %ymm3,%ymm2,%ymm2
};
static const unsigned char kSplice_unpremul[] = {
    0xc4,0x41,0x3c,0x57,0xc0,                   //  vxorps        %ymm8,%ymm8,%ymm8
    0xc4,0x41,0x64,0xc2,0xc8,0x00,              //  vcmpeqps      %ymm8,%ymm3,%ymm9
    0xc4,0x62,0x7d,0x18,0x51,0x04,              //  vbroadcastss  0x4(%rcx),%ymm10
    0xc5,0x2c,0x5e,0xd3,                        //  vdivps        %ymm3,%ymm10,%ymm10
    0xc4,0x43,0x2d,0x4a,0xc0,0x90,              //  vblendvps     %ymm9,%ymm8,%ymm10,%ymm8
    0xc5,0xbc,0x59,0xc0,                        //  vmulps        %ymm0,%ymm8,%ymm0
    0xc5,0xbc,0x59,0xc9,                        //  vmulps        %ymm1,%ymm8,%ymm1
    0xc5,0xbc,0x59,0xd2,                        //  vmulps        %ymm2,%ymm8,%ymm2
};
static const unsigned char kSplice_from_srgb[] = {
    0xc4,0x62,0x7d,0x18,0x41,0x1c,              //  vbroadcastss  0x1c(%rcx),%ymm8
    0xc5,0x3c,0x59,0xc8,                        //  vmulps        %ymm0,%ymm8,%ymm9
    0xc5,0x7c,0x59,0xd0,                        //  vmulps        %ymm0,%ymm0,%ymm10
    0xc4,0x62,0x7d,0x18,0x59,0x18,              //  vbroadcastss  0x18(%rcx),%ymm11
    0xc4,0x62,0x7d,0x18,0x61,0x14,              //  vbroadcastss  0x14(%rcx),%ymm12
    0xc4,0x41,0x7c,0x28,0xeb,                   //  vmovaps       %ymm11,%ymm13
    0xc4,0x42,0x7d,0xa8,0xec,                   //  vfmadd213ps   %ymm12,%ymm0,%ymm13
    0xc4,0x62,0x7d,0x18,0x71,0x10,              //  vbroadcastss  0x10(%rcx),%ymm14
    0xc4,0x42,0x2d,0xa8,0xee,                   //  vfmadd213ps   %ymm14,%ymm10,%ymm13
    0xc4,0x62,0x7d,0x18,0x51,0x20,              //  vbroadcastss  0x20(%rcx),%ymm10
    0xc4,0xc1,0x7c,0xc2,0xc2,0x01,              //  vcmpltps      %ymm10,%ymm0,%ymm0
    0xc4,0xc3,0x15,0x4a,0xc1,0x00,              //  vblendvps     %ymm0,%ymm9,%ymm13,%ymm0
    0xc5,0x3c,0x59,0xc9,                        //  vmulps        %ymm1,%ymm8,%ymm9
    0xc5,0x74,0x59,0xe9,                        //  vmulps        %ymm1,%ymm1,%ymm13
    0xc4,0x41,0x7c,0x28,0xfb,                   //  vmovaps       %ymm11,%ymm15
    0xc4,0x42,0x75,0xa8,0xfc,                   //  vfmadd213ps   %ymm12,%ymm1,%ymm15
    0xc4,0x42,0x15,0xa8,0xfe,                   //  vfmadd213ps   %ymm14,%ymm13,%ymm15
    0xc4,0xc1,0x74,0xc2,0xca,0x01,              //  vcmpltps      %ymm10,%ymm1,%ymm1
    0xc4,0xc3,0x05,0x4a,0xc9,0x10,              //  vblendvps     %ymm1,%ymm9,%ymm15,%ymm1
    0xc5,0x3c,0x59,0xc2,                        //  vmulps        %ymm2,%ymm8,%ymm8
    0xc5,0x6c,0x59,0xca,                        //  vmulps        %ymm2,%ymm2,%ymm9
    0xc4,0x42,0x6d,0xa8,0xdc,                   //  vfmadd213ps   %ymm12,%ymm2,%ymm11
    0xc4,0x42,0x35,0xa8,0xde,                   //  vfmadd213ps   %ymm14,%ymm9,%ymm11
    0xc4,0xc1,0x6c,0xc2,0xd2,0x01,              //  vcmpltps      %ymm10,%ymm2,%ymm2
    0xc4,0xc3,0x25,0x4a,0xd0,0x20,              //  vblendvps     %ymm2,%ymm8,%ymm11,%ymm2
};
static const unsigned char kSplice_to_srgb[] = {
    0xc5,0x7c,0x52,0xc0,                        //  vrsqrtps      %ymm0,%ymm8
    0xc4,0x41,0x7c,0x53,0xc8,                   //  vrcpps        %ymm8,%ymm9
    0xc4,0x41,0x7c,0x52,0xd0,                   //  vrsqrtps      %ymm8,%ymm10
    0xc4,0x62,0x7d,0x18,0x41,0x24,              //  vbroadcastss  0x24(%rcx),%ymm8
    0xc5,0x3c,0x59,0xd8,                        //  vmulps        %ymm0,%ymm8,%ymm11
    0xc4,0x62,0x7d,0x18,0x61,0x04,              //  vbroadcastss  0x4(%rcx),%ymm12
    0xc4,0x62,0x7d,0x18,0x69,0x28,              //  vbroadcastss  0x28(%rcx),%ymm13
    0xc4,0x62,0x7d,0x18,0x71,0x2c,              //  vbroadcastss  0x2c(%rcx),%ymm14
    0xc4,0x62,0x7d,0x18,0x79,0x30,              //  vbroadcastss  0x30(%rcx),%ymm15
    0xc4,0x42,0x0d,0xa8,0xcf,                   //  vfmadd213ps   %ymm15,%ymm14,%ymm9
    0xc4,0x42,0x15,0xb8,0xca,                   //  vfmadd231ps   %ymm10,%ymm13,%ymm9
    0xc4,0x41,0x1c,0x5d,0xc9,                   //  vminps        %ymm9,%ymm12,%ymm9
    0xc4,0x62,0x7d,0x18,0x51,0x34,              //  vbroadcastss  0x34(%rcx),%ymm10
    0xc4,0xc1,0x7c,0xc2,0xc2,0x01,              //  vcmpltps      %ymm10,%ymm0,%ymm0
    0xc4,0xc3,0x35,0x4a,0xc3,0x00,              //  vblendvps     %ymm0,%ymm11,%ymm9,%ymm0
    0xc5,0x7c,0x52,0xc9,                        //  vrsqrtps      %ymm1,%ymm9
    0xc4,0x41,0x7c,0x53,0xd9,                   //  vrcpps        %ymm9,%ymm11
    0xc4,0x41,0x7c,0x52,0xc9,                   //  vrsqrtps      %ymm9,%ymm9
    0xc4,0x42,0x0d,0xa8,0xdf,                   //  vfmadd213ps   %ymm15,%ymm14,%ymm11
    0xc4,0x42,0x15,0xb8,0xd9,                   //  vfmadd231ps   %ymm9,%ymm13,%ymm11
    0xc5,0x3c,0x59,0xc9,                        //  vmulps        %ymm1,%ymm8,%ymm9
    0xc4,0x41,0x1c,0x5d,0xdb,                   //  vminps        %ymm11,%ymm12,%ymm11
    0xc4,0xc1,0x74,0xc2,0xca,0x01,              //  vcmpltps      %ymm10,%ymm1,%ymm1
    0xc4,0xc3,0x25,0x4a,0xc9,0x10,              //  vblendvps     %ymm1,%ymm9,%ymm11,%ymm1
    0xc5,0x7c,0x52,0xca,                        //  vrsqrtps      %ymm2,%ymm9
    0xc4,0x41,0x7c,0x53,0xd9,                   //  vrcpps        %ymm9,%ymm11
    0xc4,0x42,0x0d,0xa8,0xdf,                   //  vfmadd213ps   %ymm15,%ymm14,%ymm11
    0xc4,0x41,0x7c,0x52,0xc9,                   //  vrsqrtps      %ymm9,%ymm9
    0xc4,0x42,0x15,0xb8,0xd9,                   //  vfmadd231ps   %ymm9,%ymm13,%ymm11
    0xc4,0x41,0x1c,0x5d,0xcb,                   //  vminps        %ymm11,%ymm12,%ymm9
    0xc5,0x3c,0x59,0xc2,                        //  vmulps        %ymm2,%ymm8,%ymm8
    0xc4,0xc1,0x6c,0xc2,0xd2,0x01,              //  vcmpltps      %ymm10,%ymm2,%ymm2
    0xc4,0xc3,0x35,0x4a,0xd0,0x20,              //  vblendvps     %ymm2,%ymm8,%ymm9,%ymm2
};
static const unsigned char kSplice_scale_u8[] = {
    0x48,0x8b,0x02,                             //  mov           (%rdx),%rax
    0xc4,0x62,0x7d,0x31,0x04,0x38,              //  vpmovzxbd     (%rax,%rdi,1),%ymm8
    0xc4,0x41,0x7c,0x5b,0xc0,                   //  vcvtdq2ps     %ymm8,%ymm8
    0xc4,0x62,0x7d,0x18,0x49,0x0c,              //  vbroadcastss  0xc(%rcx),%ymm9
    0xc4,0x41,0x3c,0x59,0xc1,                   //  vmulps        %ymm9,%ymm8,%ymm8
    0xc5,0xbc,0x59,0xc0,                        //  vmulps        %ymm0,%ymm8,%ymm0
    0xc5,0xbc,0x59,0xc9,                        //  vmulps        %ymm1,%ymm8,%ymm1
    0xc5,0xbc,0x59,0xd2,                        //  vmulps        %ymm2,%ymm8,%ymm2
    0xc5,0xbc,0x59,0xdb,                        //  vmulps        %ymm3,%ymm8,%ymm3
};
static const unsigned char kSplice_load_tables[] = {
    0x48,0x8b,0x02,                             //  mov           (%rdx),%rax
    0x4c,0x8b,0x42,0x08,                        //  mov           0x8(%rdx),%r8
    0xc5,0xfc,0x10,0x1c,0xb8,                   //  vmovups       (%rax,%rdi,4),%ymm3
    0xc4,0xe2,0x7d,0x18,0x11,                   //  vbroadcastss  (%rcx),%ymm2
    0xc5,0xec,0x54,0xcb,                        //  vandps        %ymm3,%ymm2,%ymm1
    0xc5,0xfc,0x57,0xc0,                        //  vxorps        %ymm0,%ymm0,%ymm0
    0xc5,0x7c,0xc2,0xc0,0x00,                   //  vcmpeqps      %ymm0,%ymm0,%ymm8
    0xc4,0x41,0x7c,0x28,0xc8,                   //  vmovaps       %ymm8,%ymm9
    0xc4,0xc2,0x35,0x92,0x04,0x88,              //  vgatherdps    %ymm9,(%r8,%ymm1,4),%ymm0
    0x48,0x8b,0x42,0x10,                        //  mov           0x10(%rdx),%rax
    0xc5,0xf5,0x72,0xd3,0x08,                   //  vpsrld        $0x8,%ymm3,%ymm1
    0xc5,0x6c,0x54,0xc9,                        //  vandps        %ymm1,%ymm2,%ymm9
    0xc4,0x41,0x7c,0x28,0xd0,                   //  vmovaps       %ymm8,%ymm10
    0xc4,0xa2,0x2d,0x92,0x0c,0x88,              //  vgatherdps    %ymm10,(%rax,%ymm9,4),%ymm1
    0x48,0x8b,0x42,0x18,                        //  mov           0x18(%rdx),%rax
    0xc5,0xb5,0x72,0xd3,0x10,                   //  vpsrld        $0x10,%ymm3,%ymm9
    0xc4,0x41,0x6c,0x54,0xc9,                   //  vandps        %ymm9,%ymm2,%ymm9
    0xc4,0xa2,0x3d,0x92,0x14,0x88,              //  vgatherdps    %ymm8,(%rax,%ymm9,4),%ymm2
    0xc5,0xe5,0x72,0xd3,0x18,                   //  vpsrld        $0x18,%ymm3,%ymm3
    0xc5,0xfc,0x5b,0xdb,                        //  vcvtdq2ps     %ymm3,%ymm3
    0xc4,0x62,0x7d,0x18,0x41,0x0c,              //  vbroadcastss  0xc(%rcx),%ymm8
    0xc4,0xc1,0x64,0x59,0xd8,                   //  vmulps        %ymm8,%ymm3,%ymm3
};
static const unsigned char kSplice_load_8888[] = {
    0x48,0x8b,0x02,                             //  mov           (%rdx),%rax
    0xc5,0xfc,0x10,0x1c,0xb8,                   //  vmovups       (%rax,%rdi,4),%ymm3
    0xc4,0xe2,0x7d,0x18,0x11,                   //  vbroadcastss  (%rcx),%ymm2
    0xc5,0xec,0x54,0xc3,                        //  vandps        %ymm3,%ymm2,%ymm0
    0xc5,0xfc,0x5b,0xc0,                        //  vcvtdq2ps     %ymm0,%ymm0
    0xc4,0x62,0x7d,0x18,0x41,0x0c,              //  vbroadcastss  0xc(%rcx),%ymm8
    0xc5,0xbc,0x59,0xc0,                        //  vmulps        %ymm0,%ymm8,%ymm0
    0xc5,0xf5,0x72,0xd3,0x08,                   //  vpsrld        $0x8,%ymm3,%ymm1
    0xc5,0xec,0x54,0xc9,                        //  vandps        %ymm1,%ymm2,%ymm1
    0xc5,0xfc,0x5b,0xc9,                        //  vcvtdq2ps     %ymm1,%ymm1
    0xc5,0xbc,0x59,0xc9,                        //  vmulps        %ymm1,%ymm8,%ymm1
    0xc5,0xb5,0x72,0xd3,0x10,                   //  vpsrld        $0x10,%ymm3,%ymm9
    0xc4,0xc1,0x6c,0x54,0xd1,                   //  vandps        %ymm9,%ymm2,%ymm2
    0xc5,0xfc,0x5b,0xd2,                        //  vcvtdq2ps     %ymm2,%ymm2
    0xc5,0xbc,0x59,0xd2,                        //  vmulps        %ymm2,%ymm8,%ymm2
    0xc5,0xe5,0x72,0xd3,0x18,                   //  vpsrld        $0x18,%ymm3,%ymm3
    0xc5,0xfc,0x5b,0xdb,                        //  vcvtdq2ps     %ymm3,%ymm3
    0xc4,0xc1,0x64,0x59,0xd8,                   //  vmulps        %ymm8,%ymm3,%ymm3
};
static const unsigned char kSplice_store_8888[] = {
    0x48,0x8b,0x02,                             //  mov           (%rdx),%rax
    0xc4,0x62,0x7d,0x18,0x41,0x08,              //  vbroadcastss  0x8(%rcx),%ymm8
    0xc5,0x3c,0x59,0xc8,                        //  vmulps        %ymm0,%ymm8,%ymm9
    0xc4,0x41,0x7d,0x5b,0xc9,                   //  vcvtps2dq     %ymm9,%ymm9
    0xc5,0x3c,0x59,0xd1,                        //  vmulps        %ymm1,%ymm8,%ymm10
    0xc4,0x41,0x7d,0x5b,0xd2,                   //  vcvtps2dq     %ymm10,%ymm10
    0xc4,0xc1,0x2d,0x72,0xf2,0x08,              //  vpslld        $0x8,%ymm10,%ymm10
    0xc4,0x41,0x2d,0xeb,0xc9,                   //  vpor          %ymm9,%ymm10,%ymm9
    0xc5,0x3c,0x59,0xd2,                        //  vmulps        %ymm2,%ymm8,%ymm10
    0xc4,0x41,0x7d,0x5b,0xd2,                   //  vcvtps2dq     %ymm10,%ymm10
    0xc4,0xc1,0x2d,0x72,0xf2,0x10,              //  vpslld        $0x10,%ymm10,%ymm10
    0xc5,0x3c,0x59,0xc3,                        //  vmulps        %ymm3,%ymm8,%ymm8
    0xc4,0x41,0x7d,0x5b,0xc0,                   //  vcvtps2dq     %ymm8,%ymm8
    0xc4,0xc1,0x3d,0x72,0xf0,0x18,              //  vpslld        $0x18,%ymm8,%ymm8
    0xc4,0x41,0x2d,0xeb,0xc0,                   //  vpor          %ymm8,%ymm10,%ymm8
    0xc4,0x41,0x35,0xeb,0xc0,                   //  vpor          %ymm8,%ymm9,%ymm8
    0xc5,0x7e,0x7f,0x04,0xb8,                   //  vmovdqu       %ymm8,(%rax,%rdi,4)
};
static const unsigned char kSplice_load_f16[] = {
    0x48,0x8b,0x02,                             //  mov           (%rdx),%rax
    0xc5,0xfa,0x6f,0x04,0xf8,                   //  vmovdqu       (%rax,%rdi,8),%xmm0
    0xc5,0xfa,0x6f,0x4c,0xf8,0x10,              //  vmovdqu       0x10(%rax,%rdi,8),%xmm1
    0xc5,0xfa,0x6f,0x54,0xf8,0x20,              //  vmovdqu       0x20(%rax,%rdi,8),%xmm2
    0xc5,0xfa,0x6f,0x5c,0xf8,0x30,              //  vmovdqu       0x30(%rax,%rdi,8),%xmm3
    0xc5,0x79,0x61,0xc1,                        //  vpunpcklwd    %xmm1,%xmm0,%xmm8
    0xc5,0xf9,0x69,0xc1,                        //  vpunpckhwd    %xmm1,%xmm0,%xmm0
    0xc5,0xe9,0x61,0xcb,                        //  vpunpcklwd    %xmm3,%xmm2,%xmm1
    0xc5,0xe9,0x69,0xd3,                        //  vpunpckhwd    %xmm3,%xmm2,%xmm2
    0xc5,0x39,0x61,0xc8,                        //  vpunpcklwd    %xmm0,%xmm8,%xmm9
    0xc5,0x39,0x69,0xc0,                        //  vpunpckhwd    %xmm0,%xmm8,%xmm8
    0xc5,0xf1,0x61,0xda,                        //  vpunpcklwd    %xmm2,%xmm1,%xmm3
    0xc5,0x71,0x69,0xd2,                        //  vpunpckhwd    %xmm2,%xmm1,%xmm10
    0xc5,0xb1,0x6c,0xc3,                        //  vpunpcklqdq   %xmm3,%xmm9,%xmm0
    0xc4,0xe2,0x7d,0x13,0xc0,                   //  vcvtph2ps     %xmm0,%ymm0
    0xc5,0xb1,0x6d,0xcb,                        //  vpunpckhqdq   %xmm3,%xmm9,%xmm1
    0xc4,0xe2,0x7d,0x13,0xc9,                   //  vcvtph2ps     %xmm1,%ymm1
    0xc4,0xc1,0x39,0x6c,0xd2,                   //  vpunpcklqdq   %xmm10,%xmm8,%xmm2
    0xc4,0xe2,0x7d,0x13,0xd2,                   //  vcvtph2ps     %xmm2,%ymm2
    0xc4,0xc1,0x39,0x6d,0xda,                   //  vpunpckhqdq   %xmm10,%xmm8,%xmm3
    0xc4,0xe2,0x7d,0x13,0xdb,                   //  vcvtph2ps     %xmm3,%ymm3
};
static const unsigned char kSplice_store_f16[] = {
    0x48,0x8b,0x02,                             //  mov           (%rdx),%rax
    0xc4,0xc3,0x7d,0x1d,0xc0,0x04,              //  vcvtps2ph     $0x4,%ymm0,%xmm8
    0xc4,0xc3,0x7d,0x1d,0xc9,0x04,              //  vcvtps2ph     $0x4,%ymm1,%xmm9
    0xc4,0xc3,0x7d,0x1d,0xd2,0x04,              //  vcvtps2ph     $0x4,%ymm2,%xmm10
    0xc4,0xc3,0x7d,0x1d,0xdb,0x04,              //  vcvtps2ph     $0x4,%ymm3,%xmm11
    0xc4,0x41,0x39,0x61,0xe1,                   //  vpunpcklwd    %xmm9,%xmm8,%xmm12
    0xc4,0x41,0x39,0x69,0xc1,                   //  vpunpckhwd    %xmm9,%xmm8,%xmm8
    0xc4,0x41,0x29,0x61,0xcb,                   //  vpunpcklwd    %xmm11,%xmm10,%xmm9
    0xc4,0x41,0x29,0x69,0xd3,                   //  vpunpckhwd    %xmm11,%xmm10,%xmm10
    0xc4,0x41,0x19,0x62,0xd9,                   //  vpunpckldq    %xmm9,%xmm12,%xmm11
    0xc5,0x7a,0x7f,0x1c,0xf8,                   //  vmovdqu       %xmm11,(%rax,%rdi,8)
    0xc4,0x41,0x19,0x6a,0xc9,                   //  vpunpckhdq    %xmm9,%xmm12,%xmm9
    0xc5,0x7a,0x7f,0x4c,0xf8,0x10,              //  vmovdqu       %xmm9,0x10(%rax,%rdi,8)
    0xc4,0x41,0x39,0x62,0xca,                   //  vpunpckldq    %xmm10,%xmm8,%xmm9
    0xc5,0x7a,0x7f,0x4c,0xf8,0x20,              //  vmovdqu       %xmm9,0x20(%rax,%rdi,8)
    0xc4,0x41,0x39,0x6a,0xc2,                   //  vpunpckhdq    %xmm10,%xmm8,%xmm8
    0xc5,0x7a,0x7f,0x44,0xf8,0x30,              //  vmovdqu       %xmm8,0x30(%rax,%rdi,8)
};
static const unsigned char kSplice_matrix_3x4[] = {
    0xc4,0x62,0x7d,0x18,0x0a,                   //  vbroadcastss  (%rdx),%ymm9
    0xc4,0x62,0x7d,0x18,0x52,0x0c,              //  vbroadcastss  0xc(%rdx),%ymm10
    0xc4,0x62,0x7d,0x18,0x5a,0x18,              //  vbroadcastss  0x18(%rdx),%ymm11
    0xc4,0x62,0x7d,0x18,0x42,0x24,              //  vbroadcastss  0x24(%rdx),%ymm8
    0xc4,0x42,0x6d,0xb8,0xc3,                   //  vfmadd231ps   %ymm11,%ymm2,%ymm8
    0xc4,0x42,0x75,0xb8,0xc2,                   //  vfmadd231ps   %ymm10,%ymm1,%ymm8
    0xc4,0x42,0x7d,0xb8,0xc1,                   //  vfmadd231ps   %ymm9,%ymm0,%ymm8
    0xc4,0x62,0x7d,0x18,0x52,0x04,              //  vbroadcastss  0x4(%rdx),%ymm10
    0xc4,0x62,0x7d,0x18,0x5a,0x10,              //  vbroadcastss  0x10(%rdx),%ymm11
    0xc4,0x62,0x7d,0x18,0x62,0x1c,              //  vbroadcastss  0x1c(%rdx),%ymm12
    0xc4,0x62,0x7d,0x18,0x4a,0x28,              //  vbroadcastss  0x28(%rdx),%ymm9
    0xc4,0x42,0x6d,0xb8,0xcc,                   //  vfmadd231ps   %ymm12,%ymm2,%ymm9
    0xc4,0x42,0x75,0xb8,0xcb,                   //  vfmadd231ps   %ymm11,%ymm1,%ymm9
    0xc4,0x42,0x7d,0xb8,0xca,                   //  vfmadd231ps   %ymm10,%ymm0,%ymm9
    0xc4,0x62,0x7d,0x18,0x5a,0x08,              //  vbroadcastss  0x8(%rdx),%ymm11
    0xc4,0x62,0x7d,0x18,0x62,0x14,              //  vbroadcastss  0x14(%rdx),%ymm12
    0xc4,0x62,0x7d,0x18,0x6a,0x20,              //  vbroadcastss  0x20(%rdx),%ymm13
    0xc4,0x62,0x7d,0x18,0x52,0x2c,              //  vbroadcastss  0x2c(%rdx),%ymm10
    0xc4,0x42,0x6d,0xb8,0xd5,                   //  vfmadd231ps   %ymm13,%ymm2,%ymm10
    0xc4,0x42,0x75,0xb8,0xd4,                   //  vfmadd231ps   %ymm12,%ymm1,%ymm10
    0xc4,0x42,0x7d,0xb8,0xd3,                   //  vfmadd231ps   %ymm11,%ymm0,%ymm10
    0xc5,0x7c,0x29,0xc0,                        //  vmovaps       %ymm8,%ymm0
    0xc5,0x7c,0x29,0xc9,                        //  vmovaps       %ymm9,%ymm1
    0xc5,0x7c,0x29,0xd2,                        //  vmovaps       %ymm10,%ymm2
};

#endif

#endif//SkSplicer_generated_DEFINED