/*
  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 * java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
*All rights reserved.
  mov             ,
* and use in source and binary forms,with or 
*modification are permitted provided that  following conditions are metjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 *
                   , gaussian_sequence)
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above        ldr               r1,#FGD_SEED]
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 *        addr9 r9,#4
 * ANY  ldr             , r5,,lsl#
  WARRANTIES OF  AND    PARTICULAR PURPOSE ARE
 *       s16 
java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  INCLUDING,BUT  LIMITED , PROCUREMENT  SUBSTITUTEGOODS  SERVICES;
 * LOSS OF USE, DATA, OR        ,  0
 * ON ANY THEORY        /immediate ,to  armv8  itinstruction .
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 * SOFTWARE, EVEN IF ADVISED OF THE         neg             lr,  lr             // 
 */

#include "src/arm/asm.S"
#include "util lsl            r10,r10 r9        /1< 4+data-grain_scale_shiftjava.lang.StringIndexOutOfBoundsException: Range [81, 82) out of bounds for length 81
#include "src/arm/asm-offsets.h"

#define GRAIN_WIDTH r10 ,#        /1< 4+datagrain_scale_shift-1
#define GRAIN_HEIGHT 73

#define SUB_GRAIN_WIDTH 44
#define SUB_GRAIN_HEIGHT 38

.macro increment_seed steps, shift=1
        lsr             r11, r2,  #3
        lsr             r12, r2,  #12
        lsr             lr,  r2,  #1
        eor             r11, r2,  r11                     // (r >> 0java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Range [36, 8) out of bounds for length 81
        eor             r11, r11, r12                     // (r >> 0) ^ (r >> 3) ^ (r >> 12) ^ (r >> 1)
i\
        lsr             r2,  r2,  #\steps
.endif
        and             ,r11,#(< \steps)-1    /bit
.if \shift
        orr             r2,  r2,  r11, lsl #(16 - \.word L(generate_grain_\type\()_lag3) - L(gen_grain_) +CONFIG_THUMB
.else
        orr             r2,  r2,  r11, L(\ype\)lag0)
.endif
.endm

.macro read_rand dest, bits, age
        ubfx            \dest,  r2,   #16 - \bits - \age, #\bits
.endm

.macro read_shift_rand dest,bl              generate_grain_rows_neon
        ubfx            \dest.lse
        lsr             r2,  r2,  #1
.endm

// special calling convention:
// r2 holds seed
/ r3  dav1d_gaussian_sequence
// clobbers r11-r12
// returns in d0-d1
function         sub                ,r5, 1/ 128< bitdepth_min_8  1
        push            {r5-r6,lr}
        increment_seed  4
        read_rand       r5,  11,  3
        read_rand
        add             r5,  r3,  r5,  lsl #1
        add             r6,  r3,  r6,  lsl #1
        vld1.16         {d0[0]}, [r5]
        read_rand       r5,  11,  1
        vld1.16         {d0[1]}, [r6]
        add             r5,  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        read_rand       r6, 11,  0
4
        add             r6,  r3,  r6,  lsl #1
        vld1.16         {d0[2]}, [r5]
        ead_rand       r5,  11,  3
        vld1.16         {d0[3]}, [r6]
        add             r5,  r3,  r5,  lsl #1
        read_rand       r6,  11,  2
        vld1.16         {d1[0]}, [r5]
        addr6, r3  r6  lsl #java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        read_rand       r5,  11,  1
        [1]}, [6]
        read_rand       r6,  11,  0
        add             r5,  r3,  r5,  java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 31
                     , r6,  lsl 1
        vld1.16         {d1[vdup.16 q9, r5
        vld1.16         {d1[3]}, [r6]
        java.lang.StringIndexOutOfBoundsException: Range [27, 11) out of bounds for length 34
endfunc

function get_grain_2_neon
        push            {        vext.8          q13,  q1,#java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        increment_seed2
        read_rand       r11, 11,  1
        vneg.s32q12,q12
        add             r11, r3,  r11, lsl #1
                 r12, r3,r12,lsl 1
        vld1.16         {d0[0]}, [r11]
        vld1.16         {d0[1]java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 2
        vrshl.s16       d0,  d0,  d30
        pop                                    // java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
endfunc

.macro get_grain_2 dst
        bl              get_grain_2_neon
. \,d0
        vmov            \dst, d0
.endif
.endm

function get_grain_4_neon
        push            {r11,lr}
        increment_seed  4
        read_rand       r11, 11,  3
        read_rand               bl              / 32
        , lsl #
        add             r12, r3,  r12, lsl #1
        vld1.16         {d0[0]        bl               // 48
        read_rand       r11,  bl              gen_grain_uv_444_lag0_neon/ 56
        vld1.16         {d0[1]}, [r12]
        read_rand       r12, 11,  0
        add             r11, r3,  r11, lsl #1
        add             r12, r3,  r12, lsl #1
        vld1.16         {d0[2]}, [r11]
        vld1.16         {d0[3]}, [r12]
        vrshl.s16       d0,  d0,  d30
                     r11pc}
endfunc

.macro get_grain_4 dst
        bl              get_grain_4_neon
.ifnc \dst, d0
         // 80
.endif
.endm

//r1   numberof  to produce
// r6, r8 and r10 hold the previoussubs            , , 1
// q0 addr11 r11,#
// q1 holds the input vector of sums from above
.acro  
function output_lag\n\()_neon
        push            {r0                     b
.if \n == 1
        mvn             lr,  r5                   // grain_min = .ndif
.else
        mov             r0,  #1
        mov             pop             r4-,pc}
        sub             r7,  r7,  #1
        sub             r9,  r9,  #1
        lsl             r0,r0  r7
        lsl             lr,  lr,  r9
        ,  #1
        add             r9,  r9,  #1
.endif
1:
        read_shift_rand r12, 11
        vmov.32         r11, d2[0]
        lsl                     lsl             r5, r5,         /128 <<bitdepth_min_8
        vext.8          q0  , 1       /( <)-1
        ldrsh           r12,        vld1.          d27] r4]      /ar_coeffs_y0
i \= java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        mla             r11,r6, ,          /  ()+*  prev output
        add             r6,  r11, r8              // 1 << (ar_coeff_shift - 1)
        add             r12, r12, r10
        asrr6 r6,r7              / > ar_coeff_shift
        asr             r12, r12, r9              // >> (4 - bitdepth_min_8 + grain_scale_shift)
        add             r6,  r6,  r12
        ,  r5
.elseif \n == 2
        mla             r11,e
        mla             r11, r6,  r10, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
        mov             r8,  r6
                     ,r11,r0              /1< (r_coeff_shift  1)
        add             , r12,lr              /1<<( -bitdepth_min_8  grain_scale_shift-1java.lang.StringIndexOutOfBoundsException: Index 102 out of bounds for length 102
                     ,r6,               / > ar_coeff_shift
        asr             r12, r12, r9              // >> (4 - bitdepth_min_8 .ndif
        bl              
        push            {lr}
        cmp             r6  r5
        mvn             lr,  r5                   // grain_min = ~grain_max
.else
        push            {r1-r3}
                    r1, #, 8
        sbfx            r2,  r4,  #8,  #8
        sbfx            r3,  r4,  #16, #8
        .ifc \type
        mla             r11, r8,  r2,  r11        // sum (        .q6 d13
        mlaendif
        pop             {r1-r3}
        mov             r10, r8
        mov             r8,  r6                     ,#GRAIN_HEIGHT  3

        add             r6,  r11, r0              // 1 << (ar_coeff_shift - 1)
        add             r12                      \sum_\)lag1_mid_neon   / 16
        asr             r6,  r6,  r7              // >> ar_coeff_shift
        asr             r12, r12, r9              // >> (4 - bitdepth_min_8 + grain_scale_shift)
        add             r6,  r6,  r12
        push            {lr}
        cmp             r6,r5
        mvn             lr,  r5                   // grain_min = ~grain_max
.endif
        it              gt
        movgt           r6,  r5
        cmp             r6,  lr
        it              lt
        movlt           ,  
.if \n >= 2
        op             {r}
.endif
        subs            r1,  r1,  #1
        vext.8          q1,  q1,  q1,  #4
        vmov.16         d1[3],        bl              sum_\ype\)lag1_right_neon/80
        bgt1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
pop             r0,pc}
endfunc
.endm

output_lag 1
output_lag 2
3


function sum_lag1_above_neon
        sub             r12, r0,  #1*GRAIN_WIDTH add             ,r11,#
        vld1.16         {10,[]/ load top right

        vext.8        bgt1b
        vext.8          q1,  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        vmull.s16       q2,  d18, d28
        mlal.s16       , d0, d27
        vmlal.s16       q2,  d2,  d29
        vmull.s16       q3,  d19, d28
        vmlal.16      ,d1,d27
        vmlal.s16       q3,  d3,                   {4-}

        vmov            q8,          mov             r5,  #1
        vmov            , q10

        bx              lr
endfunc

.macro sum_lag_n_body lag, type, uv_layout, edge, elems, uv_coeff
.ifc \vld1.          d28d29} r4]    /ar_coeffs_y011,ar_coeffs_uv[-]
        bl              sum_lag3_left_above_neon
.else
        bl              sum_\lag\        vmovs8,2java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
.endif
.ifc \        mo r1  3
        vpush           {q6-q7}
        add             r12, r11, #b 
        vld1.16         {q0, q1},
        ]!
        vpadd.i16       d0,  d0,  d1
        vpadd.i16       d1,  d2,  d3
        vpadd.i16       d12, d12, d13
        vpadd.i16       d13, d14, d15
        vadd.i16        q0,  q0,  q6
        vpop            {q6-q7}
        vrshr.s16       q0,  q0,  #2
.endif
.ifc         bl              sum_\ype(_   // 24
        vld1.16         {q0, q1}, [r11]!
        vpadd.i16       d0,  d0,  d1
        vpadd.16d1  d2,  d3
        vrshr.s16       q0,  q0,  #1
.    bl              \ype(_   /48
.ifc \type, uv_444
        vld1.16         {q0}, [r11]!
.endif
.if \uv_layout
.ifnb \uv_coeff
        vdup.8          d13, \uv_coeff
        .s8        q6  d13
.endif
        vmlal.s16       q2,  d0,  bl              sum_\type\()_/ 2
        vmlal.s16       q3,  d1,  d13
.endif
.if \uv_layout & \lems= 
        b               sum_\lag\()_y_\edge\()_start
.elseif \uv_layout == 444 && \elems == 7
        b               sum_\lag\()_y_\edge\()_start
.elseif \ifc\ uv_444
        b               sum_\lag\()_uv_420_\edge\()_start
.else
sum_\lag\()_\type\()_\edge\()_start:
        push            {r11}
.if \elems > 4
.ifc \edge, left
        increment_seed  4
        read_rand       r11, 11,  3
        read_rand       r12, 11,  2
               addr11,r3,  r11,  #
        add             r12, r3,  r12, lsl #1
        vld1.16         {d1[1]}, [r11]
        read_rand       r11, 11,  1
        vld1.16         {d1[2]}, [r12]
        add             r11,         pop             {r4-r11
        vld1.16         {d1[3]}, [r11]
        lsl             r2,  r2,  #1             L(generate_grain_type\)lag3:
        .       , ,d30
        vext.8          q2,  q2,  q2,  #12
.ifc \lag, lag3
        vmov.s16        r10, d1        lsl             r5, r5,lr/128 <bitdepth_min_8
.endif
.ifnc lag,lag1
        vmov.s16        r8,  d1[2]
endif
        vmov.s16        r6,  d1[3]

                .         ,d28[java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        mov             r1,  #1
        bl              output_\lag\()_neon
.else
        increment_seed  4, shift=0
                    , 
        mov             r1,  #4
        bl              orr             r4,     #java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
.endif

increment_seed  4,shift=java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        vmov            q1,        vpush           {d26
.ifc \edge, right
        mov             r1,  #3
        bl              output_\lag\()_neon
        ead_shift_rand,11
        add             r12, r3,  r12, lsl #1
        vld1.16         {d2[0]}, [r12]
        vrshl.s16       d2,  d2,  d30
        vext1java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
.else
        mov             r1,  #4
        bl              output_\lag\()_neon
.ndif
.else
        // elems == 1
        increment_seed  4, shift=0
                    q1,
        mov             r1,  #1
        \lag\(_
        lsr             r2,  r2,  #3

        read_rand       r11, 11, 2
        read_rand       r12, 11,  1
        add             r11, r3,  r11, lsl #1
        add             r12, r3,  r12, lsl #1
        vld1.16         {        l              sum_\\)lag3_mid_neon   / 64
        read_rand        bl              \type(_   / 
        vld1.         d2[1} r12]
        add             r11, r3,  r11, lsl #1
        vld1.16         {d2[2]}, [r11]
        vrshl.s16       d2,  d2,  d30
        vext.8          q0,  q0,  q1,  #14
.
        vst1.16         {q0}, [r0]!
        pop             {r11}
        pop             {r1, pc}
.endif
.ndm

.macro         bgt         b
function sum_\type\()_lag1_\edge\()_neon
        push            {r1, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.ifc \edge, left
        sub             r12, r0,pop            {r4-,cjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
.endif
        sum_lag_n_body  lag1
endfunc
.endm

sum_lag1_func y,      0,   left
sum_lag1_func y,      0,   mid
 0,right, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 uv_444,444,left
sum_lag1_func uv_444, 444, mid
 uv_444,444 ,7
sum_lag1_func uv_422, 422, left
sum_lag1_func uv_422, 422, mid
sum_lag1_func java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
sum_lag1_funcuv_420, ,l
sum_lag1_func uv_420, 420, mid
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 6


function sum_lag2_above_neon
        push            {lr}
        sub             ,r0,  2*RAIN_WIDTH2-16
        sub             lr,  r0,  #1*GRAIN_WIDTH*2 - 16
        vld1.16         {q10}, [r12] // load top right
       .         {} [rjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

        vdup.8          d10,                     reg r,#*32-*
        vext.8          q0,  q8,  q9,  #12 .
        vdup.8          d12, d28[1]
        vext.8          q1,  q8,  q9,  #14
        vdup.8          d14, d28[3]
        vext.8          q4,  q9,  q10, #2  // top midfunction \ype\)16bpc_neon,export=java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        vmovl
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14

        vmull.s16       q2,  d0,  d10
        vmlal.s16       q2,                     ,r3
        vmlal.s16       q2,  d8        movw            r11 (*RAIN_WIDTH3*java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
        vmull.s16       q3,        add              ,  r11
        vmlal.s16       q3,  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        vmlal.s16       q3        mul             ,r12,lr

        vdup.8          d10, d28[4]
vext.          , q9, q10, #4  / top mid,top right
        vdup.8          d12, d28[5]
        vext.8                            ,X(aussian_sequence)
        vdup.8          d14, d28[6]
        vext.8          q4,  q11, q12, #14
        vmovl.s8        q5, d10
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14

        vmlal.s16       q2,  d0,  d10
        vmlal.s16       q2,  d2,  d12
       vmlal.16      , d8,d14
        vmlal.s16       q3,  d1,  d10
        vmlal.s16        add             , , FGD_AR_COEFFS_UV
vmlal.16q3 d9,  d14

        vdup.8          d10, d29[0]
q12,q13,# // top mid,top right
        vdup.8          d12, d29[1]
        vext.          ,  java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

        vdup.8        r6, [,r6 lsl#]
        vdup.8          d8,  d28[7]

               vmovl.          d10
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.s8        q4,  d8

        vmlal.s16       q2,  d0,  d10
        vmlal.s16       q2,  d2,  d12
        vmlal.s16       q2,  d18, d14
vmlal.s16       q2,d24, d8
        vmlal.s16       q3,  d1,  d10
                ovw            ,#0x49d8
        .s16       q3, d19,d14
        vmlal.s16       q3,  d25, d8

                // Intentionally using a separateregister instead of  withan
        vmovq9 q10

        vmov            q11, q12
        vmov            q12,q13

        pop             {pc}
endfunc

.macro sum_lag2_func type, uv_layout, edge, elems=8
function \\)l\\(_eon
        push            {r1, lr}
. e,left
        sub             r12, r0,  #2        opjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        sub             lr,  r0,  #1*GRAIN_WIDTH*2
        vld1.16         {q9},  [r12]mov              #java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        vld1.16         {q12}, [lr]
.ndif
sum_lag_n_bodylag2,\,\, \dge, \lems,uv_coeffd29[]
endfunc
.endm

java.lang.StringIndexOutOfBoundsException: Range [26, 13) out of bounds for length 31
 y,        
sum_lag2_func y,      0,                      java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
   .lign2
sum_lag2_func uv_444, 444, mid
um_lag2_func uv_444,444,right,7
sum_lag2_func uv_422, 422, left
sum_lag2_func uv_422, 422, mid
sum_lag2_func ,422,right,1
sum_lag2_func uv_420, 420, left
sum_lag2_func uv_420, 420, mid
sum_lag2_func uv_420,420 ,1


   wordgenerate_grain_type(_)-(en_grain_\ype(_)+CONFIG_THUMB
        //        .L(java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 88
        // of the edge java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
        sub             r12, r0,  #3*GRAIN_WIDTH*2
        vld1.8          {q11, q12}, [r12]
        vext.8          q12, q11, q12, #10
        vext.8          mov              #28
         sum_lag3_above_start
endfunc

 sum_lag3_above_neon
        movw            r12, #(3*GRAIN_WIDTH +  mvn              r5             /grain_min=~grain_max
        sub             java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        vld1.8          {q11, q12}, [r12]

sum_lag3_above_start:
        vdup.          ,d26[]
        vext.8          q1,  q11, q12, #2
        vdup.8          d14, d26[1]
        vext.8          q4,  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 31
        vdup.8          d16, d26[ vld1.8          {22[} r4]      /ar_coeffs_uv0]
        vext.8          q5,  q11, q12, #6
        vdup.8          d18, d26[3]
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.s8        q8,  d16
        vmovl.        .16         ,r5

        movw            r12, #(2*GRAIN_WIDTH + 3)*2
        sub             ,, 

        vmull.s16       q2,  d22, d12
        vmlal.s16       q2,  d2,  d14
               vmlal.s16       , 
        ,  d10,d18
        vmull.s16       q3,  d23, d12
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       q3,  d9,  d16
        vmlal.s16       q3,  d11, d18

        vdup.8          d12, d26[4]
        vext.8                  vmov.8q1,#55
        vdup.8          bl              \\)lag0_8_neon/ 16
        vext.8          q1,  q11, q12, #10
                      gen_grain_\ype(_ /24
        vext.8          q4,  q11, q12, #12
        vld1.          {11 },[12java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
        vdup.8          d18, d26[7]
        vmov           ,q14
        vmovl.s8        q7,  d14
        vmovl.s8        q8,  d16
        vmovl.s8        q9,  d18

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q2,  d2,  d14
         add               r0,#GRAIN_WIDTH*6*6
        vmlal.s16       q2,  d22, d18
        .s16      q3  1  d12
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       .fc\ype,uv_420
        vmlal.s16       q3,              q4-}

        vdup.8          d12, d27[0]
        vext.8          q0,  q11, q12, #2
        vdup.8          d14, d27[1]
        vext.           q11 q12,#java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        vdup.8          d16, d27[2]
        vext        movr5  128
        vdup.8          d18, d27[3]
        vext.8          q5,  q11, q12, #8
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.8        ,d16
        vmovl.s8        q9,  d18

        sub             r12, r0,  #(1*GRAIN_WIDTH + 3)*2

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q2,d2, d14
        vmlal.s16       q2,  d8,  d16
        vmlal.s16       q2,  d10, d18
        vmlal.s16       q3,  d1,  d12
                             , #
                8{[},[       / [4]
        vmlal.s16       q3,  d11, d18

        vdup.8          d12, d27[4]
        vext.8          q0,  q11, q12, #10
        vdup.8          d14, d27[5]
        vext.8          q1,  q11, q12, #        vmovl.8q13,d27
        vld1.8          {q11, q12vmovl.8        d29
        vdup.8        .8        ,d28
                            ,d24
        vmovl        .8         d13
        vmovl.s8        q7,  d14
        vext.8          q5,  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        vmovl.s8        q8,  d16
        s8          

        vmlal        blsum_type(_   /16
        vmlal.s16       q2,  d2,  d14
       . q2, ,d16
        vmlal.s16       q2,  d10, d18
        vmlal.s16       q3,  d1,  d12
        .s16       q3,  3,  d14
        vmlal.s16       q3,        bl              \\)_lag1_mid_neon   / 40
        vmlal.s16blsum_\(_ag1_right_neon / 44

        vdup.8          d12, d28[0]
        vext.8          q0,  q11, q12, #4
        vdup.8          d14,d28[java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
       .8          ,q11,q12 6
        vdup.8          d16, d28[2]
        vext.8          q4,  q11, q12, #8
        vdup.8          d18, d28[3]
        vext.8          q5,  q11, q12, #10
vmovls q6  
        vmovl.s8        q7,  d14
        vmovl.s8        q8,  d16
       java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 32

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q2,  d2,  d14
        vmlal.s16       q2,  d8,  d16
        vmlal.s16       q2,  d10, d18
        vmlal        mov             r5,  #128
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       q3,  d9,  d16
         sub             r5,#        //(28 < bitdepth_min_8) - 1

        vdup.          d12 d28[4]
        vext.8          q0,  q11, q12, #12
        vmovl.s8        q6,  d12

        vmlal.s16       q2,  d0,  d12        vmov.s8           []
        vmlal vmov.s8         , d29[]

        bx              lr
endfunc

.macro sum_lag3_func type, uv_layout, edge, elems=8
functionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        push            {r1, lr}
        sum_lag_n_body  lag3,\, \uv_layout,\,\lems d29[]
endfunc
.endm

set_heightr1,  \type
sum_lag3_func y,      0,   mid
sum_lag3_func y,      0,   right, 7
sum_lag3_func uv_444, 444, left
sum_lag3_func uv_444, 444, mid
 uv_444  ,7
sum_lag3_func uv_422, 422, left
sum_lag3_func uv_422, 422, mid
 uv_422, ,right java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
sum_lag3_func uv_420, 420, left
sum_lag3_func uv_420, 420, mid
sum_lag3_func uv_420,         bl             sum_\type\)_ag2_mid_neon      // 32

function generate_grain_rows_neon
        push            {r10-r11,lr}blsum_type\(   // 40
1:
        mov             r10, #80
2:
        bl              get_gaussian_neon
        vrshl.s16       q0,  q0,  q15
        subs            r10, r10, #8
        vst1.16         {q0}, [r0]!
        bgt             2b
        get_grain_2     d0
        subs            r1,  r1,  #        increment_y_ptr r11, \type
        vst1.32         {d0[0]}, [r0]!
        bgt             1b
        pop             {r10-r11,pc}
endfunc

function vpop            {q4-q7
                    r-r11,rjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
1:
               mov            r10, #
2:
        bl              get_gaussian_neon
.16       ,q0,q15
        subs            r10, r10, #8
        vst1.16        q0} [0!
        bgt             2b
            java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
subs            ,r1  1
        vst1.16         {d0}, [r0]
        add             r0,  r0,  #GRAIN_WIDTH*2-80
        bgt             1b
            r-,}
endfunc

function gen_grain_uv_444_lag0_neon
        vld1.16         {q3}, [r11]!
gen_grain_uv_lag0_8_start:
        push            {r11,lr}
        bl              get_gaussian_neon
        vrshl.s16       q0,  q0,  q15
gen_grain_uv_lag0_8_add:
        vand            q3,  q3,  q1
        .       ,d6, 
        vmull.s16       q3,  d7,  d22
        vrshl.s32       q2,  q2,  q12
        vrshl.s32java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
        vqmovn.s32      d4,  q2
        vqmovn.s32      d5,  q3
        vqadd.s16               bl              generate_grain_rows_44_neon
        vmin.s16        q2,  q2,  q9
        vmax.s16        q2,  q2,  q10
        set_height      r1  \
        pop             {r11,pc}
endfunc

function gen_grain_uv_420_lag0_8_neon
                     , r11, #RAIN_WIDTH*2
        vld1.16         {q2,q3}, [r11]!
        vld1.16         {q4,q5}, [r12]                      \(_   / 
vpadd.16       ,  d5
        vpadd.i16       d5,  d6,  d7
        vpadd.i16               bl              \ype\)lag3_mid_neon//40
        vpadd.i16       d9,  d10, d11
        vadd.i16        q2,  q2,  q4
        vrshr.s16       q3,  q2,  #2
        b               gen_grain_uv_lag0_8_start
endfunc

_
        vld1.16         {q2,q3}, [r11
                add  , ,#*2-*16
        vpadd.i16       d5,  d6,  d7
        vrshr.s16       q3,  q2,  #1
        b               gen_grain_uv_lag0_8_start
endfunc

function gen_grain_uv_420_lag0_4_neon
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
        vld1.16         {q2}, [r11]
        vld1.16         {q0}, [r12]
        add             r11, r11, #32
        vpadd.i16       d4,  d4,  d5
        vpadd.i16       d0,  d0,  d1
        vadd.i16        d4,  d4,  d0
        vrshr.s16       d6gen_grain_44 uv_420
        pushgen_grain_44 
        get_grain_4     d0
        b               gen_grain_uv_lag0_8_add
endfunc

 
        vld1.16         {q2}, [r11]
       r11, 32
        vpadd.i16       d4,  d4,  d5
        vrshr.s16       d6,  d4,  #1
        push            {lr}
        get_grain_4     d0
        b               gen_grain_uv_lag0_8_add
endfunc

.macro gen_grain_82 type
function        .8{dst10\} r11java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        push            {r4-r11,lr}

.ifc \type,vld1. {d[+off} [12java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        ldrr4  sp 36
        mov             r12, r3
        mov             lr,  #28
        ,  #3GRAIN_WIDTHjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        mov             r1,  r2
        mul             r12, r12, lr
        clzaddr12,r12,r3
.else
                    lr,  r2
.endif
        movrel          r3,,\rc2\java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 // -
        ldr             r2,  [r1, #FGD_SEED]
        ldr             r9,  [r1, #FGD_GRAIN_SCALE_SHIFT]
.ifc \type, y
        add             r4,  r1        vld1.         {dst24\off],[lr]
.else
        add             r4,  r1,  #FGD_AR_COEFFS_UV
.endif
        add             , ,lr/  -bitdepth_min_8
        adr             r5,  vld1.8          \st2[+off]} r
        ldr             r6,  [r1endm
        add
        ldr             r6,.macro gather dst1,dst2,dst3,dst4, src1, src2, src3, src4, src5, src6, src7, src8
        vdup.16         q15, r9    // 4 - bitdepth_min_8 + data->grain_scale_shift
        add             ,r5,  r6
        vneg.s16        q15, q15

.ifc \type, uv_444
push            lrjava.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
        cmp             r12, #0
        movw            r10, #0x49d8
             movw            lr, 0xb524
        // Intentionally using a separate
        // java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        it              eq
       ,
        add             r4,  r4,  r12       // {p}
        eor             r2,  r2,  r10
        pop             {lr}
.endif

        ldr             r7,  [r1, #FGD_AR_COEFF_SHIFT]
        neg             lr, lr             / bitdepth_min_8
        mov             r8,    ,   ,d1,d2,d3 0
                gatjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 58
lslr8  ,        /1< ar_coeff_shift
        lsl             r10, r10, r9        // 1 << (4 + data-
        lsr             r8,  r8,  c ,align4
        lsr             r10, r10, #1        // 1 << (4 + data->grain_scale_shift - 1)

        bx              r5

        .align 2
L(gen_grain_\ overlap_coeffs_1align4
        word Lgenerate_grain_\type\)lag0)-Lgen_grain_\type\()_tbl) + CONFIG_THUMB
        .word L(generate_grain_\type\()_lag1) - L(gen_grain_\type\()_tbl) + CONFIG_THUMB
grain_\\()lag2  L(\type\()_tbl) +CONFIG_THUMB
        .word L(generate_grain_

L(macro calc_offset,offy ,sx,
.ifc \type, y
mov            ,#
        bl              generate_grain_rows_neon
ejava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
        mov             r5,  #128
        lsl             r5,  r5,  lr        //  128 << bitdepth_min_8
        sub             r5,r5  #        // ( < bitdepth_min_8)- 1
        mvn             r6,  r5             // grain_min = ~grain_max

        mov             r1,  #3
        bl              generate_grain_rows_neon
        mov             r1,  #GRAIN_HEIGHT-3

        vdup.q12 
        vld1.8          {d22[]}, .ndif
        vmov.i8         q0,  #0
        vmov.i8         q1,  #255
        .16         q9,  r5
        vdup.16         q10, r6
        vext.8          q13, q0,  q1,  #10        mla             dst,\, offy,\ /  += *
        vext.8          q14, q1,  q0,  #2
        vneg.s32        q12, q12
        vmovl.s8        q11, d22

1:
        vmov            q1,  q13
java.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 55
        vmov.i8         q1,  #255
        bl              gen_grain_uv_444_lag0_neon // 16
        bl              gen_grain_uv_444_lag0_neon // 24
                      java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 56
                     / java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
//                                  offsets[[]
         // 56
        bl              gen_grain_uv_444_lag0_neon // 64
        bl              gen_grain_uv_444_lag0_neon // 72
        vmov            q1,  q14/                                 int)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        bl              gen_grain_uv_444_lag0_neon // 80
        get_grain_2     d16
        subs            r1,  r1,  #1
        add             r11, r11,        vpush           -}
        vst1.32         {d16[0]}, [r0]!
        bgt             1b
.endif
        pop             {r4-r11,pc}

L(generate_grain_\type\()_lag1):
                ldrdr6,  r7,  [sp, #08]//offsets h
        mov             r5,  #128
        lsl             , ,  lr        /128< bitdepth_min_8
        sub             r5,  r5,  #1        // (128 << bitdepth_min_8) - 1
        vld1.8          {d27[]}, [r4]!      // ar_coeffs_y[0]
        vld1.8          {d28[]}        ldr             r10,     s,#   /bitdepth_max
        vld1.8          {java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
.ifc \type, y
        ldrsb           r4,  [r4, #1]       // vdup.16         q6,  r10               // bitdepth_ma
.else
        add             r4,  r4,  #2
.endif

        mov             r1,  #3
.ifc \type, uv_444
        vld1.8          {d13[]}, [r4]       // ar_coeffs_uvcmp            , 0
        ldrsb           r4,  [r4, #-1]      // ar_coeffs_uv[3]
.endif
        bl              generate_grain_rows_neon
        vmovl.s8        q13
        vmovl.s8        q12, d29
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        vmov            d29, d24
.ifc \type, uv_444
        vmovl. vmovi16q14,#6
.endif

  #GRAIN_HEIGHT - 3
1:
        bl              sum_\type\()_lag1_left_neon  // 8
        bl              sum_\type\()_lag1_mid_neon        .        ,q14,q12
        bl                      vshl.s16        q15        q15,q15,q12
        bl              sum_\type                       f
        bl              sum_\type\()_lag1_mid_neon           /  clip
        sum_type\)lag1_mid_neon   / 48
        bl              sum_\type\()_lag1_mid_neon   // 56
        bl              sum_\type\()_lag1_mid_neon   // 64
        bl              sum_\type\()_lag1_mid_neon   // 72
        bl              sum_\type\()_lag1_right_neon // 80
        get_grain_2     d16
        subs            r1,  r1,  #1

        add             r11, r11, #4
.endif
        [0]} [0!
        bgt             1b

        vpop            {q4-q7}
        pop             {r4-r11,pc}

L(generate_grain_\type\()_lag2):
        vpush           {q4-q7}
        mov             r5,  #128
                     ,r5,         /  128< 
        sub             r5,  r5,  #1        // (128 << bitdepth_min_8) - 1
        vld1.8          {d28,d29}, [r4]     // ar_coeffs_y[0-11],         add_offset      , ,r4, r5, r9

        vmov.s8         r4,  d29[2]
        vmov.s8         r10, d29[3]

        ov            , #
        bl              generate_grain_rows_neon

        mov             r1,  #GRAIN_HEIGHT - 3
1:
        bl              sum_\type\()_lag2_left_neon  // 8
        bl              sum_\type\()_lag2_mid_neon   // 16
        bl              sum_\type\()_lag2_mid_neon   // 24
        bl              sum_\type\(       calc_offsetr6,  lr, r6,0,  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        bl              sum_\type\()_lag2_mid_neon   // 40
        bl              sum_\type\()_lag2_mid_neon   // 48
        bl              sum_\type\()_lag2_mid_neon   // 56
        bl              sum_\type\()_lag2_mid_neon   // 64
        bl              sum_\type\()_lag2_mid_neon   // 72
        bl              \\)l // 80
        get_grain_2     d16
        subs            r1,  r1,  #1
.ifc \type, uv_444
        add             r11, r11, #4
.endif
        vst1.32          ldr             ,[11   #2]
        bgt             1b

        vpop            {q4-q7}
        pop             {r4-r11,pc}

L(generate_grain_\type\()_lag3):
        vpush           {q4-q7}
        mov             r5,  #128
        lsl             r5,  r5,  lr        //  128 << bitdepth_min_8
        sub             r5,  r5,  #1        // (128 << java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 20
        vld1.8          {q13, q14}, [r4]            vdup.6         ,d241java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

        vmov.u8         r4,  d28[5]
        vmov.u8         r10, d28[6]
        vmov.u8         r12, d28[7]

        orr             r4,  r4,  r10, lsl #8
        r4  r4,  r12,lsl #java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

java.lang.StringIndexOutOfBoundsException: Range [47, 31) out of bounds for length 31
        vpush           {d26}
        bl              generate_grain_rows_neon
        vpop            {d26}

        mov             r1,  #GRAIN_HEIGHT - 3
1:
        bl              sum_\type\()_lag3_left_neon  // java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 22
        bl              sum_\type\()_lag3_mid_neon   // 16
        bl              sum_\type\()_lag3_mid_neon   // 24
        bl              sum_\type\)_ag3_mid_neon   / 32
        bl              sum_\type\()_java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        bl              sum_\type\()_lag3_mid_neon   //  word loop_11  fgy_loop_tbl) +
        bl              sum_\type\()_lag3_mid_neon   // 56
        bl              sum_\type\()_lag3_mid_neon   // 64
        bl              sum_\type\()_lag3_mid_neon1:
        bl              sum_\type\()_lag3_right_neon // 80
        get_grain_2     d16
        subs            r1,  r1,  #1
.ifc \type, uv_444
        add             if ojava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Range [67, 6) out of bounds for length 6
        vst1.32         {d16[0]}, [r0]!
        bgt             1b

        vpop            q4-}
        pop             {r4-r11,pc}
endfunc
.endm

gen_grain_82 y
gen_grain_82 uv_444

.macro set_height dst, type
.ifc \type, uv_420
        mov             \dst,  #SUB_GRAIN_HEIGHT-3
else
        mov             \dst,  #GRAIN_HEIGHT-3
.endif
.endm

.macro increment_y_ptr
.ifc \type, vld1.16{q2, ,[,:28,r2//src
        add             \reg, \reg.ndif
.else
        sub             \reg, \reg, #6*32-GRAIN_WIDTHvmvn.        , #xf000               //0fff
.endif
.endm

.macro gen_grain_44 type
function generate_grain_\type\()_16bpc_neon, export=1
        push            {r4-r11,lr}

        ldr             r4,  [sp, #36]
        mov             r12, r3
        movw            .f\java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
        mov             lr,  #28
        add             r11, r1,  r11
        mov             r1,  r2
        ul             r12,r12,lr
        vqrshrn.32     d16,,  #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

        movrel          r3,  X(gaussian_sequence)
        sub             lr,  lr,  #24 // -bitdepth_min_8
        ldr             r2,  [r1, #FGD_SEED]
        ldr             r9,  [r1, #FGD_GRAIN_SCALE_SHIFT]
        add             r4,  r1,  #FGD_AR_COEFFS_UV
        add             r9,  r9,  lr // grain_scale_shift - bitdepth_min_8
        adr             r5,  L(gen_grain_\type\()_tbl)
        ldr             r6,  [r1,         vmull.s16q0, d4,  
        add             ,r9  #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        ldr             r6,  [r5, r6, lsl #2]
        vdup.16         q15, r9    // 4 - bitdepth_min_8 + data->grain_scale_shift
        add             ,    
vneg.16       ,q15

        push            {lr}
        cmp             ,#java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                     #x49d8
        movw            lr,  #0xb524
rate registerinsteadof   an
        // immediate constant, to avoid armv8 deprecated it instruction forms.
        it              eq
       r10,
        add             r4,  r4,  r12       // Addvmlal.16       q8 d8, 
        eor             r2        .       ,  d9, d14
        pop             {lr}

        ldr             r7,  [r1, #FGD_AR_COEFF_SHIFT]
        neg             lr,  lr
        r8  1
        mov             r10, #1
        lsl             ,r8, r7        /1< ar_coeff_shift
        lsl             r10, r10, r9        // 1 << (4 + data->grain_scale_shift)
        lsr             r8,  r8,  #1        // 1 <<         vqrshrns32      q1, 5
        lsr             r10, r10, #1        // 1 <<        vqrshrn.s32     3  q3, 5
        bx              r5

        .align 2
L(gen_grain_\type\()_tbl):
        .word L(generate_grain_\type\()_lag0) - L(gen_grain_vs16q8, ,
        .word L(generate_grain_\        s16q1  java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        .word L(generate_grain_\type\()_lag2) - L(java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 36
        .word L(generate_grain_\type\()_lag3) - L(gen_grain_\type\()        s q8 q8,q4

L(generate_grain_\type\()_lag0):
.ifc \type, uv_420
        vpush           {q4-q5}
.endif
        mov             r5,  #128
        lsl             r5,  r5,  lr        //  128 << java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 36
        sub             r5,  r5,  #1        // (128 <<vmvnd4                     /grain_min
         , r5             / grain_min=~grain_max

        mov             r1,  #3
        bl              generate_grain_rows_44_neon.d16, d16,d12
        set_height      r1,  \type

        vdup.32         q1216{,q3}  [r1,:28] 2/ src
        vld1.8          {d22[]}, [r4]       .ndif
        vmov.i8         q0,  #0
        vmov.i8         q1,  #255
        vdup.16         q9,  r5
                 q10 
        vext.           q0,  q1,  10
        vext.8          q14, q1,  q0,  #14
        vneg.s32        q12,                    ,q1,q5
        vmovl.s8        q11, vand            q2,  q2

1:
        vmov            q1
                      \type\)_ag0_8_neon/8
        vmov.i8         q1,  #255
        bl              gen_grain_\type\()_lag0_8_neon // 16
        bl              gen_grain_\type\()_lag0_8_neon // 24
        bl              gen_grain_\type\()_lag0_8_neon // 32
        bl              gen_grain_\type\()_lag0_8_neon // .endif
        
        bl              gen_grain_\type\()_lag0_4_neon // 44
        subs            r1,  r1,  #1
        increment_y_ptr r11, \type
                     r0, r0  #RAIN_WIDTH2616
        bgt             1b

.ifc \type, java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
        vpop            {q4-q5}
.endif
        pop             {r4-r11,pc}

L(generate_grain_\type\()_lag1):
        vpush           {        vshl.u16        q5,  
        mov
        lsl             r5,  r5,  lr        //  128caling< 15-scaling_shift  grain )
        vqrdmulhs16    q9,q9, 
        vld1.8          {d27[        .16   , q10,
        vld1.          d28],[4]      /ar_coeffs_uv[]
        vld1.8          {d29[]}, [r4]       // ar_coeffs_uv[2]
        add             r4,  r4,  #2

        mov             r1,  #3
vld1.          d13[} []/ []
        ldrsb           r4,  [r4, #-1]      // ar_coeffs_uv[3]
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
vmovl.q13,d27
        vmovl.s8        q12, d29
        vmovl.s8        q14, d28
        vmov            d29, d24
        vmovl.s8        q6,  d13

        set_height      r1,  \type
1:
        bl        vmax.16        ,q0, 
blsum_\\)lag1_mid_neon   /16
        bl              sum_\type\()_lag1_mid_neon   // 24
        vmax.s16        , q2, q14
        bl              sum_\type\)_ag1_mid_neon   // 40
        vmin.16        ,q0 q15
        subs            r1vmins q1,   q15
        increment_y_ptr r11, \type
        add             r0,  r0,  #GRAIN_WIDTH*2-6*16
        bgt             1b

                    q7}
        pop             {r4-r11,pc}

L(generate_grain_\type\()_lag2):
        vpush           {q4-q7}
        mov             r5,  #128
                    ,r5,         /128 <bitdepth_min_8
        sub             r5,  r5,  #1        // (128 << bitdepth_min_8) - 1
        vld1.8          {d28,d29}, [r4]     // ar_coeffs_uv[0-12]

        vmov.s8         r4,  d29[2]
        vmov.s8         r10, d29[3]

        mov             r1,  #3
        bl              generate_grain_rows_44_neon

              r1,\
1:
        bl              sum_\type\()_lag2_left_neon  // 8
        bl              sum_\type\()_lag2_mid_neon   // 16
        bl              sum_\type\()_lag2_mid_neon   // 24
        bl              sum_\type\()_lag2_mid_neon   // 32
        bl              sum_\type\()_lag2_mid_neon   //  fgy            ,0
        bl              sum_\type\()_lag2_right_neon // 44
        subs            r1,  r1,  #1
        increment_y_ptr r11, \type
0  r0,#GRAIN_WIDTH2616
        bgt             1b

        vpop            {q4-q7}
        pop             {r4-r11,pc}

L(generate_grain_\type\()_lag3):
        vpush           {q4-q7}
        mov             r5,  #128
                     , r5,  lr        /128< bitdepth_min_8
        << bitdepth_min_8) -1
        vld1.8          {q13, q14}, [r4]    // ar_coeffs_y[0-23], ar_coeffs_uv[0-24]

        vmov.u8         r4,  d28[5]
        vmov.u8         r10, d28[6]
        vmov.u8         r12, d28[7]

        orr             r4,  r4,  r10, lsl #8
        orr             r4,  r4,  r12, lsl #16

        mov             r1,  #3
        bl              generate_grain_rows_44_neon

        set_height      r1,  \type
1:
        bl              sum_\type\()_lag3_left_neon  // 8
        bl              sum_\type\()_lag3_mid_neon   // 16
        bl              sum_\type\()_lag3_mid_neon   /. fguv layout,sx 
        bl              sum_\type\()_lag3_mid_neon   // 32
                      \ype(_lag3_mid_neon   /40
        bl                   -}
        subs            r1,  r1,  #1
        increment_y_ptr r11, \type
                     ,  r0,#*2-*java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
         1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

        vpop            {q4-q7}
        pop             {r4-r11,pc}
endfunc
.endm

gen_grain_44 uv_420
gen_grain_44 uv_422

.macro gather_interleaved dst1, dst2, src1, src2,  add             r10, r4,r10,lsl 2/ +4*
        vmov.16         src1[0+\ff]
        vmov.u16        r12, \src3[0+\                     ,r10,#GD_UV_MULT
        add             r11, r11, r3
        ]
        add             r12, r12, r3
        [0+\off],[]
        vmov.u16        r11, \src3[2+\off]
        lr lr,  java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        vld1.8          {\dst2[0+\off]}, [        ld1         d[} lr]        /uv_mult
        vmov.u16        r12, \src2[0+\off]
        add             r11, r11, r3
        .          \st1[+off]} l]
        vmov.u16        lr,  \src4[0+\off]
        add             r12, r12, r3
        vld1.8          {\dst2[2+\off]}, [r11]
        vmov.u16        r11, \src2[2+\off]
        add             ,  lr, r3
        vld1.8          {\dst1[4java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        vmov.u16        r12, \src4[2+\off]
        add             ,r11,r3
        vld1.8          {\dst2[4+\off]}, [lr]
        add             
                             f
        vld1.8          {\dst2[6+\off]}, [r12]
.endm

.macro gather dst1, dst2, dst3, dst4, src1, src2, src3, src4, src5, src6, src7, src8
        gather_interleaved \dst1, \dst3, \src1, \src2, \src5, \src6, 0
        gather_interleaved \dst1, \dst3, \src1, \java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 36
        gather_interleaved \, \,\src3,\, \java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 70
        gather_interleaved \dst2, \dst4, \src3,         beq             f
.endm

function gather32_neon
        push            {r11-r12,lr}
        gather          d8,  d9,  d10, d11, d0,  d1,  d2,  d3,  d4,  d5,  d6,  d7
        pop             {r11-1:
endfunc


        push            {r11-r12,lr}
        gather_interleaved d8,  d9,  d0,  d1,  d2,  d3,  0
        gather_interleaved d8,  d9,  d0,  d1,  d2,  d3,  1
        pop             {r11-r12,pc}
endfunc

const overlap_coeffs_0, align=4
        .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        .short 17, 27, 32, 32
endconst

const overlap_coeffs_1, align=4
        .short 23, 0,  0,  0
        .short 22, 32, 32, 32
endconst

.macro calc_offset offx, offy, src, sx, sy
        and             \offy, \src,  #       movr6  27
        lsr             \offx, \src,  #4       // randval >> 4
.if \sy == 0
add            offy, \,o    /2*(randval&0F
.endif
.if \sx == 0
        add                                   r9, s, 116 / offsets,h
.endif
.endm

.macro add_offset dst, offx, offy, src, stride
        mla             \dst, \stride, \offy, \src //         add             r5,  r5,  r10, lsl #2  // grain_lut +=    java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 79
        add             \dst, \dst, \offx, lsl #1  /e
.endmr5,   r10,#  / =8* 

// void dav1d_fgy_32x32_16bpc_neon(pixel *const dst, const pixel *const src,
//                                 const ptrdiff_t stride,
//                                 const java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
//                                 const int scaling_shift,
//                                 const entry grain_lut[][GRAIN_WIDTH],
//                                 const int offsets[][2],
//                                 const int h, const ptrdiff_t clip,
//                                 const ptrdiff_t type,
//                                 const int bitdepth_max);
function fgy_32x32_16bpc_neon export=
        push            {r4-r11,lr}
        vpush           {q4-q7}
        , grain_lut
        ldrd            r6,  r7,  [sp, #108]   // offsets, h
        ldr             r8,       [sp, #116]   // clip
        mov             r9,  #GRAIN_WIDTH*2    // grain_lut stride
        ldr             r10,      [sp, #124]   //         ldr             r8,  [r8]              // offsets[0]//[]0java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

        eor             r4,  r4,  #15          // 15 - scaling_shift
        vdup.16         q6,  r10               //         vmov.16         d31[3], r7             // overlap y [1
        clz              addr4  r4, 2( > sx      /grain_lut + FG_BLOCK_SIZEjava.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
        vdup.6          // 15 -scaling_shift
        rsb             r10,  add             , ,r10, lsl #5-\)/ grain_lut+  *FG_BLOCK_SIZE java.lang.StringIndexOutOfBoundsException: Range [103, 104) out of bounds for length 103
        cmp             
        vdup.16         q12, r10               // bitdepth_min_8

        movrel_local    r12, overlap_coeffs_0

        beq             1f
        / clip
        vmov.i16        q14, #16
        vmov.i16        q15, #235
        vshl.s16        q14, q14, q12
        vshl.s16        q15, q15, q12
            2java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
1:
        /noclip
        vmov.i16        q14, #0
vmov            ,q6
2:
        vshr.u16        q6,  q6,  #1           // grain_max

        vld1.16         {d24, d25}, [r12, :128] // overlap_coeffs

        add             r5,  r5,  #18          // grain_lut += 9
        add             r5,  r5,  r9,  lsl #3  // grain_lut += 8 * grain_stride
        add             r5,  r5

        ldr             r10, [r6, #8]          // offsets[1][0]
        calc_offset     r10, r4,  r10, 0,   0
        add_offset      r4,  r10, r4,  r5,  r9
ldr              [6,#]          []1java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        calc_offset     r10, r11, r10, 0,   0
              r11,r10,r11,r5,r9
        ldr             r10, [r6, #12]         // offsets[1]java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 40
        calc_offset     r10, r8,  r10, 0,   0
        add_offset      r8,  r10, r8,  r5,  r9
        ldr             r6,  [r6]              // offsets                     r7   r7          /luma_stride* 2
        calc_offset     r6,  lr,  r6,  0,   0
        add_offset      r5,  r6,  lr,  r5,  r9

        add             r4,  r4,  #32*2        x             r12
        add             r6,  r11, r9,  lsl #5  // java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 5

        ldr             r10, [sp, #120]        // type
        adr             r11, L(java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 14

        , #1
        ldr             r10, [r11, r10, lsl #2]

        add             r8,  r8,  r9,  lsl #5  // grain_lut += grain_stride.wordLfguv_loop_sx0_csfl0_00)-L() +CONFIG_THUMB
addr8 r8  #2*        /grain_lut += FG_BLOCK_SIZE * bx

        add             r11, r11, r10) -L(guv_loop_sx0_tbl)+CONFIG_THUMB

             f
        // y overlap
        vdup.16         d14, d24[0]
        vdup.16         d15, d24[1]
    // backup  
        mov             r7,  #2
1:
subr2 r2  #2          / src_stride-= 32
        sub             r9,  r9,  #32          // grain_stride -= 32
        bx              r11
endfunc

function fgy_loop_neon
(:
        .word L(loop_00) - L(fgy_loop_tbl) + CONFIG_THUMB
        .word L(loop_01) - L(fgy_loop_tbl) + CONFIG_THUMB
        .word L(loop_10) - L(fgy_loop_tbl) + CONFIG_THUMB
        .word         mov             ,lr

m fgy ox,oy
L(loop_\ox\oy):
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
.if \ox
        vld1.16         {d0},       [r4],       r9 // grain_lut old
.endif
. \oy
        vld1.16         {q2,  q3},  [r6]!          // grain_lut top
.endif
.if \ox && \oy
        vld1.16         {d2},       [r8],       r9 // grain_lut top        vld1.         d2}[]       / grain_lut  
. !\ox && !\oy
i \y
        vld1.16         {q4,  q5},  [r6],       r9 // grain_lut top
.endif
.if !\ox && !\oy
        vld1.16         {q0,  q1},  [r1, :128]!    // src
.endif
        vld1.16         .
.if !\ox && !\oy
        vld1.16         {        .         q, , [6 128] / luma
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
.if !\oy
        i q5  0f000               / 0x0fff
.endif
vld1.         {10 q11} [5]       r9 / grain_lut

.if \ox
        add             r4,r4, #32
        vmull.s16       q0,  d0,  d24
        vmlal.s16       q0,  d16, d25
.endif

.if \oy
.if \ox
        add             r8,  r8,  #32
        vmull.s16       q1,  d2,  d24
        vmlal.s16       q1,  d4,  d25
        vqrshrn.s32     d16, q0,  #5
        vmvn            d0,  d12                   // grain_min
        vqrshrn.s32     d4,  q1,  #5
d16 java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
        vmin.s16        d4,  d4,  d12
        vmax.s16        d16, d16, d0
        vmax.s16        d4,  d4,  d0
.endif

        vmull.s16       q0,  d4,  d14
        vmull.s16       q1,  d5,  d14
        vmull.s16       q2,          vmlal.s16       q1, d4,d25
        vmull.s16       q3,  d7,  d14
        vmlal.s16       q0,          vqrshrn.s32     d16, q0,.32     ,q0 5
        vmlal.s16       q1,  d17, d15
        vmlal.s16       q2,  d18, d15
        vmlal.s16       q3,  d19, d15
        vmull.s16       q8,  d20, d15
        vmull.s16       q9,  d21, d15
        vmull.s16       q10, d22, d15
        vmull.s16       q11, d23, d15
        vmlal.s16       .ndif
        vmlal.s16       q9,  d9,  d14
        vmlal.s16       q10, d10, d14
        vmlal.s16       q11, d11, d14
        vmvn            q4,  q6                   // grain_min
        vqrshrn.s32     d0,  q0,  #5
        vqrshrn.s32     d1,  q1,  #5
        vqrshrn.s32     d2,  q2,  #5
        vqrshrn.s32     d3,  q3,  #5
     vqrshrn.s32     d4  q8,#5
        vqrshrn.s32     d5,  q9,  #5
        vqrshrn.s32     d6,q10 #
        vqrshrn.s32     d7,  q11, #5
        vmin.s16        q8,  q0,  q6
        vmin.s16        q9,  q1        vmlal.s16       ,d16, d29
        vld1.16         {q0,  q1},  [r1, :128]!    // src
        vmin.s16                vmlal.s16       ,d17, 29
        vmin.s16        q11, q3,  q6
        vmax.s16        q8,  q8,  q4
        vmax.s16        q9,  q9,  q4
        vld1.16         {q2,  q3},  [r1, :128], r2 // src
        vmvn.i16        q5,  #0xf000               // 0java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 8
        vmax.s16        q10, q10, q4
        vmax.s16        q11, q11, q4
.elseif \ox
        vmvn            d4,  d12                   // grain_min
        vqrshrn.s32     d16, q0,  #5
        vld1.16         {q0,  q1},  [r1, :128]!    // src
        s16d16, d16 java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
        vmax.s16        d16, d16, d4
        vld1.16         {q2,  q3},  [r1, v.16       ,d9  
.endif

        // Make sure that uninitialized pixels out of range past the right
        // edge are in range; their actual values shouldn't matter.
        vand            q0,  q0,  q5
        vand            q1,  q1,  q5
        vand            q2,  q2,  q5
        vand            q3,  q3,  q5

        bl              gather32_neon

.if \ox || \oy
        vpush           {q6-q7}
.endif

        vmovl.u8        q6,  d8        // scaling
        vmovl.u8        q7,  d9
        vmovl.u8        q4,  d10
        vmovl.u8        q5,  d11

        vshl.u16        q6,  q6,  q13  // scaling << (15 - scaling_shift)
        vshl.u16        q7,  q7,  q13
        vshl.u16        q4,  q4,  q13
        vshl.u16        q5,  q5,  q13

        vqrdmulh.s16            .         {0  }  r,:]    /luma
        vqrdmulh.s16    q9,  q9,  q7
        vqrdmulh.s16    q10, q10, q4
        vqrdmulh.s16    q11, q11, q5

.if \ox || \oy
        vpop            {q6-q7}
.endif

        vqadd.s16       q0,  q0,  q8   // *src + noise
. !\csfl
        vqadd.s16       q2,  q2,  q10
        vqadd.s16               vdup.16         ,d300   /uv_luma_mult

        vmax.s16        q0,  q0,  q14
        vmax.s16        q1,  q1,  q14
        vmax.s16        q2,  q2,  q14
        vmax.s16        q3,  q3,  q14
        vmin.s16        q0,  q0,  q15
        vmin.s16        q1,  q1,  q15
        vmin.s16        q2,  q2,  q15
        vmin.s16        q3,  q3,  q15

vst116{,q1} r0 :28]    / dst
        subs            r7,  r7,  #1
.if \oy
        vdup.16         d14, d25[0]
        vdup.16         d15, d25[1]
.endif
        vst1.16         {q2, q3}, [r0, :128], r2 // dst
        bgt             1b

.if \oy

        sub             r7,  r10, #2           // restore actual remaining h
        gtLloop_ox))
.endif
        vpop            {q4-q7}
        pop             {r4-r11,        .s32       , q0,  java.lang.NullPointerException
.endm

        fgy             0, 0
        fgy             0, 1
        fgy             1, 0
        fgy             1, 1
endfunc

// void dav1d_fguv_32x32_420_16bpc_neon(pixel *const dst,
//                                      const pixel *const src,
//                                      const ptrdiff_t stride,
//                                      const uint8_t scaling[SCALING_SIZE],
//                                      const Dav1dFilmGrainData *const data,
//                                      const entry grain_lut[][GRAIN_WIDTH],
//                                      const pixel *const luma_row,
//                                      const ptrdiff_t luma_stride,
//                                      const int offsets[][2],
//                                      const ptrdiff_t h, const ptrdiff_t uv,
//                                      const ptrdiff_t is_id,
//                                      const ptrdiff_t type,
//                                      const int bitdepth_max);
.macro fguv layout, sx, sy
function fguv_32x32_\layout\()_16bpc_neon, export=1
        pushvshrns32  ,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vpush           {q4-q7}
        vdup.16         q4  d303 // bitdepth_max
        ldrd            r10, r11, [sp, #124java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 31
        ldr             r6,       [sp, #136]   // bitdepth_max

                    ,
        rsb             r7,  r7,  #24          // bitdepth_min_8

        // !csfl
        add             r10, r4,  r10, lsl #2  // + 4*uv
        add             r12, r10, #FGD_UV_LUMA_MULT
        add             lr,  r10, #FGD_UV_MULT
        ldrh            r10, [r10, #FGD_UV_OFFSET] // uv_offset
       {[,r //uv_luma_mult
        lsl             r10, r10, r7           // uv_offset << bitdepth_min_8
        vld1.16         {d30[1]}, [lr]         // uv_mult

.els
        ldr             r12, [r4, #FGD_CLIP_TO_RESTRICTED_RANGE]
        eor             lr,  lr,  #15          // 15 - scaling_shift

        vmov.16         d30[2], r10            // uv_offset << bitdepth_min_8

        cmp             r12, #0
        vdup.16         q13, lr                // 15 - scaling_shift

                van             q1 q14
        // clip
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        vand           , q14
mov             r9,java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        lsl             r8,  r8,  r7
        lsl             r9,  r9,  r7
        beq             2f
        // is_id
        r9  235
        lsl             r9,  r9,  r7
        b               2f
1:
        // no clip
        mov             r8,  #0
        mov             r9,  r6                // bitdepth_max
2:
        vmov.16         d30[3], r6             // bitdepth_max
        vdup.16         d31, r8                // clip_min

        mov             r10, #GRAIN_WIDTH*2    // grain_lut stride

.if \sy
        mov             r6,  #23
        mov             r7,  #22
.else
        mov             r6,  #27
        mov                     vmovl.u8q6, d8// scaling
.endif
        vmov.16         d31[1], r9             // clip_max

        ldrd            r8,  r9,  [sp, #116]   // offsets, h

        add             r5,  r5,  #(2*(3 + (2 >> \        vmovl.q5  d11
.if \sy
        add             ,r5, r10  2 // grain_lut += 4 * grain_stride
        add             r5,  r5,  r10, lsl #1  // grain_lut += 2 * grain_stride
.else
        vshl.16         q6q13  // scaling << (15 - scaling_shift)
        add             r5,  r5,  r10          // grain_lut += grain_stride
.endif
        vmov.16         d31[2], r6             // overlap y [0]

        ldr             r12, [r8, #8]          // offsets[1][0]
        calc_offset     r12, r4,  r12, \sx, \sy
        add_offset      r4,  r12, r4,  r5,  r10

        ldr             r12, [r8, #4]          // offsets[0][1]
        calc_offset     r12, lr,  r12, \sx, \sy
        add_offset      lr,  r12, lr,  r5,  r10

        ldr             r12, [r8, #12]         // offsets[1][1]
        calc_offset     r12, r11, r12, \sx, \sy
              r11 ,r11   r10

        ldr             r8,  [r8]              // offsets[0][0]
        calc_offset     r8,  r12, r8,  \sx, \sy
        add_offset      r5,  r8,  r12, r5,  r10

        vmov.16         d31[3], r7             // overlap y [1]

         
        add             r8,  lr,  r10, lsl #(5 - \sy) // grain_lut += grain_stride * FG_BLOCK_SIZE * by
        vmins16        ,q2 
        add             r11, r11, #2*(32 >> \sx)      // grain_lut += FG_BLOCK_SIZE * bx

        movrel_local    r12, overlap_coeffs_\sx
        ldr             lr,       [sp, #132]   // type
ldrdr6    s,#   // luma_row, luma_stride

        vld1.16         {d24, 

                1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#if CONFIG_THUMB
        // This uses movrel_local instead of adr above, because the target
        // can be out of range for adr. But movrel_local leaves the thumb bit
       /  COFF b  wouldntifbuildingthumb  )
        // thus try to clear the bit for robustness.
        bic             r12, r12, #1
#endif.endm

        tst             lr,  #1
        ldr             lr,  [r12, lr,  lsl #2]

        add             r12, r12, lr

        beq             1f
        // y overlap
        sub             lr,  r9,  #(2 >> \sy)  // backup remaining h
        mov             r9,  #(2 >> \sy)

1:
if\
        add                     r-,}
.endif
        sub             r7,  r7,  #32          // luma_stride -= 32

        bx              r12
endfunc
.endm

fguv 420, 1, 1
422,1,0
fguv 444, 0, 0

function fguv_loop_sx0_neon
L(fguv_loop_sx0_tbl):
        .word L(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
        . ()-L(java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 77
        .word L(fguv_loop_sx0_csfl0_10) - L(fguv_loop_sx0_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx0_csfl0_11) - L(fguv_loop_sx0_tbl) + CONFIG_THUMB
        .word java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 2
        .word L(fguv_loop_sx0_csfl1_01) - L(fguv_loop_sx0_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx0_csfl1_10) - L(fguv_loop_sx0_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx0_csfl1_11) - L(fguv_loop_sx0_tbl) + CONFIG_THUMB

.macro fguv_loop_sx0 csfl, ox, oy
L(fguv_loop_sx0_csfl\csfl\()_\ox\oy):
java.lang.StringIndexOutOfBoundsException: Range [39, 8) out of bounds for length 68
        sub             
.if \oy
        mov             r12, lr
.endif
L(fguv_loop_sx0_csfl\csfl\()_\ox\oy\()_loopstart):
:
. java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
        vld1.16         {d0},       [.
.endif
.if \oy
        vld1.16         {q2,  q3},  [r8]!           // grain_lut top
.endif
.if \ox &.f\x
        vld1.16         {d2},       [r11],      r10 // grain_lut top old
.endif
.if !\ox && !\oy
        vld1.16         {q0,  q1},  [r6, :128]!     // luma
.endif
        vld1        .q0, d16,java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
.if \oy
        vld1.16         {q4,  q5},  [r8],       r10 // grain_lut top
.endif
.if !\ox && !\oy
        vld1.16         {        vqrshrn.s32     d16.     d16,q0,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
.endif
.if \oy
        vdup.16         d28, d31[2]                 // overlap y coeff
        vdup.16         d29, d31[3]                 // overlap y coeff
.endif
        vld1.16         {q10, q11}, [r5],       r10 // grain_lut

java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 37
        vdup.16         q7,  d30[3]                // bitdepth_max
        add             r4,  r4,  #32
                vmlaljava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                vmlals16         ,java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        vmlal.s16       q0,  d16, d25
        vmvn            q6,  q7.if !ox
.endif

.if \oy
.if \ox
        add             r11, r11, #32
        vmull.s16       q1,  d2,  d24
        vmlal.s16       q1 vqrshrn.32    ,,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vqrshrn.s32        vmvn            ,q7// grain_min
        vqrshrn.s32     d4,  q1,  #5
        vmin.s16                vld1.16         {q.16         , , r6,:]    /luma
        vmin.s16        d16, d16, d14
        vmax.s16        d4,  d4,  d12
        vmax.s16        d16, d16, d12
.endif

        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        vmull.s16       q1,  d5,  d28
        vmull.s16       q2,  d6,  d28
        vmull.s16       q3,  d7,  d28
.if !\ox
        vdup.16         q7,  d30[3]                // bitdepth_maxvdup.6         , 3]
.endif
                  ,java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        vmlal.s16       q1,  d17vmin.q1, q7 
        vmlal.s16       q2,  d18, d29
.
.if !\oxvdup16q14 [] // bitdepth_max
        vshr.u16        q7,  vld1. {,q3}  r1,:] 
.endif
        vmull.s16       q8,  d20, d29
        vmull.s16       q9,  d21, d29
        vmull.s16       q10, d22, d29
        vmull.s16       q11, d23, d29
.if         vandq1, q1 q14
        vmvn            q6,  q7                    // grain_min
.endif
        vmlal.s16       q8,  d8,  d28
        vmlal.s16       q9,  d9,  d28
        vmlal.s16       q10, d10, d28
        vmlal.s16       q11, d11, d28
.,java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vqrshrn.s32     d1        vqrdmulh.    ,  ,  q6// round2((scaling << (15 - scaling_shift) * grain, 15)
        vqrshrn.s32        vqrdmulh.q9   java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vqrshrn.s32     d3,  q3,  #5
        vqrshrn.s32     d4,  q8,  #5
        vqrshrn.s32     d5,  q9,  #5
        vqrshrn.s32     d6,  q10, #5
        vqrshrn.s32     d7,  q11, #5
 9
        vmin.s16        q9,  q1,  q7
        vld1.16         {q0,  q1},  [r6, :128]!    // luma
        vmin.s16        q10, q2,  q7
s16        ,q3 q7
        vmax.s16        q8,  q8,  q6
        vmax.s16        q9,  q9,  q6
        vld1.16         {q2,  q3},  [r6, :128], r7 // luma
        vmax.s16        q10, q10, q6
        vmax.s16        q11, q11, q6
.elseif \ox
        vqrshrn.s32     d16, q0,  #5
        vld1.16         {q0,  q1},  [r6, :128]!    // luma
        vmin.s16        d16, d16, d14
        vld1.16         {q2,  q3},  [r6, :128], r7 // luma
        vmax.s16        d16, d16, d12
.endif

.if !\csfl
        vdup.16         d28, d30[0]   // uv_luma_mult
        vld1.16         {q4,  q5},  [r1, :128]! // src
        vdup.16         d29, d30[1]   // uv_mult
        vmull.s16       q6,  d0,  d28
        vmull.s16       q7,  d1,  d28
        vmull.s16       q0,  d2,  d28
        vmull.s16       q1,  d3,  d28
        vmlal.s16       q6,  d8,  d29
        vmlal.s16       q7,  d9,  d29
        vmlal.s16       q0,  d10, d29
        vmlal.s16       q1,  d11, d29
        vld1.16         {q4,  q5},  [r1, :128]  // src
        sub             r1,  r1,  #32
        vshrn.s32       d12, q6,  #6
        vshrn.s32       d13, q7,  #6
        vshrn.s32       d14, q0,  #6
        vshrn.s32       d15, q1,  #6
        vmull.s16       q0,  d4,  d28
        vmull.s16       q1,  d5,  d28
        vmull.s16       q2,  d6,  d28
        vmull.s16       q3,  d7,  d28
        vmlal.s16       q0,  d8,  d29
        vmlal.s16       q1,  d9,  d29
        vmlal.s16       q2,  d10, d29
        vmlal.s16       q3,  d11, d29
        vdup.16         q14, d30[2]   // uv_offset
        vshrn.s32       d0,  q0,  #6
        vshrn.s32       d1,  q1,  #6
        vshrn.s32       d2,  q2,  #6
        vshrn.s32       d3,  q3,  #6
        vdup.16         q4,  d30[3]   // bitdepth_max
        vmov.i16        q5,  #0
        vadd.i16        q6,  q6,  q14
        vadd.i16        q7,  q7,  q14
        vadd.i16        q2,  q0,  q14
        vadd.i16        q3,  q1,  q14
        vmin.s16        q0,  q6,  q4
        vmin.s16        q1,  q7,  q4
        vmin.s16        q2,  q2,  q4
        vmin.s16        q3,  q3,  q4
        vmax.s16        q0,  q0,  q5
        vmax.s16        q1,  q1,  q5
        vmax.s16        q2,  q2,  q5
        vmax.s16        q3,  q3,  q5
.else
        vdup.16         q14, d30[3]  // bitdepth_max
        // Make sure that uninitialized pixels out of range past the right
        // edge are in range; their actual values shouldn't matter.
        vand            q0,  q0,  q14
        vand            q1,  q1,  q14
        vand            q2,  q2,  q14
        vand            q3,  q3,  q14
.endif

        bl              gather32_neon

        vld1.16         {q0,  q1},  [r1, :128]!    // src

        vmovl.u8        q6,  d8        // scaling
        vmovl.u8        q7,  d9
        vmovl.u8        q4,  d10
        vmovl.u8        q5,  d11

        vld1.16         {q2,  q3},  [r1, :128], r2 // src

        vshl.u16        q6,  q6,  q13  // scaling << (15 - scaling_shift)
        vshl.u16        q7,  q7,  q13
        vshl.u16        q4,  q4,  q13
        vshl.u16        q5,  q5,  q13

        vqrdmulh.s16    q8,  q8,  q6   // round2((scaling << (15 - scaling_shift) * grain, 15)
        vqrdmulh.s16    q9,  q9,  q7
        vqrdmulh.s16    q10, q10, q4
        vqrdmulh.s16    q11, q11, q5


        vdup.16         q4,  d31[0]    // clip_min
        vdup.16         q5,  d31[1]    // clip_max

        vqadd.s16       q0,  q0,  q8   // *src + noise
        vqadd.s16       q1,  q1,  q9
        vqadd.s16       q2,  q2,  q10
        vqadd.s16       q3,  q3,  q11

.if \oy
        vmov.32         lr,  d25[0] // 2 first 16 bit coeffs from overlap x
.endif

        vmax.s16        q0,  q0,  q4
        vmax.s16        q1,  q1,  q4
        vmax.s16        q2,  q2,  q4
        vmax.s16        q3,  q3,  q4
        vmin.s16        q0,  q0,  q5
        vmin.s16        q1,  q1,  q5
        vmin.s16        q2,  q2,  q5
        vmin.s16        q3,  q3,  q5

        vst1.16         {q0, q1}, [r0, :128]! // dst

        subs            r9,  r9,  #1
.if \oy
        vmov.32         d31[1], lr  // new coeffs for overlap y
.endif

        vst1.16         {q2, q3}, [r0, :128], r2 // dst
        bgt             1b

.if \oy
        cmp             r12, #0
        mov             r9,  r12               // restore actual remaining h
        bgt             L(fguv_loop_sx0_csfl\csfl\()_\ox\()0_loopstart)
.endif
        b               9f
.endm
        fguv_loop_sx0   0, 0, 0
        fguv_loop_sx0   0, 0, 1
        fguv_loop_sx0   0, 1, 0
        fguv_loop_sx0   0, 1, 1
        fguv_loop_sx0   1, 0, 0
        fguv_loop_sx0   1, 0, 1
        fguv_loop_sx0   1, 1, 0
        fguv_loop_sx0   1, 1, 1

9:
        vpop            {q4-q7}
        pop             {r4-r11,pc}
endfunc

function fguv_loop_sx1_neon
L(fguv_loop_sx1_tbl):
        .word L(fguv_loop_sx1_csfl0_00) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl0_01) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl0_10) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl0_11) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl1_00) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl1_01) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl1_10) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl1_11) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB

.macro fguv_loop_sx1 csfl, ox, oy
L(fguv_loop_sx1_csfl\csfl\()_\ox\oy):
.if \oy
        mov             r12, lr
.endif
1:
.if \ox
        vld1.16         {d0},       [r4],       r10 // grain_lut old
.endif
.if \ox && \oy
        vld1.16         {d2},       [r11],      r10 // grain_lut top old
.endif
.if \oy
        vld1.16         {q2,  q3},  [r8],       r10 // grain_lut top
.endif
.if !\ox && !\oy
        vld1.16         {q0,  q1},  [r6, :128]!     // luma
.endif
        vld1.16         {q8,  q9},  [r5],       r10 // grain_lut
.if \oy
        vdup.16         d28, d31[2]                 // overlap y coeff
        vdup.16         d29, d31[3]                 // overlap y coeff
.endif
.if !\ox && !\oy
        vld1.16         {q2,  q3},  [r6, :128], r7  // luma
.endif

.if \ox
        vdup.16         q7,  d30[3]                // bitdepth_max
        vmull.s16       q0,  d0,  d24
        vshr.u16        q7,  q7,  #1               // grain_max
        vmlal.s16       q0,  d16, d25
        vmvn            q6,  q7                    // grain_min
.endif

.if \oy
.if \ox
        vmull.s16       q1,  d2,  d24
        vmlal.s16       q1,  d4,  d25
        vqrshrn.s32     d16, q0,  #5
        vqrshrn.s32     d4,  q1,  #5
        vmin.s16        d4,  d4,  d14
        vmin.s16        d16, d16, d14
        vmax.s16        d4,  d4,  d12
        vmax.s16        d16, d16, d12
.endif

        vmull.s16       q0,  d4,  d28
        vmull.s16       q1,  d5,  d28
        vmull.s16       q2,  d6,  d28
        vmull.s16       q3,  d7,  d28
.if !\ox
        vdup.16         q7,  d30[3]                // bitdepth_max
.endif
        vmlal.s16       q0,  d16, d29
        vmlal.s16       q1,  d17, d29
        vmlal.s16       q2,  d18, d29
        vmlal.s16       q3,  d19, d29
.if !\ox
        vshr.u16        q7,  q7,  #1               // grain_max
.endif
        vqrshrn.s32     d16, q0,  #5
        vqrshrn.s32     d17, q1,  #5
        vqrshrn.s32     d18, q2,  #5
        vqrshrn.s32     d19, q3,  #5
.if !\ox
        vmvn            q6,  q7                    // grain_min
.endif
        vld1.16         {q0,  q1},  [r6, :128]!    // luma
        vmin.s16        q8,  q8,  q7
        vmin.s16        q9,  q9,  q7
        vmax.s16        q8,  q8,  q6
        vmax.s16        q9,  q9,  q6
        vld1.16         {q2,  q3},  [r6, :128], r7 // luma
.elseif \ox
        vqrshrn.s32     d16, q0,  #5
        vld1.16         {q0,  q1},  [r6, :128]!    // luma
        vmin.s16        d16, d16, d14
        vld1.16         {q2,  q3},  [r6, :128], r7 // luma
        vmax.s16        d16, d16, d12
.endif

        vpadd.i16       d0,  d0,  d1
        vpadd.i16       d1,  d2,  d3
        vpadd.i16       d2,  d4,  d5
        vpadd.i16       d3,  d6,  d7
        vrshr.u16       q0,  q0,  #1
        vrshr.u16       q1,  q1,  #1
.if !\csfl
        vdup.16         d28, d30[0]   // uv_luma_mult
        vld1.16         {q2,  q3},  [r1, :128], r2 // src
        vdup.16         d29, d30[1]   // uv_mult
        vmull.s16       q6,  d0,  d28
        vmull.s16       q7,  d1,  d28
        vmull.s16       q0,  d2,  d28
        vmull.s16       q1,  d3,  d28
        vmlal.s16       q6,  d4,  d29
        vmlal.s16       q7,  d5,  d29
        vmlal.s16       q0,  d6,  d29
        vmlal.s16       q1,  d7,  d29
        vshrn.s32       d12, q6,  #6
        vshrn.s32       d13, q7,  #6
        vshrn.s32       d14, q0,  #6
        vshrn.s32       d15, q1,  #6
        vdup.16         q14, d30[2]   // uv_offset
        vdup.16         q4,  d30[3]   // bitdepth_max
        vmov.i16        q5,  #0
        vadd.i16        q6,  q6,  q14
        vadd.i16        q7,  q7,  q14
        vmin.s16        q0,  q6,  q4
        vmin.s16        q1,  q7,  q4
        vmax.s16        q0,  q0,  q5
        vmax.s16        q1,  q1,  q5
.else
        vdup.16         q14, d30[3]  // bitdepth_max
        vld1.16         {q2,  q3},  [r1, :128], r2 // src

        // Make sure that uninitialized pixels out of range past the right
        // edge are in range; their actual values shouldn't matter.
        vand            q0,  q0,  q14
        vand            q1,  q1,  q14
.endif

        bl              gather16_neon

        vmovl.u8        q6,  d8        // scaling
        vmovl.u8        q7,  d9

        vshl.u16        q6,  q6,  q13  // scaling << (15 - scaling_shift)
        vshl.u16        q7,  q7,  q13

        vqrdmulh.s16    q8,  q8,  q6   // round2((scaling << (15 - scaling_shift) * grain, 15)
        vqrdmulh.s16    q9,  q9,  q7


        vdup.16         q4,  d31[0]    // clip_min
        vdup.16         q5,  d31[1]    // clip_max

        vqadd.s16       q0,  q2,  q8   // *src + noise
        vqadd.s16       q1,  q3,  q9

.if \oy
        // Swap the two last coefficients of d31, place them first in d28
        vrev64.16       d28, d31
.endif

        vmax.s16        q0,  q0,  q4
        vmax.s16        q1,  q1,  q4
        vmin.s16        q0,  q0,  q5
        vmin.s16        q1,  q1,  q5

        subs            r9,  r9,  #1
.if \oy
        // Take the first two 16 bit coefficients of d28 and place them at the
        // end of d31
        vtrn.32         d31, d28
.endif

        vst1.16         {q0, q1}, [r0, :128], r2 // dst
        bgt             1b

.if \oy
        cmp             r12, #0
        mov             r9,  r12               // restore actual remaining h
        bgt             L(fguv_loop_sx1_csfl\csfl\()_\ox\()0)
.endif

        b               9f
.endm
        fguv_loop_sx1   0, 0, 0
        fguv_loop_sx1   0, 0, 1
        fguv_loop_sx1   0, 1, 0
        fguv_loop_sx1   0, 1, 1
        fguv_loop_sx1   1, 0, 0
        fguv_loop_sx1   1, 0, 1
        fguv_loop_sx1   1, 1, 0
        fguv_loop_sx1   1, 1, 1

9:
        vpop            {q4-q7}
        pop             {r4-r11,pc}
endfunc