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

#include "tests/Test.h"

#if defined(SK_GRAPHITE)
#include "include/gpu/graphite/Context.h"
#include "include/gpu/graphite/PrecompileContext.h"
#include "src/gpu/graphite/PrecompileContextPriv.h"
#include "src/gpu/graphite/TextureInfoPriv.h"
#include "tests/graphite/precompile/PaintOptionsBuilder.h"
#include "tests/graphite/precompile/PrecompileTestUtils.h"

using namespace skgpu::graphite;
using namespace PaintOptionsUtils;
using namespace PrecompileTestUtils;

// Single sampled R w/ just depth
const RenderPassProperties kR_1_D{DepthStencilFlags::kDepth,
                                kAlpha_8_SkColorType,
                                /* fDstCS= */ nullptr,
                                /* fRequiresMSAA= */ false};

// MSAA R w/ depth and stencil
const RenderPassProperties kR_4_DS{DepthStencilFlags::kDepthStencil,
                                 kAlpha_8_SkColorType,
                                 /* fDstCS= */ nullptr,
                                 /* fRequiresMSAA= */ true};

// Single sampled BGRA w/ just depth
const RenderPassProperties kBGRA_1_D{DepthStencilFlags::kDepth,
                                   kBGRA_8888_SkColorType,
                                   /* fDstCS= */ nullptr,
                                   /* fRequiresMSAA= */ false};

// MSAA BGRA w/ just depth
const RenderPassProperties kBGRA_4_D{DepthStencilFlags::kDepth,
                                   kBGRA_8888_SkColorType,
                                   /* fDstCS= */ nullptr,
                                   /* fRequiresMSAA= */ true};

// MSAA BGRA w/ depth and stencil
const RenderPassProperties kBGRA_4_DS{DepthStencilFlags::kDepthStencil,
                                    kBGRA_8888_SkColorType,
                                    /* fDstCS= */ nullptr,
                                    /* fRequiresMSAA= */ true};

// The same as kBGRA_1_D but w/ an SRGB colorSpace
const RenderPassProperties kBGRA_1_D_SRGB{DepthStencilFlags::kDepth,
                                        kBGRA_8888_SkColorType,
                                        SkColorSpace::MakeSRGB(),
                                        /* fRequiresMSAA= */ false};

// The same as kBGRA_1_D but w/ an Adobe RGB colorSpace
const RenderPassProperties kBGRA_1_D_Adobe{
  DepthStencilFlags::kDepth, kBGRA_8888_SkColorType,
  SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB),
  /* fRequiresMSAA= */ false};

// The same as kBGRA_4_DS but w/ an SRGB colorSpace
const RenderPassProperties kBGRA_4_DS_SRGB{DepthStencilFlags::kDepthStencil,
                                         kBGRA_8888_SkColorType,
                                         SkColorSpace::MakeSRGB(),
                                         /* fRequiresMSAA= */ true};

// The same as kBGRA_4_DS but w/ an Adobe RGB colorSpace
const RenderPassProperties kBGRA_4_DS_Adobe{
  DepthStencilFlags::kDepthStencil, kBGRA_8888_SkColorType,
  SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kAdobeRGB),
  /* fRequiresMSAA= */ true};

constexpr DrawTypeFlags kRRectAndNonAARect = static_cast<DrawTypeFlags>(
        DrawTypeFlags::kAnalyticRRect | DrawTypeFlags::kNonAAFillRect);
constexpr DrawTypeFlags kQuadAndNonAARect = static_cast<DrawTypeFlags>(
        DrawTypeFlags::kPerEdgeAAQuad | DrawTypeFlags::kNonAAFillRect);

namespace {
// These settings cover 108 of the 255 cases in 'kCases'.
// They create 136 Pipelines so only modestly over-generate (28 Pipelines).
//
// The order here is:
//    First all the kBitmapText_Mask draws
//    Second  all the kBitmapText_Color draws
// Then we switch to being subdivided by the Render Pass Properties and sorted by
// the name of the PaintOptions creation function.
const PrecompileSettings kPrecompileCases[] = {
//-----------------
/*  0 */ { Builder().srcOver(),
           DrawTypeFlags::kBitmapText_Mask,
           kBGRA_1_D },
//-----------------
/*  1 */ { Builder().srcOver(),
           DrawTypeFlags::kBitmapText_Mask,
           kBGRA_4_DS },
//-----------------
/*  2 */ { Builder().linearGrad(kSmall).srcOver(),
           DrawTypeFlags::kBitmapText_Mask,
           kBGRA_4_DS },

//-----------------
/*  3 */ { Builder().transparent().srcOver(),
           DrawTypeFlags::kBitmapText_Color,
           kBGRA_1_D },
/*  4 */ { Builder().srcOver(),
           DrawTypeFlags::kBitmapText_Color,
           kBGRA_1_D_Adobe },
//-----------------
/*  5 */ { Builder().srcOver(),
           DrawTypeFlags::kBitmapText_Color,
           kBGRA_4_DS_Adobe },

//-----------------
/*  6 */ { Builder().srcOver(),
           kRRectAndNonAARect,
           kR_1_D },
/*  7 */ { Builder().hwImg(kAlpha).srcOver(),
           DrawTypeFlags::kPerEdgeAAQuad,
           kR_1_D },
/*  8 */ { Builder().hwImg(kAlpha, kRepeat).src(),
           DrawTypeFlags::kNonAAFillRect,
           kR_1_D },

//-----------------
/*  9 */ { Builder().hwImg(kPremul, kClamp).dstIn(),
           kQuadAndNonAARect,
           kBGRA_1_D },
/* 10 */ { Builder().hwImg(kPremul).matrixCF().srcOver(),
           DrawTypeFlags::kNonAAFillRect,
           kBGRA_1_D },
/* 11 */ { Builder().hwImg(kPremul).porterDuffCF().srcOver(),
           DrawTypeFlags::kPerEdgeAAQuad,
           kBGRA_1_D },
/* 12 */ { Builder().hwImg(kPremul, kClamp).srcOver(),
           DrawTypeFlags::kAnalyticRRect,
           kBGRA_1_D },
/* 13 */ { Builder().hwImg(kPremul).src().srcOver(),
           kQuadAndNonAARect,
           kBGRA_1_D },
/* 14 */ { Builder().linearGrad(kSmall).srcOver(),
           DrawTypeFlags::kNonAAFillRect,
           kBGRA_1_D },
/* 15 */ { Builder().src().srcOver(),
           DrawTypeFlags::kSimpleShape,
           kBGRA_1_D },
/* 16 */ { Builder().transparent().hwImg(kPremul, kClamp).srcOver(),
           kQuadAndNonAARect,
           kBGRA_1_D },
/* 17 */ { Builder().linearGrad(kComplex).dither().srcOver(),
           kRRectAndNonAARect,
           kBGRA_1_D_Adobe },
/* 18 */ { Builder().hwImg(kSRGB).srcOver(),
           kRRectAndNonAARect,
           kBGRA_1_D_SRGB },
/* 19 */ { Builder().hwImg(kSRGB).src(),
           kQuadAndNonAARect,
           kBGRA_1_D_SRGB },
/* 20 */ { Builder().yuv(kNoCubic).srcOver(),
           DrawTypeFlags::kSimpleShape,
           kBGRA_1_D_SRGB },

//-----------------
/* 21 */ { Builder().hwImg(kPremul).dstIn(),
           DrawTypeFlags::kPerEdgeAAQuad,
           kBGRA_4_DS },
/* 22 */ { Builder().hwImg(kPremul).matrixCF().srcOver(),
           DrawTypeFlags::kNonAAFillRect,
           kBGRA_4_DS },
/* 23 */ { Builder().hwImg(kPremul, kClamp).srcOver(),
           kQuadAndNonAARect,
           kBGRA_4_DS },
/* 24 */ { Builder().clear().src().srcOver(),
           kRRectAndNonAARect,
           kBGRA_4_DS },
/* 25 */ { Builder().srcOver(),
           DrawTypeFlags::kNonSimpleShape,
           kBGRA_4_DS },
/* 26 */ { Builder().transparent().hwImg(kPremul).srcOver(),
           DrawTypeFlags::kPerEdgeAAQuad,
           kBGRA_4_DS },
/* 27 */ { Builder().linearGrad(kComplex).dither().srcOver(),
           kRRectAndNonAARect,
           kBGRA_4_DS_Adobe },
/* 28 */ { Builder().hwImg(kSRGB).srcOver(),
           DrawTypeFlags::kAnalyticRRect,
           kBGRA_4_DS_SRGB },
/* 29 */ { Builder().yuv(kHWAndShader).srcOver(),
           DrawTypeFlags::kSimpleShape,
           kBGRA_4_DS_SRGB },
};

// Case 33 is the only case that solely covers Pipeline labels with the "w/ msaa load" sub-string.
#define MSAA_ONLY_CASE 28

//
// These Pipelines are candidates for inclusion in Chrome's precompile. They were generated
// by collecting all the Pipelines from 9 of the top 14 visited sites according to Wikipedia
//
static const PipelineLabel kCases[] = {
//--------
/*   0 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "TessellateWedgesRenderStep[Winding] + "
               "(empty)" },
/*   1 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "TessellateWedgesRenderStep[EvenOdd] + "
               "(empty)" },
/*   2 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "TessellateWedgesRenderStep[Convex] + "
               "SolidColor SrcOver" },
/*   3 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*   4 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "SolidColor SrcOver" },
/*   X */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver AnalyticClip" },
/*   6 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver" },
/*   7 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Src" },
/*   8 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Clear" },
/*   ? */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[InverseCover] + "
               "(empty)" },
/*  10 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor SrcOver" },
/*  11 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver" },
//--------
/*   ? */ { 9, "RP((BGRA8+D16 x4->1).rgba) + "                       //-----------------------------
               "TessellateWedgesRenderStep[Convex] + "
               "SolidColor SrcOver" },
/*   ? */ { 9, "RP((BGRA8+D16 x4->1).rgba) + "                       //-----------------------------
               "TessellateStrokesRenderStep + "
               "SolidColor SrcOver" },
/*   X */ { 9, "RP((BGRA8+D16 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
//--------
/*  15 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "TessellateWedgesRenderStep[Winding] + "
               "(empty)" },
/*  16 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*  17 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "SolidColor SrcOver" },
/*   X */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver AnalyticClip" },
/*  19 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver" },
/*  20 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Src" },
/*  21 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Clear" },
/*  22 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*   ? */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "       //-----------------------------
               "CoverBoundsRenderStep[InverseCover] + "
               "(empty)" },
/*  24 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor SrcOver" },
/*  25 */ { 9, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver" },
//--------
/*  26 */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] Src" },
/*  27 */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*  28 */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver" },
/*  29 */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Src" },
/*   X */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
/*  31 */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor SrcOver" },
/*  32 */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver" },
/*   X */ { 9, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticBlurRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
//--------
/*   X */ { 7, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
/*   X */ { 7, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticBlurRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
//--------
/*  36 */ { 7, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "TessellateWedgesRenderStep[EvenOdd] + "
               "(empty)" },
/*  37 */ { 7, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "TessellateWedgesRenderStep[Convex] + "
               "SolidColor SrcOver" },
/*   X */ { 7, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
//--------
/*   X */ { 7, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver AnalyticClip" },
/*  40 */ { 7, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] Src" },
//--------
/*   X */ { 6, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver AnalyticClip" },
/*  42 */ { 6, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "BitmapTextRenderStep[Mask] + "
               "LocalMatrix[LinearGradient4+PreAlpha] SrcOver" },
//--------
/*  43 */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver" },
/*  44 */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] Src" },
/*   X */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver AnalyticClip" },
/*   X */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
/*  47 */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] Src" },
/*  48 */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] Src" },
/*  49 */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*   X */ { 6, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticBlurRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
//--------
/*  51 */ { 5, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/*  52 */ { 5, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "LocalMatrix[LinearGradient4+PreAlpha] SrcOver" },
//--------
/*   X */ { 5, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver AnalyticClip" },
//--------
/*  54 */ { 5, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  55 */ { 5, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  56 */ { 5, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] DstIn" },
/*  57 */ { 5, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  58 */ { 5, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
//--------
/*  59 */ { 4, "RP((R8+D16 x1).a000) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[BlendCompose[CoordNormalize[HardwareImage(0)]+AlphaOnly, RGBPaintColor, DstIn]] SrcOver" },
/*  60 */ { 4, "RP((R8+D16 x1).a000) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver" },
/*   X */ { 4, "RP((R8+D16 x1).a000) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur16[LocalMatrix[ImageShaderClamp(0)+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]] Src" },
/*  62 */ { 4, "RP((R8+D16 x1).a000) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver" },
//--------
/*  63 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "TessellateCurvesRenderStep[EvenOdd] + "
               "(empty)" },
/*   X */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver AnalyticClip" },
/*  65 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  66 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "MiddleOutFanRenderStep[EvenOdd] + "
               "(empty)" },
/*  67 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  68 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*  69 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[InverseCover] + "
               "SolidColor SrcOver" },
/*   X */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver AnalyticClip" },
/*  71 */ { 4, "RP((BGRA8+D16 x4->1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor SrcOver" },
/*  72 */ { 4, "RP((BGRA8+D16 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver" },
//--------
/*  73 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "TessellateCurvesRenderStep[EvenOdd] + "
               "(empty)" },
/*   X */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver AnalyticClip" },
/*  75 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  76 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver" },
/*  77 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  78 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/*  79 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "MiddleOutFanRenderStep[EvenOdd] + "
               "(empty)" },
/*  80 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*  81 */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*   X */ { 4, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticBlurRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
//--------
/*   ? */ { 4, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "          //-----------------------------
               "TessellateWedgesRenderStep[Convex] + "
               "SolidColor SrcOver" },
/*  84 */ { 4, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor SrcOver" },
//--------
/*  85 */ { 4, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "SolidColor SrcOver" },
/*   X */ { 4, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver AnalyticClip" },
/*   X */ { 4, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+KnownRuntimeEffect_Luma SrcOver" },
/*  88 */ { 4, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] Src" },
/*   X */ { 4, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur16[LocalMatrix[ImageShaderClamp(0)+PreAlpha]] Src" },
/*   X */ { 4, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver AnalyticClip" },
//--------
/*  91 */ { 3, "RP((R8+D16 x1).a000) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[BlendCompose[Image(0)+AlphaOnly, RGBPaintColor, DstIn]] Src" },
/*   X */ { 3, "RP((R8+D16 x1).a000) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur16[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]] Src" },
//--------
/*   ? */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "TessellateWedgesRenderStep[Convex] + "
               "(empty)" },
/*  94 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "TessellateStrokesRenderStep + "
               "SolidColor SrcOver" },
/*   X */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver AnalyticClip" },
/*  96 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*   X */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver AnalyticClip" },
/*  98 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] DstIn" },
/*   X */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "SolidColor SrcOver AnalyticClip" },
/*   ? */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/* 101 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/* 102 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*   X */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor SrcOver AnalyticClip" },
//--------
/* 104 */ { 3, "RP((BGRA8+D16 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver" },
/* 105 */ { 3, "RP((BGRA8+D16 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Src" },
//--------
/*   ? */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "       //-----------------------------
               "TessellateWedgesRenderStep[Convex] + "
               "(empty)" },
/*   X */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver AnalyticClip" },
/*   ? */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "       //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/* 109 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*   X */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverageMaskRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 111 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "BitmapTextRenderStep[Color] + "
               "BlendCompose[RGBPaintColor, PrimitiveColor+PreAlpha+sRGB+Gamut+sRGB+PostAlpha, PorterDuffBlender] SrcOver" },
/* 112 */ { 3, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
//--------
/* 113 */ { 3, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver" },
/* 114 */ { 3, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver" },
//--------
/*   X */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver AnalyticClip" },
/* 116 */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/* 117 */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/* 118 */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradient4+PreAlpha] SrcOver" },
/* 119 */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[Image(0)+PreAlpha] Src" },
/* 120 */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*   X */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "CoverageMaskRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 122 */ { 3, "RP((BGRA8+D16 x1).rgba) + "
               "BitmapTextRenderStep[Color] + "
               "BlendCompose[RGBPaintColor, PrimitiveColor+PreAlpha+sRGB+Gamut+sRGB+PostAlpha, PorterDuffBlender] SrcOver" },
/* 123 */ { 3, "RP((BGRA8+D16 x1).rgba) + "                          //-----------------------------
               "AnalyticRRectRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
//--------
/* 124 */ { 2, "RP((R8+D16 x1).a000) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[BlendCompose[CoordNormalize[HardwareImage(0)]+AlphaOnly, RGBPaintColor, DstIn]] Src" },
/*   X */ { 2, "RP((R8+D16 x1).a000) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur4[LocalMatrix[ImageShaderClamp(0)+AlphaOnly]] Src" },
/*   X */ { 2, "RP((R8+D16 x1).a000) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur4[LocalMatrix[CoordNormalize[HardwareImage(0)]+AlphaOnly]] Src" },
//--------
/*   X */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "TessellateWedgesRenderStep[Convex] + "
               "SolidColor SrcOver AnalyticClip" },
/* 128 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver" },
/*   X */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 130 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/*   X */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverageMaskRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 132 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/* 133 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "BitmapTextRenderStep[Color] + "
               "BlendCompose[RGBPaintColor, PrimitiveColor+PreAlpha+sRGB+Gamut+sRGB+PostAlpha, PorterDuffBlender] SrcOver" },
/* 134 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
//--------
/*   ? */ { 2, "RP((BGRA8+D16 x4->1).rgba) + "                       //-----------------------------
               "TessellateWedgesRenderStep[Convex] + "
               "(empty)" },
/* 136 */ { 2, "RP((BGRA8+D16 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] DstIn" },
//--------
/* 137 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "TessellateStrokesRenderStep + "
               "SolidColor SrcOver" },
/*   X */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "SolidColor SrcOver AnalyticClip" },
/*   X */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 140 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/* 141 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+MatrixColorFilter SrcOver" },
/* 142 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/* 143 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/* 144 */ { 2, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "       //-----------------------------
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
//--------
/*   X */ { 2, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver AnalyticClip" },
/* 146 */ { 2, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Src" },
//--------
/* 147 */ { 2, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[ImageShaderClamp(0)+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/*   X */ { 2, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver AnalyticClip" },
/* 149 */ { 2, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver" },
/*   ? */ { 2, "RP((BGRA8+D16 x1).rgba) + "                          //-----------------------------
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*   X */ { 2, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur16[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]] Src" },
/* 152 */ { 2, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/* 153 */ { 2, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
//--------
/*   ? */ { 1, "RP((R8+D24_S8 x4->1).a000) + "                       //-----------------------------
               "TessellateWedgesRenderStep[EvenOdd] + "
               "(empty)" },
/*   ? */ { 1, "RP((R8+D24_S8 x4->1).a000) + "                       //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "SolidColor SrcOver" },
//--------
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "TessellateStrokesRenderStep + "
               "SolidColor SrcOver AnalyticClip" },
/*   ? */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] Multiply" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[YUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver AnalyticClip" },
/*   ? */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] Multiply" },
/*   ? */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[RadialGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*   ? */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[RadialGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*   ? */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*   ? */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "BlendCompose[LocalMatrix[RadialGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn]+Dither SrcOver" },
/*   ? */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "                    //-----------------------------
               "CoverBoundsRenderStep[RegularCover] + "
               "BlendCompose[LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn]+Dither SrcOver" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 169 */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+MatrixColorFilter SrcOver AnalyticClip" },
/* 171 */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+MatrixColorFilter SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "BitmapTextRenderStep[Color] + "
               "BlendCompose[BlendCompose[RGBPaintColor, PrimitiveColor+PreAlpha+sRGB+Gamut+sRGB+PostAlpha, PorterDuffBlender], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[RadialGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[RadialGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[RadialGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/* 179 */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
//--------
/*   X */ { 1, "RP((BGRA8+D16 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
/* 182 */ { 1, "RP((BGRA8+D16 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D16 x4->1).rgba) + "
               "AnalyticBlurRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "TessellateWedgesRenderStep[Convex] + "
               "SolidColor SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "TessellateStrokesRenderStep + "
               "SolidColor SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[RadialGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[RadialGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "BlendCompose[LocalMatrix[RadialGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[RegularCover] + "
               "BlendCompose[LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn]+Dither SrcOver" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 198 */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+MatrixColorFilter SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "CoverageMaskRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "BitmapTextRenderStep[Color] + "
               "BlendCompose[BlendCompose[RGBPaintColor, PrimitiveColor+PreAlpha+sRGB+Gamut+sRGB+PostAlpha, PorterDuffBlender], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/* 203 */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[RadialGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[RadialGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[RadialGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D24_S8 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "TessellateWedgesRenderStep[Convex] + "
               "(empty)" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "TessellateStrokesRenderStep + "
               "SolidColor SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver AnalyticClip" },
/* 215 */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "PerEdgeAAQuadRenderStep + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver AnalyticClip" },
/* 217 */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "BitmapTextRenderStep[Color] + "
               "BlendCompose[RGBPaintColor, PrimitiveColor+PreAlpha+sRGB+Gamut+sRGB+PostAlpha, PorterDuffBlender] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "SolidColor SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[HWYUVImageNoSwizzle+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x4->1).rgba w/ msaa load) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*    */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[ImageShaderClamp(0)+PreAlpha] DstIn" },
/*   X */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+KnownRuntimeEffect_Luma SrcOver AnalyticClip" },
/*   X */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "PerEdgeAAQuadRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "SolidColor Src AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[Image(0)+PreAlpha] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[HWYUVImage+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha] DstIn" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur8[LocalMatrix[ImageShaderClamp(0)+PreAlpha]] Src" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur16[LocalMatrix[Image(0)+PreAlpha]] Src" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur12[LocalMatrix[ImageShaderClamp(0)+PreAlpha]] Src" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "KnownRuntimeEffect_1DBlur12[LocalMatrix[Image(0)+PreAlpha]] Src" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradientBuffer+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradient8+PreAlpha]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[Image(0)+PreAlpha]+MatrixColorFilter+MatrixColorFilter Src" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[Image(0)+PreAlpha]+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/*   X */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+MatrixColorFilter SrcOver AnalyticClip" },
/* 242 */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+MatrixColorFilter SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "BlendCompose[LocalMatrix[LinearGradient4+PreAlpha+sRGB+Gamut+sRGB+PostAlpha], AlphaOnlyPaintColor, SrcIn]+Dither SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "BlendCompose[LocalMatrix[ImageShaderClamp(0)+PreAlpha], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha], PorterDuffBlender] Src" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverBoundsRenderStep[NonAAFill] + "
               "BlendCompose[LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+MatrixColorFilter, LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha]+BlendCompose[SolidColor, Passthrough, PorterDuffBlender], PorterDuffBlender] Src" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CoverageMaskRenderStep + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "CircularArcRenderStep + "
               "SolidColor SrcOver" },
/*   X */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver AnalyticClip" },
/* 250 */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "BitmapTextRenderStep[Mask] + "
               "SolidColor+BlendCompose[SolidColor, Passthrough, PorterDuffBlender] SrcOver" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "BitmapTextRenderStep[Color] + "
               "BlendCompose[BlendCompose[RGBPaintColor, PrimitiveColor+PreAlpha, PorterDuffBlender], AlphaOnlyPaintColor, SrcIn] SrcOver" },
/* 252 */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[CoordNormalize[HardwareImage(0)]+PreAlpha+sRGB+Gamut+sRGB+PostAlpha] SrcOver" },
/*   X */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver AnalyticClip" },
/*     */ { 1, "RP((BGRA8+D16 x1).rgba) + "
               "AnalyticRRectRenderStep + "
               "LocalMatrix[LinearGradient8+PreAlpha+sRGB+Gamut+sRGB+PostAlpha]+Dither SrcOver" },
};

bool skip(const char* str) {
    if (strstr(str, "AnalyticClip")) {  // we have to think about this a bit more
        return true;
    }
    if (strstr(str, "AnalyticBlurRenderStep")) { // currently internal only
        return true;
    }
    if (strstr(str, "KnownRuntimeEffect_1DBlur4")) {  // we have to revise how we do blurring
        return true;
    }
    if (strstr(str, "KnownRuntimeEffect_1DBlur16")) {  // we have to revise how we do blurring
        return true;
    }
    if (strstr(str, "KnownRuntimeEffect_Luma")) {  // this also seems too specialized
        return true;
    }

    return false;
}

// The pipeline strings were created using the Dawn Metal backend so that is the only viable
// comparison
bool is_dawn_metal_context_type(skgpu::ContextType type) {
    return type == skgpu::ContextType::kDawn_Metal;
}

} // anonymous namespace

// This test verifies that for each case in 'kPrecompileCases':
//    1) it covers some pipeline(s) in 'kCases'
//    2) more than 40% of the generated Precompile Pipelines are used (i.e., that over-generation
//        isn't too out of control).
// Optionally, it can also:
//    FINAL_REPORT:   Print out a final report that includes missed cases in 'kCases'
//    PRINT_COVERAGE: list the cases (in 'kCases') that are covered by each 'kPrecompileCases' case
//    PRINT_GENERATED_LABELS: list the Pipeline labels for a specific 'kPrecompileCases' case
// Also of note, the "skip" method documents the Pipelines we're intentionally skipping and why.
DEF_GRAPHITE_TEST_FOR_CONTEXTS(ChromePrecompileTest, is_dawn_metal_context_type,
                               reporter, context, /* testContext */, CtsEnforcement::kNever) {
    using namespace skgpu::graphite;

    std::unique_ptr<PrecompileContext> precompileContext = context->makePrecompileContext();
    const skgpu::graphite::Caps* caps = precompileContext->priv().caps();

    TextureInfo textureInfo = caps->getDefaultSampledTextureInfo(kBGRA_8888_SkColorType,
                                                                 skgpu::Mipmapped::kNo,
                                                                 skgpu::Protected::kNo,
                                                                 skgpu::Renderable::kYes);

    const bool msaaSupported = caps->getCompatibleMSAASampleCount(textureInfo) > SampleCount::k1;

    if (!msaaSupported) {
        // The following pipelines rely on having MSAA
        return;
    }

#ifdef SK_ENABLE_VELLO_SHADERS
    if (caps->computeSupport()) {
        // The following pipelines rely on not utilizing Vello
        return;
    }
#endif

    PipelineLabelInfoCollector collector({ kCases }, skip);

    static const size_t kChosenCase = -1; // only test this entry in 'kPrecompileCases'
    for (size_t i = 0; i < std::size(kPrecompileCases); ++i) {
        if (kChosenCase != -1 && kChosenCase != i) {
            continue;
        }

        if (i == MSAA_ONLY_CASE && !caps->loadOpAffectsMSAAPipelines()) {
            // If "w/ msaa load" strings aren't being generated, cases that only handle Pipeline
            // labels with that sub-string will never be matched.
            continue;
        }

        RunTest(context, precompileContext.get(), reporter, kPrecompileCases[i], i,
                { kCases },
                &collector,
                /* checkPaintOptionCoverage= */ true);
    }

#if defined(FINAL_REPORT)
    // This block prints out a final report. This includes a list of the cases in 'kCases' that
    // were not covered by the PaintOptions.

    collector.finalReport();
#endif
}

#endif // SK_GRAPHITE