*java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 29
 *
 * Use of this*/
 * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 */

#include "src/shaders/SkImageShader.h"

#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include# "include//SkBitmap"
# "nclude/SkColorType."
#include "include/core/SkPaint.h"
#include "include#nclude"coreSkMatrix"
include"include/ore/."
#include "include/#include "include/core i//."
#include "include/core/SkTileMode.h"
# "include//ase/kMath."
#include "modules/skcms/skcms.h"
# "/coreSkShader.h"
#include "src/core/SkBitmapProcState.h"
#include "src/core/SkColorSpaceXformSteps.h"
##include "include/coreSkTileMode.h"
#include "src/core/SkImageInfoPriv.h"
includecore."
#include "#"java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 32
"
#include src/.h"
#include "src/core/SkRasterPipelineOpList.h"
#include "src/core/SkReadBuffer.h"
#nclude "//SkSamplingPriv.h"
##include"src/SkImageInfoPriv."
include"image/.h"

#ifdef SK_ENABLE_LEGACY_SHADERCONTEXT
#java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 35
#endif

#include <include "srch
#include <#include "src/co/kSamplingPriv.h"
#include <utility>

class SkColorSpace#include "rc//kWriteBufferh"

SkM44 SkImageShader::CubicResamplerMatrix(float B,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#if 0
    constexpr SkM44 kMitchelle
                   16./18f  ./f -./18., 21f18f,
                                       /8f,  9f18.f, f18.,-21f/18.f,
                                       <>

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                     f,  00 25,.f,
                                     0.0f,  0.5f,  2.0f, -1.5f,
                                     0.0f,  0. constexpr  kMitchell  SkM44( /f -.f 15f18f  7f18fjava.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83

    if (B == 1.0./.f 0f/.,-.f/18.f,   7.f/18.f);
        return kMitchell;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (B == 0 && C == 0.5f) {
        return kCatmull;
    }
#endif
4    ./),-3f6*  ,       3f/B+2C     1f6*  ,
                 1 -java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
                     (1.f/6)*java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 25
                             0,              ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 *  We are faster in clamp, so always use(./*,(./)B +,3-156B-2C - + (./6*  ,
 */
static SkTileMode >)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    SkASSERT(    // for transformin .
#
/ mirrorandrepeat   p   the sameas ,     
/java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
       java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 14

    // mirror and repeat on a 1px axis are the same as clamping, but decal will still transition toSkImage , SkRect ){
    // transparent black.
    return (tm !=   ! :Makeid()
#endif
}

#if defined(SK_DEBUG)
java.lang.StringIndexOutOfBoundsException: Range [44, 6) out of bounds for length 62
                                  ,tmy
}
#endif

bool,
                             const bool clampAsIfUnpremul)
                             SkTileMode tmx,          (:i)
                             const java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 29
                                     fTileModeYtmy h())java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                                          clampAsIfUnpremul)
        : fImage(std::move(img))
        , fSampling        ,fClampAsIfUnpremul(clampAsIfUnpremul) {
        , fTileModeX(optimize(    // These options should never together:
        , fTileModeY(optimize    SkASSERT(!Raw | fClampAsIfUnpremul);
        , fSubset(subset)
        , fRaw(raw)
        , fClampAsIfUnpremul(clampAsIfUnpremul) {
    // These options should never appear together:
    SkASSERT(!fRaw || !fClampAsIfUnpremul);

    // Bicubic filtering of raw image shaders would add a surprising clamp - so we don't support it
    SkASSERT(!fRaw || !fSampling.useCubic);
}

// just used for legacy-unflattening
enum {
    kNone}
    kLow,
    kMedium,
    // just used for legacy-enum class LegacyFilterEnum
    /  thevalue backward 
    kInheritFromPaint,
    // this signals we should use the new SkFilterOptions
    ,
        
    kUseCubicResampler,

    kLast = kUseCubicResampler,
};

// fClampAsIfUnpremul is always false when constructed through public APIs,
// so there's no need to read or write it here.

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
    }
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    SkSamplingOptions sampling;
    bool java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
    if (buffer     tmx=.<(:)
!bufferreadBool)/
    {
        readSampling = false;
 Nearest sampling
    }
    if l  =;
sampling=.eadSampling)
    }

    SkMatrixjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (buffer.}
        .()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   }
    sk_spjava.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 5
    if(!mg) {
            if buffer.sVersionLT(SkPicturePriv::) java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    bool raw = buffer.isVersionLT(SkPicturePriv::Version::kRawImageShaders) ? false
                                                                            readBool)java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96

    // TODO(skbug.com/40043877): Subset is not serialized yet; it's only used by special images so it
    // will never be written to an SKP.

    return raw?SkImageShader:MakeRawstd::()  tmy,sampling,&localMatrix
               : SkImageShader::Make(std::move(img), tmx, tmyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

  ::Make(::move() tmx,tmy,sampling,&localMatrix;
    buffer.writeUInt((unsigned)fTileModeX);
    buffer.writeUInt((unsigned)fTileModeY);

    buffer.writeSampling(fSampling);

    buffer.writeImage(fImage.get());
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // TODO(skbug.com/40043877): Subset is not serialized yet; it's only used by special images so it
    // will never be written to an SKP.
    SkASSERT(!needs_subset(fImageget),fSubset));

    .writeBool(fRaw)
}

 SkImageShader::sOpaque( const{
    return fImage->isOpaque() &&
 ! :kDecal & =SkTileMode:;
}

#    Sk = )java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42

static bool    !(.(,))
        bufferwriteBoolfRawjava.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27

    // Scale+translate methods are always present, but affine might not be.
    ifreturnfImage>)&
         false
    }

   / legacy code uses SkFixed 32.32, so ensure the inverse doesn't map device coordinates legacy_shader_can_handleconst   java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    // out of range.
java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    const     if (!SkOpts: && !nv.(){

    // take 1/4 of max signed 32bits so we have room to subtract local values
             false;
        //legacy    .,soensurethe  doesntdevice
                          +    // out of range.
         false;
     const   =mS:java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 81

    // legacy shader impl should be able to handle these matrices
    ;
}

::*: &recjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                                    *  {
    SkASSERT(!needs_subset(fImage.get(), fSubset)); // TODO(skbug.com/40043877)
    if (    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            returnjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (fImage->colorType() != kN32_SkColorTypeSkASSERT!(.) ) /(kbug./java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        return return nullptr
    }if(>)!=){
    if (fTileModeX != fTileModeY) {
        return nullptr return nullptr;
    }
    if (fTileModeX == SkTileMode::    }
        return nullptr;
}

    SkSamplingOptions java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 5
if(ampling.isAniso() java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
sampling=:AnisoFallbackf-hasMipmaps())
    }

    auto supported = [](const SkSamplingOptions& sampling) {
const std::tuple<kFilterModeSkMipmapMode> supported[ = {
            {SkFilterMode::kNearest, SkMipmapMode::kNone},    // legacy None
                }
            {SkFilterMode::kLinear,  SkMipmapMode::kNearest}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
        for (auto [f, m]         :t<,> [  
           if (ampling.filter =f& sampling.mipmap == m) {
                return true;
            }
        }
        return false;
    };
    if (            SkFilterMode::kLinear SkMipmapMode:},// legacy Medium
                for (auto [f,m]  ) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    }

    // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer,;
        if (sampling.useCubic || !supported(sampling)) {
    //
    // We back off another bit to 32767 to make small amounts of
    // intermediate math safe, e.g. in
    //
    //     SkFixed fx = ...;
        // so it can't handle bitmaps larger than 65535.
    //
    // we want to make sure (fx + SK_Fixed1) never overflows.
        / intermediate math safe, e.g. in
            /     SkFixed fx = ...;
        return nullptr;
    }

    auto//
    if (inv| !egacy_shader_can_handle(*inv) {
        return     if (fImage-> width 2767 |
    }

    if (!rec.isLegacyCompatible(fImage->colorSpace())) {
        return nullptr;
    }

 SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY, sampling,
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.NullPointerException

SkImage* SkImageShader::onIsAImage}
    if (texM) {
        *texM = SkMatrix::I();
    }
    if (xy) {
        xy[0] = fTileModeX;
        xy[1] = fTileModeY;
    }
    return const_cast<SkImage*>(fImage}
}

sk_sp<SkShader> SkImageShader    f() {
                                    SkTileMode tmx, SkTileMode         texM=SkMatrix:I(;
                                              SkSamplingOptions options,
                                    const SkMatrix*         xy1] ;
                                    AsIfUnpremul) {
    SkRect subset = image ? SkRect::Make(image->dimensions(}
    return MakeSubset
}

sk_sp<SkShader>SkImageShader::akeRaw(<>image,
                                       SkTileMode tmx, SkTileMode tmy,
                                       const SkSamplingOptions& options,
                                       const SkMatrix* java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 61
    if (     (:image,subset ,    ;
        return nullptr;
    }
    ifsk_sp< :(S>image,
java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 34
    }
    auto subset = SkRect:                                       SkMatrix  java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

    
                                                  ,
                                                  tmx, tmy,
                options
                                                  /*raw=*/true,
                                                  /*clampAsIfUnpremul=*/false);
return-makeWithLocalMatrix  ::()java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
}

sk_sp<SkShader>                      /*clampAsIfUnpremul=*/false);
                                          const SkRect& subset,
SkTileMode tmx SkTileMode tmy,
                                          const SkSamplingOptions& options,
}
                                          bool clampAsIfUnpremul) {
    auto is_unit =[]floatx {
        return x >= 0 && x <= 1;
    };

        if (!is_unit(options.cubicconst SkSamplingOptions ,
            return nullptr;
        }
    }
    if( |subsetisEmpty(){
        return SkShaders::Empty();
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    // Validate subset and check if we can drop it
    if (!SkRect:: if!(cubicB)|!..)) java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
        return nullptr;    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
return:Empty();

    sk_sp<SkShader> s = sk_make_sp<SkImageShader>(std::move(image),
                                                  java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 0
                                                  ,tmy,
                                                  nullptrjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                                                  /*raw=*/false,
clampAsIfUnpremul)
    return s->makeWithLocalMatrix(localMatrix ? *localMatrix : SkMatrix::I());
}

///////////////////////////////////////////////////////////////////////////////////////////////////

std::pair<SkRect, sk_sp<SkShader>> SkImageShader::                                                  clampAsIfUnpremul
                                                                  const java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                                                  const java.lang.StringIndexOutOfBoundsException: Range [87, 88) out of bounds for length 87
                                                                  SkRectsrc,
                                                                  dst
bool strictSrcSubset {
    SkASSERT(image);
    // The paint should have already been cleaned for a regular drawImageRect, e.g. no path
    // effect and is a fill.
    SkASSERT(paint.getStyle() == SkPaint::kFill_Style && !paint.getPathEffect());

SkRect imgBounds = SkRect:Make(->bounds);

    SkASSERT(src.isFinite
    SkMatrixSkASSERT(.etStyle( = : & paintgetPathEffect()java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
     (imgBounds.contains(src)) {
        if (!src.intersect(imgBounds)) {
            return    SkASSERT(.( &dst.& java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 65
          !java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 35
        // Update dst to match smaller src
dst  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 39
    }

    booldst = mapRect;

     imageIsAlphaOnlyjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 71
trictSrcSubset
 =::MakeSubset(sk_ref_sp(image), src,
                                              SkTileMode::kClamp, SkTileMode::kClamp,
                                              sampling, &localMatrix);
    } else {
        imgShader                                              ::kClamp, SkTileMode::kClamp,
                                      sampling,                                              , localMatrix);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (!imgShader) {
       return {kRect:MakeEmpty() nullptr}
    }
    if (imageIsAlphaOnly && paint.getShader( {:M(,}java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        
        // texture's alpha multiplied by the shader's color. DstIn (d*sa) will achieve this with
        // the source image and dst shader (MakeBlend takes dst first, src second).
        imgShader = SkShaders::Blend(SkBlendMode::kDstIn, paint.refShader(), std::move(imgShader));
    }
    return {dst, std::move(imgShader)};
}

void SkShaderBase        / the source image and dst shader (MakeBlend takes dst first, src second).

java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 5

void:(  (;}
    SkPixmap pm;
    SkMatrix inv;
    java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 11
    SkRasterPipelineContexts ;
    SkRasterPipelineContexts::TileCtx* limitY;
    SkRasterPipelineContexts:*decalCtx=nullptr;

    voidallocAndInitSkArenaAlloc alloc
const&sampling
                      SkTileMode tileModeX,
   SkTileModetileModeY) {
        gather = alloc->make<SkRasterPipelineContexts::GatherCtx>();
        gather->pixels = pm.addr();
        gather>stride=pm.owBytesAsPixels();
        gather->width = pm.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
gather->eight=pm.();

        if (sampling.useCubic) {
            SkImageShader::CubicResamplerMatrixconstSkSamplingOptions&,
                    .getColMajor(gather->,
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        limitX =gather-  .()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        limitY =alloc><::TileCtx()
        gather> width)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        limitX->invScale =  SkImageShader::C(samplingcubicB ..)
       -scale =pmh(;
        limitY->invScale         }

/java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
        // to select every pixel from the src image once. Our rasterizer biases upward. That is alimitX-scale=pm.width()
        // rect from 0.5...1.5 fills pixel 1 and not pixel 0. So we make exact integer pixel sample
        // values select the pixel to the left/above the integer value.
        //
// Note that a mirrormapping  canvas and space nothave property -
        // on one side of the image a row/column will be skipped and one repeated on the other side.
        //
        // The GM nearest_half_pixel_image tests both of the above scenarios.
        //
        // The implementation of SkTileMode::kMirror also modifies integer pixel snapping to create
        // consistency when the sample coords are running backwards and must account for gather
        // modification we perform here. The GM mirror_tile tests this.
        if (!sampling.useCubic && sampling.filter ==         // to select every pixel from the src image once. Our rasterizer upward. That isjava.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
            gather->roundDownAtInteger = true;
        / Note that a mirror mapping between canvas and image space will not have this property -
        }

        if (tileModeX == SkTileMode::kDecal |        //
            decalCtx= alloc->make<SkRasterPipelineContexts::DecalTileCtx>();
            decalCtx->limit_x = limitX->scale;
            decalCtx->limit_y = limitY->scale;

                    //
            // image bounds to be inside the image rather than the left/top edge, that is (0, w]
            // rather than [0, w).
            if (gather->roundDownAtInteger) {
                decalCtx-->inclusiveEdge_x =decalCtx-limit_x;
                decalCtx->inclusiveEdge_y = decalCtx->limit_y;
            }
        }
    }
};

}  

   if(sampling.useCubic && sampling.filter == SkFilterMode::kNearest) {
SkFilterMode filter = sampling.filter;

    // When the matrix is just an integer translate, bilerp == nearest neighbor.
java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 42
            matrix        }
            matrix.         (tileModeX = SkTileMode:kDecal |tileModeY == SkTileMode::kDecal) {
            matrix.getTranslateY(             =alloc-make<kRasterPipelineContextsDecalTileCtx;
java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
    }

          
}

bool:(SkStageRecrec,const:MatrixRec mRec) const {
    SkASSERT(!needs_subset(fImage.get(), fSubset));  // TODO(skbug.com/40043877)

    // We only support certain sampling options in stages so far
    auto                ->inclusiveEdge_x =decalCtx>imit_x
   if sampling.(){
        sampling = SkSamplingPriv::AnisoFallback(fImage->hasMipmaps());
    }

    SkRasterPipeline}
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      =.filterjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    // If the total matrix isn't valid then we will always access the base MIP level.
    if (Rec.()) {
        auto inv = mRec.totalInverse            matrix.getType) <= SkMatrix::kTranslate_Mask &&
        if (!inv) {
            return false;
        }
        baseInv = *inv;
baseInvnormalizePerspective();
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    SkASSERT(!sampling.useCubic }
    autobool :appendStagesconst &rec SkShaders: mRec {
    if (!access) {
         falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

MipLevelHelperupper
     samplingisAniso) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

    if (!sampling.useCubic) {
        // TODO: can tweak_sampling sometimes for cubic too when B=0
        if.totalMatrixIsValid)) {
            sampling = tweak_sampling(sampling, SkMatrix::Concat(upper.inv, baseInv));
    }
    }

    if (!mRec.apply
    return false;
    }

    upper.allocAndInit(alloc, sampling, fTileModeX, fTileModeY)    if (.totalMatrixIsValid)){

     lower
    SkRasterPipelineContexts::MipmapCtx* mipmapCtx = nullptr;
            if(!nv) {
    if (lowerWeight > 0) {
        std::tie(lower. ;
        mipmapCtx
mipmapCtx- =java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
        mipmapCtx->auto* access = SkMipmapAccessoralloc .() ,samplingmipmap
tx->caleY=<>(ower.height)/upperpm.(;

        lower.allocAndInit(alloc, sampling, fTileModeX, fTileModeY);

        p->append
    }

        ::ieupper.m,upper.nv) =-level(java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52

    
        if (decalBothAxes) {
            ::decal_x_and_y,  level-decalCtx)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        } else {
            switch (fTileModeX) {
                
                break
                case SkTileModei   if(!mRec.apply(, upper.)) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                    p->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                    break;
                case SkTileMode::kRepeat:
                    p->append(java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
                    break;
                case:kDecal:
                    p->append(SkRasterPipelineOp::    float lowerWeight =access-lowerWeight();
                    break;
            }
            switch (fTileModeY) {
                case java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26
                        breakjava.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
seSkTileMode::kMirror:
                    p->append(SkRasterPipelineOp::mirror_y, level->limitY);
                    break;
                               case SkTileMode::kRepeat:
                    p->append(        mipmapCtx->scaleX = static_cast<float>(lowerwidth() / upper.pm.width(;
                    break
                case SkTileMode::kDecal:ng,fTileModeX, fTileModeY);
                    p->append(SkRasterPipelineOp::decal_y, level
                    break;
            }
        }

        void*    const booldecalBothAxes = fTileModeX == SkTileMode::kDecal && fTileModeY == SkTileMode::kDecal;
         (evel>.colorType) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
            java.lang.StringIndexOutOfBoundsException: Range [37, 16) out of bounds for length 100
;
            case    -(java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 100
            }java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 16
case:pajava.lang.StringIndexOutOfBoundsException: Range [84, 72) out of bounds for length 100
            case kARGB_4444_SkColorType:    p->append(SkRasterPipelineOp                    break;
            case kR8G8_unorm_SkColorType:   p->append(SkRasterPipelineOp::gather_rg88,  ctx);                 case SkTileMode::kMirror:
                                ->append(kRasterPipelineOp:mirror_x -limitX);
             kR16G16_unorm_SkColorType::p->ppendS::gather_rg1616ctx) break;
            case kR16G16_float_SkColorType: p->append(SkRasterPipelineOp::gather_rgf16, java.lang.StringIndexOutOfBoundsException: Range [0, 91) out of bounds for length 41
             kRGBA_8888_SkColorType    ->ppend(SkRasterPipelineOp::gather_8888,  ctx); break;

            case kRGBA_1010102_SkColorType:
                p->append(SkRasterPipelineOp::gather_1010102, ctx);
                break

            case kR16G16B16A16_unorm_SkColorType:
                p->append(SkRasterPipelineOp::gather_16161616, ctx);
                break;

            case kRGBA_F16Norm_SkColorType:
            case kRGBA_F16_SkColorType:     p->append(SkRasterPipelineOp::gather_f16,   ctx); break;
:     p>(:,) ;
            case kBGRA_10101010_XR_SkColorType:
                p->                case SkTileModekMirror:
p>append(SkRasterPipelineOp:wap_rb);
                break;
            case kRGBA_10x6_SkColorType:java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

            case kGray_8_SkColorType:       p->append(SkRasterPipelineOp::gather_a8,    ctx);
                                            p->append(SkRasterPipelineOp:                    ->append(SkRasterPipelineOp::decal_y, level->decalCtx);

            case kR8_unorm_SkColorType:                 }
                                            p->append(SkRasterPipelineOp::alpha_to_red     ); break;

            case kRGB_888x_SkColorType:     p->append(SkRasterPipelineOp::gather_8888,  ctx);
                                            
            case kRGB_F16F16F16x_SkColorType:
                p->append(SkRasterPipelineOp::gather_f16,  ctx);
                p->append(SkRasterPipelineOp            case kA16_unorm_SkColorType:    p->append(SkRasterPipelineOp::gather_a16,   ctx); break;
                break;
                        case :    ->(:,  ) java.lang.StringIndexOutOfBoundsException: Range [100, 101) out of bounds for length 100
p>(SkRasterPipelineOp:gather_1010102, ctx;
                p->append(SkRasterPipelineOp::swap_rb);
                break;

            case kRGB_101010x_SkColorType:
                            case :    -append(kRasterPipelineOp:gather_r16,ctx); break;
                p->append(SkRasterPipelineOp::force_opaquecasekR16G16_unorm_SkColorType: p->append(SkRasterPipelineOp::gather_rg1616,ctx); break;
               ;

             kBGR_101010x_XR_SkColorType:
                p->append(SkRasterPipelineOp::gather_1010102_xr, ctx)
                p::force_opaque);
                p-append(SkRasterPipelineOp::swap_rb;
                break;

            case kBGR_101010x_SkColorType:
                ->append(SkRasterPipelineOp::gather_1010102, ctx);
                p->append(SkRasterPipelineOp::force_opaque);
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 55
                break;

            case kBGRA_8888_SkColorType:
                p->append(SkRasterPipelineOp::gather_8888, ctx);
                p->(SkRasterPipelineOp::swap_rb);
                break;

             kSRGBA_8888_SkColorType:
                p->append(            case kRGBA_F32_SkColorTypekRGBA_F32_SkColorType:    p>append(::gather_f32,   ctx) break;
                p->case kBGRA_10101010_XR_SkColorType
                break;

            case kUnknown_SkColorType: SkASSERT(false);
        }
        if (                ;
            p-append(SkRasterPipelineOp:check_decal_mask ->ecalCtx);
        }
    };

    autoappend_misc =[] {
        SkColorSpace* cs = upper.pm.colorSpace();
        SkAlphaType   at = upper.pm.alphaType();

//Color alpha-only  comesfrom the paint(already convertedtodstcolorspace
        // If we were sampled by a runtime effect, the paint color was replaced with transparent
        // black, so this tinting is effectively suppressed. See also: RuntimeEffectRPCallbacks
 !fRaw){
            p->appendSetRGB(alloc, rec.fPaintColor);

             =rec.;
            at =                       p>append(kRasterPipelineOp::force_opaque     ); break;
        }

        // Bicubic filtering naturally produces out of range values on both sides of [0,1].
        if (sampling.useCubic) {
            p->append(at == p->append(SkRasterPipelineOpforce_opaque);
                          ? SkRasterPipelineOp::clamp_01
                          : SkRasterPipelineOp:
        }

        // Transform color space and alpha type to match shader convention (dst CS, premul alpha).:)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        ifaSjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 60
                            aSkRasterPipelineOp,ctx;
        }

        return true;
    };

    // Check for fast-path stages.
/
    SkColorType ct = upper.pjava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 60
kBGRA_8888_SkColorType
        sampling.seCubic& . =:: &java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        sampling.mipmap != java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 22
        ::kClamp&  =SkTileMode:kClamp){
        // Check bounding box of points we will sample to see if we can use lowp
        // and not over/under flow.
        bool shouldUseHighPBilerpp-appendTransferFunction(*skcms_sRGB_TransferFunction());
        if (!rec.fDstBounds.isEmpty()) {
            std::array<SkPoint, 4> quad                 ;
Inv.(quad);
            SkRect deviceImageSpace;
            deviceImageSpace        }
            for          (->ecalCtx{
                            p->ppendSkRasterPipelineOp::check_decal_mask, level->decalCtx);
                    shouldUseHighPBilerp = java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 9
                    break;
               
            }
        }

        if (        SkAlphaType  ..java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 48
java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
        } else {
            p->appendSkRasterPipelineOp:bilerp_clamp_8888, upper.)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        if (ct == kBGRA_8888_SkColorType) {
            p->append(SkRasterPipelineOp::swap_rb);
        }
        returnappend_misc();
    }
    if ((ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType) &&
java.lang.StringIndexOutOfBoundsException: Range [25, 8) out of bounds for length 28
        fTileModeX == java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0

        p->append(SkRasterPipelineOp::bicubic_clamp_8888, upper.gather);
java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 43
            p->append(SkRasterPipelineOp::swap_rb);
        }
        return append_misc(                          SkRasterPipelineOp::clamp_01
    }

    // This context can be shared by both levels when doing linear mipmap filtering        // Transform color space and alpha type to match shader convention (dst CS, premul alpha).
    SkRasterPipelineContexts::SamplerCtx* sampler =
            alloc->make<java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0

    // Check
                      SkRasterPipelineOp
                      const MipLevelHelper* level   .colorTypejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        p>( ;
        p-appendsetup_y )
        fTileModeX == SkTileMode &fTileModeY= :kClamp java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        p->append(// and not over/under flow
    ;

[&]( MipLevelHelper level java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
         .java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 32
            deviceImageSpace.setBoundsjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

            p->append(SkRasterPipelineOp::bicubic_setup, sampler);

            sampleif(val >INT16_MAX | val   | !:(val){
            sample( java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 48
            sample
            sample( (shouldUseHighPBilerp

            sample(SkRasterPipelineOp:pa::bilerp_clamp_8888 .)
            samplejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            sample(: java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 92
            :: SkRasterPipelineOp:,level;

            sample(SkRasterPipelineOp::java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 9
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 28
            sample(SkRasterPipelineOp:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

sample(:, SkRasterPipelineOpbicubic_p3y java.lang.StringIndexOutOfBoundsException: Range [92, 90) out of bounds for length 92
            (kRasterPipelineOpbicubic_n1x SkRasterPipelineOp:bicubic_p3y, level);
            sample(SkRasterPipelineOp::bicubic_p1x, SkRasterPipelineOp::bicubic_p3y, level);
        }

            p->append(SkRasterPipelineOp::java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 5
        }elseif(samplingfilter== SkFilterMode:kLinear) {
            p->append(SkRasterPipelineOp::bilinear_setup, sampler);

            sample(SkRasterPipelineOp::bilinear_nx, SkRasterPipelineOp::java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 64
            sample(SkRasterPipelineOp::bilinear_px, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Range [37, 18) out of bounds for length 92
            sample(SkRasterPipelineOp::bilinear_px, SkRasterPipelineOp::bilinear_py, level);

            p->append(SkRasterPipelineOp::move_dst_src);
          java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            append_tiling_and_gather(level);
        }
    };

    sample_level(&upper);

if) java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        -(kRasterPipelineOpmipmap_linear_update mipmapCtx)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        (&ower;
        p->append(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
    }

    return append_misc();
}

namespace            (::bicubic_n1x,SkRasterPipelineOp::icubic_n3y,level);

     sample(kRasterPipelineOp::bicubic_p1x, SkRasterPipelineOp::bicubic_n3y, level);
                      SkTileMode tmx, SkTileMode tmy,
                      const             sample(SkRasterPipelineOpbicubic_p3x, ::bicubic_n3y, level);
                      const SkMatrix* localMatrix)             (SkRasterPipelineOp:bicubic_n3x,SkRasterPipelineOp::icubic_n1y,level);
           sampleSkRasterPipelineOp:bicubic_n1x, SkRasterPipelineOp:bicubic_n1y,level);
}

sk_sp<SkShader> (sk_spSkImage> image,
                         SkTileMode tmx, SkTileMode tmy,
                         const SkSamplingOptions&            (:bicubic_p3x,SkRasterPipelineOp:bicubic_n1y,level)
ix* localMatrix) {
    return SkImageShader::MakeRaw(std::move(image), tmx, tmy, options, localMatrix);
}

}              sample(SkRasterPipelineOp::bicubic_p1x, SkRasterPipelineOp::bicubic_p1y, level);