void put_no_rnd_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {

   DECLARE_ALIGNED_16(signed int, ABCD[4]) =

                        {((8 - x) * (8 - y)),

                             ((x) * (8 - y)),

                         ((8 - x) * (y)),

                             ((x) * (y))};

    register int i;

    vec_u8 fperm;

    const vec_s32 vABCD = vec_ld(0, ABCD);

    const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);

    const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);

    const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);

    const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);

    LOAD_ZERO;

    const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));

    const vec_u16 v6us  = vec_splat_u16(6);

    register int loadSecond     = (((unsigned long)src) % 16) <= 7 ? 0 : 1;

    register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;



    vec_u8 vsrcAuc, vsrcBuc, vsrcperm0, vsrcperm1;

    vec_u8 vsrc0uc, vsrc1uc;

    vec_s16 vsrc0ssH, vsrc1ssH;

    vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;

    vec_s16 vsrc2ssH, vsrc3ssH, psum;

    vec_u8 vdst, ppsum, fsum;



    if (((unsigned long)dst) % 16 == 0) {

        fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,

                           0x14, 0x15, 0x16, 0x17,

                           0x08, 0x09, 0x0A, 0x0B,

                           0x0C, 0x0D, 0x0E, 0x0F};

    } else {

        fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,

                           0x04, 0x05, 0x06, 0x07,

                           0x18, 0x19, 0x1A, 0x1B,

                           0x1C, 0x1D, 0x1E, 0x1F};

    }



    vsrcAuc = vec_ld(0, src);



    if (loadSecond)

        vsrcBuc = vec_ld(16, src);

    vsrcperm0 = vec_lvsl(0, src);

    vsrcperm1 = vec_lvsl(1, src);



    vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);

    if (reallyBadAlign)

        vsrc1uc = vsrcBuc;

    else

        vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);



    vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc);

    vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc);



    if (!loadSecond) {// -> !reallyBadAlign

        for (i = 0 ; i < h ; i++) {





            vsrcCuc = vec_ld(stride + 0, src);



            vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

            vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);



            vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc);

            vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc);



            psum = vec_mladd(vA, vsrc0ssH, vec_splat_s16(0));

            psum = vec_mladd(vB, vsrc1ssH, psum);

            psum = vec_mladd(vC, vsrc2ssH, psum);

            psum = vec_mladd(vD, vsrc3ssH, psum);

            psum = vec_add(v28ss, psum);

            psum = vec_sra(psum, v6us);



            vdst = vec_ld(0, dst);

            ppsum = (vec_u8)vec_packsu(psum, psum);

            fsum = vec_perm(vdst, ppsum, fperm);



            vec_st(fsum, 0, dst);



            vsrc0ssH = vsrc2ssH;

            vsrc1ssH = vsrc3ssH;



            dst += stride;

            src += stride;

        }

    } else {

        vec_u8 vsrcDuc;

        for (i = 0 ; i < h ; i++) {

            vsrcCuc = vec_ld(stride + 0, src);

            vsrcDuc = vec_ld(stride + 16, src);



            vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

            if (reallyBadAlign)

                vsrc3uc = vsrcDuc;

            else

                vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);



            vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc);

            vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc);



            psum = vec_mladd(vA, vsrc0ssH, vec_splat_s16(0));

            psum = vec_mladd(vB, vsrc1ssH, psum);

            psum = vec_mladd(vC, vsrc2ssH, psum);

            psum = vec_mladd(vD, vsrc3ssH, psum);

            psum = vec_add(v28ss, psum);

            psum = vec_sr(psum, v6us);



            vdst = vec_ld(0, dst);

            ppsum = (vec_u8)vec_pack(psum, psum);

            fsum = vec_perm(vdst, ppsum, fperm);



            vec_st(fsum, 0, dst);



            vsrc0ssH = vsrc2ssH;

            vsrc1ssH = vsrc3ssH;



            dst += stride;

            src += stride;

        }

    }

}

void put_no_rnd_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {

   DECLARE_ALIGNED_16(signed int, ABCD[4]) =

                        {((8 - x) * (8 - y)),

                             ((x) * (8 - y)),

                         ((8 - x) * (y)),

                             ((x) * (y))};

    register int i;

    vec_u8 fperm;

    const vec_s32 vABCD = vec_ld(0, ABCD);

    const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);

    const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);

    const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);

    const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);

    LOAD_ZERO;

    const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));

    const vec_u16 v6us  = vec_splat_u16(6);

    register int loadSecond     = (((unsigned long)src) % 16) <= 7 ? 0 : 1;

    register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;



    vec_u8 vsrcAuc, vsrcBuc, vsrcperm0, vsrcperm1;

    vec_u8 vsrc0uc, vsrc1uc;

    vec_s16 vsrc0ssH, vsrc1ssH;

    vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;

    vec_s16 vsrc2ssH, vsrc3ssH, psum;

    vec_u8 vdst, ppsum, fsum;



    if (((unsigned long)dst) % 16 == 0) {

        fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,

                           0x14, 0x15, 0x16, 0x17,

                           0x08, 0x09, 0x0A, 0x0B,

                           0x0C, 0x0D, 0x0E, 0x0F};

    } else {

        fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,

                           0x04, 0x05, 0x06, 0x07,

                           0x18, 0x19, 0x1A, 0x1B,

                           0x1C, 0x1D, 0x1E, 0x1F};

    }



    vsrcAuc = vec_ld(0, src);



    if (loadSecond)

        vsrcBuc = vec_ld(16, src);

    vsrcperm0 = vec_lvsl(0, src);

    vsrcperm1 = vec_lvsl(1, src);



    vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);

    if (reallyBadAlign)

        vsrc1uc = vsrcBuc;

    else

        vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);



    vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc);

    vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc);



    if (!loadSecond) {

        for (i = 0 ; i < h ; i++) {





            vsrcCuc = vec_ld(stride + 0, src);



            vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

            vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);



            vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc);

            vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc);



            psum = vec_mladd(vA, vsrc0ssH, vec_splat_s16(0));

            psum = vec_mladd(vB, vsrc1ssH, psum);

            psum = vec_mladd(vC, vsrc2ssH, psum);

            psum = vec_mladd(vD, vsrc3ssH, psum);

            psum = vec_add(v28ss, psum);

            psum = vec_sra(psum, v6us);



            vdst = vec_ld(0, dst);

            ppsum = (vec_u8)vec_packsu(psum, psum);

            fsum = vec_perm(vdst, ppsum, fperm);



            vec_st(fsum, 0, dst);



            vsrc0ssH = vsrc2ssH;

            vsrc1ssH = vsrc3ssH;



            dst += stride;

            src += stride;

        }

    } else {

        vec_u8 vsrcDuc;

        for (i = 0 ; i < h ; i++) {

            vsrcCuc = vec_ld(stride + 0, src);

            vsrcDuc = vec_ld(stride + 16, src);



            vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

            if (reallyBadAlign)

                vsrc3uc = vsrcDuc;

            else

                vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);



            vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc);

            vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc);



            psum = vec_mladd(vA, vsrc0ssH, vec_splat_s16(0));

            psum = vec_mladd(vB, vsrc1ssH, psum);

            psum = vec_mladd(vC, vsrc2ssH, psum);

            psum = vec_mladd(vD, vsrc3ssH, psum);

            psum = vec_add(v28ss, psum);

            psum = vec_sr(psum, v6us);



            vdst = vec_ld(0, dst);

            ppsum = (vec_u8)vec_pack(psum, psum);

            fsum = vec_perm(vdst, ppsum, fperm);



            vec_st(fsum, 0, dst);



            vsrc0ssH = vsrc2ssH;

            vsrc1ssH = vsrc3ssH;



            dst += stride;

            src += stride;

        }

    }

}

    vec_u8 vsrcAuc, vsrcBuc, vsrcperm0, vsrcperm1;     vec_u8 vsrcAuc, vsrcBuc, vsrcperm0, vsrcperm1;
void FUNC_0(uint8_t * VAR_0, uint8_t * VAR_1, int VAR_2, int VAR_3, int VAR_4, int VAR_5) {

   DECLARE_ALIGNED_16(signed int, ABCD[4]) =

                        {((8 - VAR_4) * (8 - VAR_5)),

                             ((VAR_4) * (8 - VAR_5)),

                         ((8 - VAR_4) * (VAR_5)),

                             ((VAR_4) * (VAR_5))};

    register int VAR_6;

    vec_u8 fperm;

    const vec_s32 VAR_7 = vec_ld(0, ABCD);

    const vec_s16 VAR_8 = vec_splat((vec_s16)VAR_7, 1);

    const vec_s16 VAR_9 = vec_splat((vec_s16)VAR_7, 3);

    const vec_s16 VAR_10 = vec_splat((vec_s16)VAR_7, 5);

    const vec_s16 VAR_11 = vec_splat((vec_s16)VAR_7, 7);

    LOAD_ZERO;

    const vec_s16 VAR_12 = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));

    const vec_u16 VAR_13  = vec_splat_u16(6);

    register int VAR_14     = (((unsigned long)VAR_1) % 16) <= 7 ? 0 : 1;

    register int VAR_15 = (((unsigned long)VAR_1) % 16) == 15 ? 1 : 0;



    vec_u8 vsrcAuc, vsrcBuc, vsrcperm0, vsrcperm1;

    vec_u8 vsrc0uc, vsrc1uc;

    vec_s16 vsrc0ssH, vsrc1ssH;

    vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;

    vec_s16 vsrc2ssH, vsrc3ssH, psum;

    vec_u8 vdst, ppsum, fsum;



    if (((unsigned long)VAR_0) % 16 == 0) {

        fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,

                           0x14, 0x15, 0x16, 0x17,

                           0x08, 0x09, 0x0A, 0x0B,

                           0x0C, 0x0D, 0x0E, 0x0F};

    } else {

        fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,

                           0x04, 0x05, 0x06, 0x07,

                           0x18, 0x19, 0x1A, 0x1B,

                           0x1C, 0x1D, 0x1E, 0x1F};

    }



    vsrcAuc = vec_ld(0, VAR_1);



    if (VAR_14)

        vsrcBuc = vec_ld(16, VAR_1);

    vsrcperm0 = vec_lvsl(0, VAR_1);

    vsrcperm1 = vec_lvsl(1, VAR_1);



    vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);

    if (VAR_15)

        vsrc1uc = vsrcBuc;

    else

        vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);



    vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc);

    vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc);



    if (!VAR_14) {

        for (VAR_6 = 0 ; VAR_6 < VAR_3 ; VAR_6++) {





            vsrcCuc = vec_ld(VAR_2 + 0, VAR_1);



            vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

            vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);



            vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc);

            vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc);



            psum = vec_mladd(VAR_8, vsrc0ssH, vec_splat_s16(0));

            psum = vec_mladd(VAR_9, vsrc1ssH, psum);

            psum = vec_mladd(VAR_10, vsrc2ssH, psum);

            psum = vec_mladd(VAR_11, vsrc3ssH, psum);

            psum = vec_add(VAR_12, psum);

            psum = vec_sra(psum, VAR_13);



            vdst = vec_ld(0, VAR_0);

            ppsum = (vec_u8)vec_packsu(psum, psum);

            fsum = vec_perm(vdst, ppsum, fperm);



            vec_st(fsum, 0, VAR_0);



            vsrc0ssH = vsrc2ssH;

            vsrc1ssH = vsrc3ssH;



            VAR_0 += VAR_2;

            VAR_1 += VAR_2;

        }

    } else {

        vec_u8 vsrcDuc;

        for (VAR_6 = 0 ; VAR_6 < VAR_3 ; VAR_6++) {

            vsrcCuc = vec_ld(VAR_2 + 0, VAR_1);

            vsrcDuc = vec_ld(VAR_2 + 16, VAR_1);



            vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

            if (VAR_15)

                vsrc3uc = vsrcDuc;

            else

                vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);



            vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc);

            vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc);



            psum = vec_mladd(VAR_8, vsrc0ssH, vec_splat_s16(0));

            psum = vec_mladd(VAR_9, vsrc1ssH, psum);

            psum = vec_mladd(VAR_10, vsrc2ssH, psum);

            psum = vec_mladd(VAR_11, vsrc3ssH, psum);

            psum = vec_add(VAR_12, psum);

            psum = vec_sr(psum, VAR_13);



            vdst = vec_ld(0, VAR_0);

            ppsum = (vec_u8)vec_pack(psum, psum);

            fsum = vec_perm(vdst, ppsum, fperm);



            vec_st(fsum, 0, VAR_0);



            vsrc0ssH = vsrc2ssH;

            vsrc1ssH = vsrc3ssH;



            VAR_0 += VAR_2;

            VAR_1 += VAR_2;

        }

    }

}

void FUNC_0(uint8_t * VAR_0, uint8_t * VAR_1, int VAR_2, int VAR_3, int VAR_4, int VAR_5) { DECLARE_ALIGNED_16(signed int, ABCD[4]) =
{((8 - VAR_4) * (8 - VAR_5)), ((VAR_4) * (8 - VAR_5)),
((8 - VAR_4) * (VAR_5)),
((VAR_4) * (VAR_5))}; register int VAR_6; vec_u8 fperm; const vec_s32 VAR_7 = vec_ld(0, ABCD); const vec_s16 VAR_8 = vec_splat((vec_s16)VAR_7, 1); const vec_s16 VAR_9 = vec_splat((vec_s16)VAR_7, 3); const vec_s16 VAR_10 = vec_splat((vec_s16)VAR_7, 5); const vec_s16 VAR_11 = vec_splat((vec_s16)VAR_7, 7); LOAD_ZERO; const vec_s16 VAR_12 = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4)); const vec_u16 VAR_13  = vec_splat_u16(6); register int VAR_14     = (((unsigned long)VAR_1) % 16) <= 7 ? 0 : 1; register int VAR_15 = (((unsigned long)VAR_1) % 16) == 15 ? 1 : 0; vec_u8 vsrcAuc, vsrcBuc, vsrcperm0, vsrcperm1; vec_u8 vsrc0uc, vsrc1uc; vec_s16 vsrc0ssH, vsrc1ssH; vec_u8 vsrcCuc, vsrc2uc, vsrc3uc; vec_s16 vsrc2ssH, vsrc3ssH, psum; vec_u8 vdst, ppsum, fsum; if (((unsigned long)VAR_0) % 16 == 0) { fperm = (vec_u8){0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x08, 0x09, 0x0A, 0x0B,
0x0C, 0x0D, 0x0E, 0x0F}; } else { fperm = (vec_u8){0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x18, 0x19, 0x1A, 0x1B,
0x1C, 0x1D, 0x1E, 0x1F}; } vsrcAuc = vec_ld(0, VAR_1); if (VAR_14)
vsrcBuc = vec_ld(16, VAR_1); vsrcperm0 = vec_lvsl(0, VAR_1); vsrcperm1 = vec_lvsl(1, VAR_1); vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0); if (VAR_15)
vsrc1uc = vsrcBuc; else
vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1); vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc); vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc); if (!VAR_14) { for (VAR_6 = 0 ; VAR_6 < VAR_3 ; VAR_6++) { vsrcCuc = vec_ld(VAR_2 + 0, VAR_1); vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0); vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1); vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc); vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc); psum = vec_mladd(VAR_8, vsrc0ssH, vec_splat_s16(0)); psum = vec_mladd(VAR_9, vsrc1ssH, psum); psum = vec_mladd(VAR_10, vsrc2ssH, psum); psum = vec_mladd(VAR_11, vsrc3ssH, psum); psum = vec_add(VAR_12, psum); psum = vec_sra(psum, VAR_13); vdst = vec_ld(0, VAR_0); ppsum = (vec_u8)vec_packsu(psum, psum); fsum = vec_perm(vdst, ppsum, fperm); vec_st(fsum, 0, VAR_0); vsrc0ssH = vsrc2ssH; vsrc1ssH = vsrc3ssH; VAR_0 += VAR_2; VAR_1 += VAR_2; } } else { vec_u8 vsrcDuc; for (VAR_6 = 0 ; VAR_6 < VAR_3 ; VAR_6++) { vsrcCuc = vec_ld(VAR_2 + 0, VAR_1); vsrcDuc = vec_ld(VAR_2 + 16, VAR_1); vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0); if (VAR_15)
vsrc3uc = vsrcDuc; else
vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1); vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc2uc); vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc3uc); psum = vec_mladd(VAR_8, vsrc0ssH, vec_splat_s16(0)); psum = vec_mladd(VAR_9, vsrc1ssH, psum); psum = vec_mladd(VAR_10, vsrc2ssH, psum); psum = vec_mladd(VAR_11, vsrc3ssH, psum); psum = vec_add(VAR_12, psum); psum = vec_sr(psum, VAR_13); vdst = vec_ld(0, VAR_0); ppsum = (vec_u8)vec_pack(psum, psum); fsum = vec_perm(vdst, ppsum, fperm); vec_st(fsum, 0, VAR_0); vsrc0ssH = vsrc2ssH; vsrc1ssH = vsrc3ssH; VAR_0 += VAR_2; VAR_1 += VAR_2; } } }