void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,

                                    int stride, int h, int x, int y) {

  POWERPC_PERF_DECLARE(PREFIX_h264_chroma_mc8_num, 1);

    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 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));

    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, vfdst, fsum;



  POWERPC_PERF_START_COUNT(PREFIX_h264_chroma_mc8_num, 1);



    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 (ABCD[3]) {

        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);



                CHROMA_MC8_ALTIVEC_CORE

            }

        } 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);



                CHROMA_MC8_ALTIVEC_CORE

            }

        }

    } else {

        const vec_s16 vE = vec_add(vB, vC);

        if (ABCD[2]) { // x == 0 B == 0

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

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

                    vsrcCuc = vec_ld(stride + 0, src);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE



                    vsrc0uc = vsrc1uc;

                }

            } else {

                vec_u8 vsrcDuc;

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

                    vsrcCuc = vec_ld(stride + 0, src);

                    vsrcDuc = vec_ld(stride + 15, src);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE



                    vsrc0uc = vsrc1uc;

                }

            }

        } else { // y == 0 C == 0

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

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

                    vsrcCuc = vec_ld(0, src);

                    vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);



                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE

                }

            } else {

                vec_u8 vsrcDuc;

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

                    vsrcCuc = vec_ld(0, src);

                    vsrcDuc = vec_ld(15, src);

                    vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

                    if (reallyBadAlign)

                        vsrc1uc = vsrcDuc;

                    else

                        vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);



                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE

                }

            }

        }

    }

    POWERPC_PERF_STOP_COUNT(PREFIX_h264_chroma_mc8_num, 1);

}

void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,

                                    int stride, int h, int x, int y) {

  POWERPC_PERF_DECLARE(PREFIX_h264_chroma_mc8_num, 1);

    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 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));

    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, vfdst, fsum;



  POWERPC_PERF_START_COUNT(PREFIX_h264_chroma_mc8_num, 1);



    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 (ABCD[3]) {

        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);



                CHROMA_MC8_ALTIVEC_CORE

            }

        } 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);



                CHROMA_MC8_ALTIVEC_CORE

            }

        }

    } else {

        const vec_s16 vE = vec_add(vB, vC);

        if (ABCD[2]) { 

            if (!loadSecond) {

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

                    vsrcCuc = vec_ld(stride + 0, src);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE



                    vsrc0uc = vsrc1uc;

                }

            } else {

                vec_u8 vsrcDuc;

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

                    vsrcCuc = vec_ld(stride + 0, src);

                    vsrcDuc = vec_ld(stride + 15, src);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE



                    vsrc0uc = vsrc1uc;

                }

            }

        } else { 

            if (!loadSecond) {

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

                    vsrcCuc = vec_ld(0, src);

                    vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);



                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE

                }

            } else {

                vec_u8 vsrcDuc;

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

                    vsrcCuc = vec_ld(0, src);

                    vsrcDuc = vec_ld(15, src);

                    vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

                    if (reallyBadAlign)

                        vsrc1uc = vsrcDuc;

                    else

                        vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);



                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE

                }

            }

        }

    }

    POWERPC_PERF_STOP_COUNT(PREFIX_h264_chroma_mc8_num, 1);

}

    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) {

  POWERPC_PERF_DECLARE(PREFIX_h264_chroma_mc8_num, 1);

    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_sl(vec_splat_s16(1),vec_splat_u16(5));

    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, vfdst, fsum;



  POWERPC_PERF_START_COUNT(PREFIX_h264_chroma_mc8_num, 1);



    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 (ABCD[3]) {

        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);



                CHROMA_MC8_ALTIVEC_CORE

            }

        } 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);



                CHROMA_MC8_ALTIVEC_CORE

            }

        }

    } else {

        const vec_s16 VAR_16 = vec_add(VAR_9, VAR_10);

        if (ABCD[2]) { 

            if (!VAR_14) {

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

                    vsrcCuc = vec_ld(VAR_2 + 0, VAR_1);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE



                    vsrc0uc = vsrc1uc;

                }

            } 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 + 15, VAR_1);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE



                    vsrc0uc = vsrc1uc;

                }

            }

        } else { 

            if (!VAR_14) {

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

                    vsrcCuc = vec_ld(0, VAR_1);

                    vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

                    vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);



                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE

                }

            } else {

                vec_u8 vsrcDuc;

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

                    vsrcCuc = vec_ld(0, VAR_1);

                    vsrcDuc = vec_ld(15, VAR_1);

                    vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

                    if (VAR_15)

                        vsrc1uc = vsrcDuc;

                    else

                        vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);



                    CHROMA_MC8_ALTIVEC_CORE_SIMPLE

                }

            }

        }

    }

    POWERPC_PERF_STOP_COUNT(PREFIX_h264_chroma_mc8_num, 1);

}

void FUNC_0(uint8_t * VAR_0, uint8_t * VAR_1,
int VAR_2, int VAR_3, int VAR_4, int VAR_5) { POWERPC_PERF_DECLARE(PREFIX_h264_chroma_mc8_num, 1); 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_sl(vec_splat_s16(1),vec_splat_u16(5)); 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, vfdst, fsum; POWERPC_PERF_START_COUNT(PREFIX_h264_chroma_mc8_num, 1); 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 (ABCD[3]) { 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); CHROMA_MC8_ALTIVEC_CORE
} } 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); CHROMA_MC8_ALTIVEC_CORE
} } } else { const vec_s16 VAR_16 = vec_add(VAR_9, VAR_10); if (ABCD[2]) { if (!VAR_14) { for (VAR_6 = 0 ; VAR_6 < VAR_3 ; VAR_6++) { vsrcCuc = vec_ld(VAR_2 + 0, VAR_1); vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0); CHROMA_MC8_ALTIVEC_CORE_SIMPLE
vsrc0uc = vsrc1uc; } } 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 + 15, VAR_1); vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0); CHROMA_MC8_ALTIVEC_CORE_SIMPLE
vsrc0uc = vsrc1uc; } } } else { if (!VAR_14) { for (VAR_6 = 0 ; VAR_6 < VAR_3 ; VAR_6++) { vsrcCuc = vec_ld(0, VAR_1); vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0); vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1); CHROMA_MC8_ALTIVEC_CORE_SIMPLE
} } else { vec_u8 vsrcDuc; for (VAR_6 = 0 ; VAR_6 < VAR_3 ; VAR_6++) { vsrcCuc = vec_ld(0, VAR_1); vsrcDuc = vec_ld(15, VAR_1); vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0); if (VAR_15)
vsrc1uc = vsrcDuc; else
vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1); CHROMA_MC8_ALTIVEC_CORE_SIMPLE
} } } } POWERPC_PERF_STOP_COUNT(PREFIX_h264_chroma_mc8_num, 1); }