LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_partition_set(x264_macroblock_t*, int, int, int, int, int, int)
void x264_mb_partition_set(x264_macroblock_t *mb, int i_list, int i_part, int i_sub, int i_ref, int mx, int my) {LOG_CALL;
    int x, y;
    int w, h;
    int dx, dy;

    x264_mb_partition_getxy(mb, i_part, i_sub, &x, &y);
    x264_mb_partition_size(mb, i_part, i_sub, &w, &h);

    for (dx = 0; dx < w; dx++)
    {
        for (dy = 0; dy < h; dy++)
        {
            mb->partition[x + dx][y + dy].i_ref[i_list] = i_ref;
            mb->partition[x + dx][y + dy].mv[i_list][0] = mx;
            mb->partition[x + dx][y + dy].mv[i_list][1] = my;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %r14d
movl %ecx, %r13d
movl %edx, %r15d
movl %esi, -0x2c(%rbp)
movq %rdi, %r12
leaq 0x1e679(%rip), %rdi     # 0x251b4
leaq 0x1ecee(%rip), %rsi     # 0x25830
leaq 0x1ed8c(%rip), %rdx     # 0x258d5
xorl %eax, %eax
callq 0x4c22
movl 0x1c(%r12), %ecx
cmpl $0xd, %ecx
je 0x6b7b
cmpl $0xf, %ecx
je 0x6b72
cmpl $0xe, %ecx
movl $0x0, %r8d
jne 0x6b6e
leal (%r15,%r15), %r8d
xorl %eax, %eax
jmp 0x6bdf
leal (%r15,%r15), %eax
xorl %r8d, %r8d
jmp 0x6bdf
movl %r15d, %r8d
shrl $0x1f, %r8d
addl %r15d, %r8d
andl $-0x2, %r8d
movl %r15d, %eax
subl %r8d, %eax
addl %eax, %eax
movslq %r15d, %rdx
movl 0x20(%r12,%rdx,4), %edx
cmpl $0xa, %edx
ja 0x6bdf
movl $0x111, %esi            # imm = 0x111
btl %edx, %esi
jb 0x6bc1
movl $0x222, %esi            # imm = 0x222
btl %edx, %esi
jb 0x6bdc
movl $0x444, %esi            # imm = 0x444
btl %edx, %esi
jae 0x6bdf
addl %r13d, %eax
jmp 0x6bdf
movl %r13d, %edx
shrl $0x1f, %edx
addl %r13d, %edx
movl %edx, %esi
andl $-0x2, %esi
subl %esi, %r13d
addl %r13d, %eax
sarl %edx
addl %edx, %r8d
jmp 0x6bdf
addl %r13d, %r8d
cmpl $0xd, %ecx
je 0x6c06
movl $0x4, %edx
cmpl $0xf, %ecx
je 0x6bff
cmpl $0xe, %ecx
jne 0x6bf8
movl $0x2, %edx
movl $0x4, %ecx
jmp 0x6c34
movl $0x2, %ecx
jmp 0x6c34
movslq %r15d, %rcx
movl 0x20(%r12,%rcx,4), %esi
movl $0x2, %ecx
movl $0x2, %edx
cmpq $0xa, %rsi
ja 0x6c34
leaq 0x1f1cb(%rip), %rcx     # 0x25df0
movq (%rcx,%rsi,8), %rcx
leaq 0x1f218(%rip), %rdx     # 0x25e48
movq (%rdx,%rsi,8), %rdx
movl 0x10(%rbp), %esi
movslq -0x2c(%rbp), %rdi
movslq %r8d, %r8
cltq
leaq (%rax,%rax,4), %rax
shlq $0x5, %rax
leaq (%r8,%r8,4), %r8
leaq (%rax,%r8,8), %r8
leaq (%r8,%rdi,8), %rax
addq %r12, %rax
addq $0x3c, %rax
leaq (%r8,%rdi,4), %rdi
addq %r12, %rdi
addq $0x30, %rdi
xorl %r8d, %r8d
movl $0xa0, %r9d
movq %rdx, %r10
xorl %r11d, %r11d
movl %r14d, (%rdi,%r11)
movl %ebx, -0x4(%rax,%r11)
movl %esi, (%rax,%r11)
addq $0x28, %r11
decq %r10
jne 0x6c75
incq %r8
addq %r9, %rax
addq %r9, %rdi
cmpq %rcx, %r8
jne 0x6c6f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_partition_get(x264_macroblock_t*, int, int, int, int*, int*, int*)
void x264_mb_partition_get(x264_macroblock_t *mb, int i_list, int i_part, int i_sub, int *pi_ref, int *pi_mx, int *pi_my) {LOG_CALL;
    int x, y;

    x264_mb_partition_getxy(mb, i_part, i_sub, &x, &y);

    if (pi_ref)
    {
        *pi_ref = mb->partition[x][y].i_ref[i_list];
    }
    if (pi_mx && pi_my)
    {
        *pi_mx = mb->partition[x][y].mv[i_list][0];
        *pi_my = mb->partition[x][y].mv[i_list][1];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, -0x38(%rbp)
movl %ecx, %ebx
movl %edx, %r13d
movl %esi, -0x2c(%rbp)
movq %rdi, %r14
leaq 0x1e4e2(%rip), %rdi     # 0x251b4
leaq 0x1eb57(%rip), %rsi     # 0x25830
leaq 0x1ec0b(%rip), %rdx     # 0x258eb
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x4c22
movl 0x1c(%r14), %eax
cmpl $0xd, %eax
je 0x6d14
cmpl $0xf, %eax
je 0x6d0f
cmpl $0xe, %eax
movq -0x38(%rbp), %r9
movl -0x2c(%rbp), %ecx
jne 0x6d0a
movl %r13d, %r12d
addl %r13d, %r12d
xorl %r13d, %r13d
jmp 0x6d7a
addl %r13d, %r13d
jmp 0x6d73
movl %r13d, %r12d
shrl $0x1f, %r12d
addl %r13d, %r12d
andl $-0x2, %r12d
movslq %r13d, %rax
subl %r12d, %r13d
addl %r13d, %r13d
movl 0x20(%r14,%rax,4), %eax
cmpl $0xa, %eax
ja 0x6d73
movl $0x111, %ecx            # imm = 0x111
btl %eax, %ecx
jb 0x6d58
movl $0x222, %ecx            # imm = 0x222
btl %eax, %ecx
jb 0x6d70
movl $0x444, %ecx            # imm = 0x444
btl %eax, %ecx
jae 0x6d73
addl %ebx, %r13d
jmp 0x6d73
movl %ebx, %eax
shrl $0x1f, %eax
addl %ebx, %eax
movl %eax, %ecx
andl $-0x2, %ecx
subl %ecx, %ebx
addl %ebx, %r13d
sarl %eax
addl %eax, %r12d
jmp 0x6d73
addl %ebx, %r12d
movq -0x38(%rbp), %r9
movl -0x2c(%rbp), %ecx
movq 0x10(%rbp), %rax
movslq %r13d, %rsi
movslq %r12d, %rdx
movslq %ecx, %rcx
testq %r9, %r9
je 0x6da6
leaq (%rsi,%rsi,4), %rdi
shlq $0x5, %rdi
addq %r14, %rdi
leaq (%rdx,%rdx,4), %r8
leaq (%rdi,%r8,8), %rdi
movl 0x30(%rdi,%rcx,4), %edi
movl %edi, (%r9)
testq %r15, %r15
sete %dil
testq %rax, %rax
sete %r8b
orb %dil, %r8b
jne 0x6dd9
leaq (%rsi,%rsi,4), %rsi
shlq $0x5, %rsi
addq %rsi, %r14
leaq (%rdx,%rdx,4), %rdx
leaq (%r14,%rdx,8), %rdx
movl 0x38(%rdx,%rcx,8), %esi
movl %esi, (%r15)
movl 0x3c(%rdx,%rcx,8), %ecx
movl %ecx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_predict_mv_pskip(x264_macroblock_t*, int*)
void x264_mb_predict_mv_pskip(x264_macroblock_t *mb, int mv[2]) {LOG_CALL;
    int x, y, xn, yn;

    int i_refa = -1;
    int i_refb = -1;

    int mvxa = 0, mvxb = 0;
    int mvya = 0, mvyb = 0;

    x264_macroblock_t *mbn;


    x264_mb_partition_getxy(mb, 0, 0, &x, &y);

    /* Left  pixel (-1,0)*/
    xn = x - 1;
    mbn = mb;
    if (xn < 0)
    {
        xn += 4;
        mbn = mb->context->mba;
    }
    if (mbn)
    {
        i_refa = -2;
        if (!IS_INTRA(mbn->i_type) && mbn->partition[xn][y].i_ref[0] != -1)
        {
            i_refa = mbn->partition[xn][y].i_ref[0];
            mvxa = mbn->partition[xn][y].mv[0][0];
            mvya = mbn->partition[xn][y].mv[0][1];
        }
    }

    /* Up ( pixel(0,-1)*/
    yn = y - 1;
    mbn = mb;
    if (yn < 0)
    {
        yn += 4;
        mbn = mb->context->mbb;
    }
    if (mbn)
    {
        i_refb = -2;
        if (!IS_INTRA(mbn->i_type) && mbn->partition[x][yn].i_ref[0] != -1)
        {
            i_refb = mbn->partition[x][yn].i_ref[0];
            mvxb = mbn->partition[x][yn].mv[0][0];
            mvyb = mbn->partition[x][yn].mv[0][1];
        }
    }

    if (i_refa == -1 || i_refb == -1 ||
            (i_refa == 0 && mvxa == 0 && mvya == 0) ||
            (i_refb == 0 && mvxb == 0 && mvyb == 0))
    {
        mv[0] = 0;
        mv[1] = 0;
    } else
    {
        x264_mb_predict_mv(mb, 0, 0, 0, mv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1de94(%rip), %rdi     # 0x251b4
leaq 0x1e509(%rip), %rsi     # 0x25830
leaq 0x1e5e6(%rip), %rdx     # 0x25914
xorl %eax, %eax
callq 0x4c22
movq 0x10(%r14), %rax
movq (%rax), %r8
movb $0x1, %al
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movb $0x1, %sil
movb $0x1, %dil
testq %r8, %r8
je 0x7387
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
cmpl $0x2, 0x18(%r8)
jb 0x7387
movl 0x210(%r8), %r9d
cmpl $-0x1, %r9d
je 0x7387
cmpl $0x0, 0x218(%r8)
sete %sil
cmpl $0x0, 0x21c(%r8)
sete %dil
movl %r9d, %edx
movq 0x10(%r14), %r8
movq 0x8(%r8), %r9
testq %r9, %r9
je 0x73a0
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
cmpl $0x2, 0x18(%r9)
jae 0x73a5
movb $0x1, %r8b
jmp 0x73cf
movl 0xa8(%r9), %r10d
movb $0x1, %r8b
cmpl $-0x1, %r10d
je 0x73cf
cmpl $0x0, 0xb0(%r9)
sete %al
cmpl $0x0, 0xb4(%r9)
sete %r8b
movl %r10d, %ecx
cmpl $-0x1, %edx
je 0x73f4
cmpl $-0x1, %ecx
je 0x73f4
testl %edx, %edx
sete %dl
andb %sil, %dl
testb %dil, %dl
jne 0x73f4
testl %ecx, %ecx
sete %cl
andb %r8b, %al
andb %cl, %al
cmpb $0x1, %al
jne 0x7400
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %rbp
jmp 0x6de8
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: motion_compensation_chroma(unsigned char*, int, unsigned char*, int, int, int, int, int)
static void motion_compensation_chroma( uint8_t *src, int i_src_stride,
                                        uint8_t *dst, int i_dst_stride,
                                        int mvx, int mvy,
                                        int i_width, int i_height )
{
    uint8_t *srcp;
    int x, y;

    const int d8x = mvx&0x07;
    const int d8y = mvy&0x07;

    const int cA = (8-d8x)*(8-d8y);
    const int cB = d8x    *(8-d8y);
    const int cC = (8-d8x)*d8y;
    const int cD = d8x    *d8y;

    src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
    srcp = &src[i_src_stride];

    for( y = 0; y < i_height; y++ )
    {
        for( x = 0; x < i_width; x++ )
        {
            dst[x] = ( cA*src[x]  + cB*src[x+1] +
                       cC*srcp[x] + cD*srcp[x+1] + 32 ) >> 6;
        }
        dst  += i_dst_stride;

        src   = srcp;
        srcp += i_src_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, 0x18(%rbp)
jle 0x88b5
movslq %esi, %rsi
movl %r9d, %r11d
sarl $0x3, %r11d
movl %esi, %ebx
imull %r11d, %ebx
movl %r8d, %r11d
sarl $0x3, %r11d
addl %ebx, %r11d
movslq %r11d, %r12
leaq (%rdi,%r12), %r11
andl $0x7, %r9d
movl $0x8, %ebx
movl $0x8, %r15d
subl %r9d, %r15d
andl $0x7, %r8d
subl %r8d, %ebx
movl %ebx, %r14d
imull %r9d, %r14d
imull %r8d, %r9d
imull %r15d, %ebx
imull %r15d, %r8d
movslq %ecx, %rax
movq %rax, -0x30(%rbp)
movl 0x10(%rbp), %r15d
addq %rsi, %r12
addq %r12, %rdi
incq %rdi
xorl %r12d, %r12d
cmpl $0x0, 0x10(%rbp)
jle 0x88a2
xorl %r13d, %r13d
movzbl (%r11,%r13), %eax
imull %ebx, %eax
movzbl 0x1(%r11,%r13), %r10d
imull %r8d, %r10d
addl %eax, %r10d
movzbl -0x1(%rdi,%r13), %eax
imull %r14d, %eax
movzbl (%rdi,%r13), %ecx
imull %r9d, %ecx
addl %eax, %ecx
leal (%r10,%rcx), %eax
addl $0x20, %eax
shrl $0x6, %eax
movb %al, (%rdx,%r13)
leaq 0x1(%r13), %rax
movq %rax, %r13
cmpq %rax, %r15
jne 0x885e
addq %rsi, %r11
addq -0x30(%rbp), %rdx
incl %r12d
addq %rsi, %rdi
cmpl 0x18(%rbp), %r12d
jne 0x8855
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_copy(unsigned char*, int, unsigned char*, int, int, int)
static void mc_copy( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    int y;

    for( y = 0; y < i_height; y++ )
    {
        memcpy( dst, src, i_width );

        src += i_src_stride;
        dst += i_dst_stride;
    }
}

// Assembly:
testl %r9d, %r9d
jle 0x8910
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %rdx, %r14
movq %rdi, %r15
movslq %r8d, %rax
movq %rax, -0x30(%rbp)
movslq %esi, %r13
movslq %ecx, %r12
movq %r14, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x20a0
addq %r13, %r15
addq %r12, %r14
decl %ebx
jne 0x88e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_hh(unsigned char*, int, unsigned char*, int, int, int)
static inline void mc_hh( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    int x, y;

    for( y = 0; y < i_height; y++ )
    {
        for( x = 0; x < i_width; x++ )
        {
            dst[x] = x264_mc_clip1( ( x264_tapfilter1( &src[x] ) + 16 ) >> 5 );
        }
        src += i_src_stride;
        dst += i_dst_stride;
    }
}

// Assembly:
testl %r9d, %r9d
jle 0x8abe
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rax
movslq %ecx, %rcx
movl %r8d, %esi
xorl %r10d, %r10d
leaq 0x1d4ba(%rip), %r11     # 0x25f00
testl %r8d, %r8d
jle 0x8aa6
xorl %ebx, %ebx
movzbl -0x2(%rdi,%rbx), %r14d
movzbl -0x1(%rdi,%rbx), %r15d
movzbl (%rdi,%rbx), %r12d
movzbl 0x1(%rdi,%rbx), %r13d
addl %r12d, %r13d
leal (%r13,%r13,4), %r12d
movzbl 0x2(%rdi,%rbx), %r13d
addl %r15d, %r13d
movzbl 0x3(%rdi,%rbx), %r15d
leal (%r13,%r13,4), %r13d
leal (%r14,%r12,4), %r14d
addl %r15d, %r14d
subl %r13d, %r14d
addl $0x10, %r14d
sarl $0x5, %r14d
addl $0x50, %r14d
movb (%r14,%r11), %r14b
movb %r14b, (%rdx,%rbx)
incq %rbx
cmpq %rbx, %rsi
jne 0x8a4d
addq %rax, %rdi
addq %rcx, %rdx
incl %r10d
cmpl %r9d, %r10d
jne 0x8a46
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_xy11(unsigned char*, int, unsigned char*, int, int, int)
static void mc_xy11( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    uint8_t tmp1[16*16];
    uint8_t tmp2[16*16];

    mc_hv( src, i_src_stride, tmp1, i_width, i_width, i_height );
    mc_hh( src, i_src_stride, tmp2, i_width, i_width, i_height );
    pixel_avg( dst, i_dst_stride, tmp1, i_width, tmp2, i_width, i_width, i_height );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %ecx, -0x3c(%rbp)
testl %r9d, %r9d
jle 0x8ef1
movq %rdx, -0x50(%rbp)
movl %r9d, -0x30(%rbp)
leal (%rsi,%rsi), %eax
movslq %eax, %rbx
negl %eax
movslq %eax, %r14
movslq %esi, %rcx
negl %esi
movslq %esi, %r15
leal (%rcx,%rcx,2), %eax
movslq %eax, %r12
movl %r8d, -0x2c(%rbp)
movslq %r8d, %rax
movq %rax, -0x38(%rbp)
movl %eax, %esi
addq %rdi, %r12
addq %rdi, %rbx
movq %rcx, -0x48(%rbp)
leaq (%rdi,%rcx), %r13
addq %rdi, %r15
addq %rdi, %r14
leaq -0x260(%rbp), %rax
xorl %edx, %edx
leaq 0x1d16b(%rip), %r11     # 0x25f00
movq %rdi, %r8
movq %rdx, -0x58(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x8df1
xorl %r9d, %r9d
movzbl (%r15,%r9), %r10d
movzbl (%r8,%r9), %ecx
movzbl (%r13,%r9), %edx
addl %ecx, %edx
movzbl (%rbx,%r9), %ecx
addl %r10d, %ecx
movzbl (%r14,%r9), %r10d
leal (%rdx,%rdx,4), %edx
leal (%r10,%rdx,4), %edx
movzbl (%r12,%r9), %r10d
addl %r10d, %edx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %edx
addl $0x10, %edx
sarl $0x5, %edx
addl $0x50, %edx
movb (%rdx,%r11), %cl
movb %cl, (%rax,%r9)
incq %r9
cmpq %r9, %rsi
jne 0x8da5
movq -0x48(%rbp), %rcx
addq %rcx, %r8
addq -0x38(%rbp), %rax
movq -0x58(%rbp), %rdx
incl %edx
addq %rcx, %r12
addq %rcx, %rbx
addq %rcx, %r13
addq %rcx, %r15
addq %rcx, %r14
cmpl -0x30(%rbp), %edx
jne 0x8d98
movl -0x30(%rbp), %r14d
testl %r14d, %r14d
movl -0x2c(%rbp), %r15d
movq -0x50(%rbp), %r12
jle 0x8ef1
leaq -0x160(%rbp), %rax
xorl %ecx, %ecx
testl %r15d, %r15d
jle 0x8e8e
xorl %r8d, %r8d
movzbl -0x2(%rdi,%r8), %edx
movzbl -0x1(%rdi,%r8), %r9d
movzbl (%rdi,%r8), %r10d
movzbl 0x1(%rdi,%r8), %ebx
addl %r10d, %ebx
leal (%rbx,%rbx,4), %r10d
movzbl 0x2(%rdi,%r8), %ebx
addl %r9d, %ebx
movzbl 0x3(%rdi,%r8), %r9d
leal (%rbx,%rbx,4), %ebx
leal (%rdx,%r10,4), %edx
addl %r9d, %edx
subl %ebx, %edx
addl $0x10, %edx
sarl $0x5, %edx
addl $0x50, %edx
movb (%rdx,%r11), %dl
movb %dl, (%rax,%r8)
incq %r8
cmpq %r8, %rsi
jne 0x8e3c
addq -0x48(%rbp), %rdi
addq -0x38(%rbp), %rax
incl %ecx
cmpl %r14d, %ecx
jne 0x8e34
testl %r14d, %r14d
jle 0x8ef1
movslq -0x3c(%rbp), %rax
leaq -0x160(%rbp), %rcx
leaq -0x260(%rbp), %rdi
xorl %r8d, %r8d
testl %r15d, %r15d
jle 0x8edc
xorl %r9d, %r9d
movzbl (%rdi,%r9), %edx
movzbl (%rcx,%r9), %r10d
addl %r10d, %edx
incl %edx
shrl %edx
movb %dl, (%r12,%r9)
incq %r9
cmpq %r9, %rsi
jne 0x8ebf
addq %rax, %r12
movq -0x38(%rbp), %rdx
addq %rdx, %rdi
addq %rdx, %rcx
incl %r8d
cmpl %r14d, %r8d
jne 0x8eb7
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_xy21(unsigned char*, int, unsigned char*, int, int, int)
static void mc_xy21( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    uint8_t tmp1[16*16];
    uint8_t tmp2[16*16];

    mc_hc( src, i_src_stride, tmp1, i_width, i_width, i_height );
    mc_hh( src, i_src_stride, tmp2, i_width, i_width, i_height );
    pixel_avg( dst, i_dst_stride, tmp1, i_width, tmp2, i_width, i_width, i_height );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %r9d, %ebx
movl %ecx, -0x3c(%rbp)
movq %rdx, %r15
movq %rdi, %r13
leaq -0x240(%rbp), %r12
movl %esi, -0x38(%rbp)
movq %r12, %rdx
movl %r8d, %ecx
movl %r8d, -0x2c(%rbp)
callq 0x9491
testl %ebx, %ebx
jle 0x9019
movl %ebx, %r14d
movslq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %ecx
movslq %ecx, %rax
movl %ecx, %ecx
leaq -0x140(%rbp), %rsi
xorl %edi, %edi
leaq 0x1cf99(%rip), %r8      # 0x25f00
cmpl $0x0, -0x2c(%rbp)
jle 0x8fc1
xorl %r9d, %r9d
movzbl -0x2(%r13,%r9), %r10d
movzbl -0x1(%r13,%r9), %r11d
movzbl (%r13,%r9), %ebx
movzbl 0x1(%r13,%r9), %edx
addl %ebx, %edx
leal (%rdx,%rdx,4), %edx
movzbl 0x2(%r13,%r9), %ebx
addl %r11d, %ebx
movzbl 0x3(%r13,%r9), %r11d
leal (%rbx,%rbx,4), %ebx
leal (%r10,%rdx,4), %edx
addl %r11d, %edx
subl %ebx, %edx
addl $0x10, %edx
sarl $0x5, %edx
addl $0x50, %edx
movb (%rdx,%r8), %dl
movb %dl, (%rsi,%r9)
incq %r9
cmpq %r9, %rcx
jne 0x8f70
addq -0x38(%rbp), %r13
addq %rax, %rsi
incl %edi
cmpl %r14d, %edi
jne 0x8f67
testl %r14d, %r14d
jle 0x9019
movslq -0x3c(%rbp), %rdx
leaq -0x140(%rbp), %rsi
xorl %edi, %edi
cmpl $0x0, -0x2c(%rbp)
jle 0x9009
xorl %r8d, %r8d
movzbl (%r12,%r8), %r9d
movzbl (%rsi,%r8), %r10d
addl %r10d, %r9d
incl %r9d
shrl %r9d
movb %r9b, (%r15,%r8)
incq %r8
cmpq %r8, %rcx
jne 0x8fea
addq %rdx, %r15
addq %rax, %r12
addq %rax, %rsi
incl %edi
cmpl %r14d, %edi
jne 0x8fe1
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_xy31(unsigned char*, int, unsigned char*, int, int, int)
static void mc_xy31( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    uint8_t tmp1[16*16];
    uint8_t tmp2[16*16];

    mc_hv( src+1, i_src_stride, tmp1, i_width, i_width, i_height );
    mc_hh( src,   i_src_stride, tmp2, i_width, i_width, i_height );
    pixel_avg( dst, i_dst_stride, tmp1, i_width, tmp2, i_width, i_width, i_height );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %ecx, -0x3c(%rbp)
testl %r9d, %r9d
jle 0x920f
movq %rdx, -0x50(%rbp)
movl %r9d, -0x30(%rbp)
leaq 0x1(%rdi), %rbx
leal (%rsi,%rsi), %eax
movslq %eax, %rcx
negl %eax
cltq
movslq %esi, %r9
leal (%r9,%r9,2), %esi
movslq %esi, %rdx
movl %r8d, -0x2c(%rbp)
movslq %r8d, %rsi
movq %rsi, -0x38(%rbp)
movl %esi, %esi
leaq 0x1(%rdi,%rdx), %r14
leaq 0x1(%rdi,%rcx), %r15
leaq (%rdi,%r9), %r12
incq %r12
movq %rdi, %r13
movq %r9, -0x48(%rbp)
subq %r9, %r13
incq %r13
addq %rdi, %rax
incq %rax
leaq -0x260(%rbp), %rcx
xorl %r8d, %r8d
leaq 0x1ce53(%rip), %r11     # 0x25f00
movq %r8, -0x58(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x9109
xorl %r9d, %r9d
movzbl (%r13,%r9), %r10d
movzbl (%rbx,%r9), %r8d
movzbl (%r12,%r9), %edx
addl %r8d, %edx
movzbl (%r15,%r9), %r8d
addl %r10d, %r8d
movzbl (%rax,%r9), %r10d
leal (%rdx,%rdx,4), %edx
leal (%r10,%rdx,4), %edx
movzbl (%r14,%r9), %r10d
addl %r10d, %edx
leal (%r8,%r8,4), %r8d
subl %r8d, %edx
addl $0x10, %edx
sarl $0x5, %edx
addl $0x50, %edx
movb (%rdx,%r11), %dl
movb %dl, (%rcx,%r9)
incq %r9
cmpq %r9, %rsi
jne 0x90ba
movq -0x48(%rbp), %rdx
addq %rdx, %rbx
addq -0x38(%rbp), %rcx
movq -0x58(%rbp), %r8
incl %r8d
addq %rdx, %r14
addq %rdx, %r15
addq %rdx, %r12
addq %rdx, %r13
addq %rdx, %rax
cmpl -0x30(%rbp), %r8d
jne 0x90ad
movl -0x30(%rbp), %r14d
testl %r14d, %r14d
movl -0x2c(%rbp), %r15d
movq -0x50(%rbp), %r12
jle 0x920f
leaq -0x160(%rbp), %rax
xorl %ecx, %ecx
testl %r15d, %r15d
jle 0x91ac
xorl %r8d, %r8d
movzbl -0x2(%rdi,%r8), %edx
movzbl -0x1(%rdi,%r8), %r9d
movzbl (%rdi,%r8), %r10d
movzbl 0x1(%rdi,%r8), %ebx
addl %r10d, %ebx
leal (%rbx,%rbx,4), %r10d
movzbl 0x2(%rdi,%r8), %ebx
addl %r9d, %ebx
movzbl 0x3(%rdi,%r8), %r9d
leal (%rbx,%rbx,4), %ebx
leal (%rdx,%r10,4), %edx
addl %r9d, %edx
subl %ebx, %edx
addl $0x10, %edx
sarl $0x5, %edx
addl $0x50, %edx
movb (%rdx,%r11), %dl
movb %dl, (%rax,%r8)
incq %r8
cmpq %r8, %rsi
jne 0x915a
addq -0x48(%rbp), %rdi
addq -0x38(%rbp), %rax
incl %ecx
cmpl %r14d, %ecx
jne 0x9152
testl %r14d, %r14d
jle 0x920f
movslq -0x3c(%rbp), %rax
leaq -0x160(%rbp), %rcx
leaq -0x260(%rbp), %rdi
xorl %r8d, %r8d
testl %r15d, %r15d
jle 0x91fa
xorl %r9d, %r9d
movzbl (%rdi,%r9), %edx
movzbl (%rcx,%r9), %r10d
addl %r10d, %edx
incl %edx
shrl %edx
movb %dl, (%r12,%r9)
incq %r9
cmpq %r9, %rsi
jne 0x91dd
addq %rax, %r12
movq -0x38(%rbp), %rdx
addq %rdx, %rdi
addq %rdx, %rcx
incl %r8d
cmpl %r14d, %r8d
jne 0x91d5
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_xy12(unsigned char*, int, unsigned char*, int, int, int)
static void mc_xy12( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    uint8_t tmp1[16*16];
    uint8_t tmp2[16*16];

    mc_hc( src, i_src_stride, tmp1, i_width, i_width, i_height );
    mc_hv( src, i_src_stride, tmp2, i_width, i_width, i_height );
    pixel_avg( dst, i_dst_stride, tmp1, i_width, tmp2, i_width, i_width, i_height );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl %r9d, %ebx
movl %ecx, -0x34(%rbp)
movq %rdx, %r14
movq %rdi, %r13
leaq -0x260(%rbp), %r12
movq %rsi, %r15
movq %r12, %rdx
movl %r8d, %ecx
movl %r8d, -0x2c(%rbp)
callq 0x9491
movl %ebx, -0x30(%rbp)
testl %ebx, %ebx
jle 0x947f
movq %r14, -0x48(%rbp)
leal (%r15,%r15), %eax
movslq %eax, %rdx
negl %eax
movslq %eax, %rsi
movl %r15d, %eax
negl %eax
movslq %eax, %rdi
movslq %r15d, %r8
leal (%r15,%r15,2), %eax
movslq %eax, %r9
movl -0x2c(%rbp), %eax
movslq %eax, %rcx
movq %rcx, -0x40(%rbp)
movl %eax, %ecx
addq %r13, %r9
addq %r13, %rdx
movq %r8, -0x50(%rbp)
leaq (%r8,%r13), %r10
addq %r13, %rdi
addq %r13, %rsi
leaq -0x160(%rbp), %r11
xorl %r8d, %r8d
leaq 0x1cb5d(%rip), %r14     # 0x25f00
movq %r8, -0x58(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x9400
xorl %eax, %eax
movzbl (%rdi,%rax), %r8d
movzbl (%r13,%rax), %ebx
movzbl (%r10,%rax), %r15d
addl %ebx, %r15d
movzbl (%rdx,%rax), %ebx
addl %r8d, %ebx
movzbl (%rsi,%rax), %r8d
leal (%r15,%r15,4), %r15d
leal (%r8,%r15,4), %r8d
movzbl (%r9,%rax), %r15d
addl %r15d, %r8d
leal (%rbx,%rbx,4), %ebx
subl %ebx, %r8d
addl $0x10, %r8d
sarl $0x5, %r8d
addl $0x50, %r8d
movb (%r8,%r14), %r8b
movb %r8b, (%r11,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x93af
movq -0x50(%rbp), %rax
addq %rax, %r13
addq -0x40(%rbp), %r11
movq -0x58(%rbp), %r8
incl %r8d
addq %rax, %r9
addq %rax, %rdx
addq %rax, %r10
addq %rax, %rdi
addq %rax, %rsi
cmpl -0x30(%rbp), %r8d
jne 0x93a3
cmpl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %r10
movl -0x34(%rbp), %eax
jle 0x947f
movslq %eax, %rdx
leaq -0x160(%rbp), %rsi
xorl %edi, %edi
cmpl $0x0, -0x2c(%rbp)
jle 0x946b
xorl %eax, %eax
movzbl (%r12,%rax), %r8d
movzbl (%rsi,%rax), %r9d
addl %r9d, %r8d
incl %r8d
shrl %r8d
movb %r8b, (%r10,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x944c
addq %rdx, %r10
movq -0x40(%rbp), %rax
addq %rax, %r12
addq %rax, %rsi
incl %edi
cmpl -0x30(%rbp), %edi
jne 0x9444
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_xy32(unsigned char*, int, unsigned char*, int, int, int)
static void mc_xy32( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    uint8_t tmp1[16*16];
    uint8_t tmp2[16*16];

    mc_hc( src,   i_src_stride, tmp1, i_width, i_width, i_height );
    mc_hv( src+1, i_src_stride, tmp2, i_width, i_width, i_height );
    pixel_avg( dst, i_dst_stride, tmp1, i_width, tmp2, i_width, i_width, i_height );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl %r9d, %ebx
movl %ecx, -0x34(%rbp)
movq %rdx, %r14
movq %rdi, %r13
leaq -0x260(%rbp), %r12
movq %rsi, %r15
movq %r12, %rdx
movl %r8d, %ecx
movl %r8d, -0x2c(%rbp)
callq 0x9491
movl %ebx, -0x30(%rbp)
testl %ebx, %ebx
jle 0x9852
movq %r14, -0x48(%rbp)
leaq 0x1(%r13), %rdx
leal (%r15,%r15), %eax
movslq %eax, %r8
negl %eax
cltq
movslq %r15d, %r11
leal (%r15,%r15,2), %ecx
movslq %ecx, %rdi
movl -0x2c(%rbp), %ecx
movslq %ecx, %rsi
movq %rsi, -0x40(%rbp)
movl %ecx, %ecx
leaq 0x1(%r13,%rdi), %rdi
leaq 0x1(%r13,%r8), %r8
leaq (%r11,%r13), %r9
incq %r9
leaq (%rax,%r13), %r10
incq %r10
movq %r11, -0x50(%rbp)
subq %r11, %r13
incq %r13
leaq -0x160(%rbp), %r11
xorl %esi, %esi
leaq 0x1c77f(%rip), %r14     # 0x25f00
movq %rsi, -0x58(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x97d9
xorl %eax, %eax
movzbl (%r13,%rax), %esi
movzbl (%rdx,%rax), %ebx
movzbl (%r9,%rax), %r15d
addl %ebx, %r15d
movzbl (%r8,%rax), %ebx
addl %esi, %ebx
movzbl (%r10,%rax), %esi
leal (%r15,%r15,4), %r15d
leal (%rsi,%r15,4), %esi
movzbl (%rdi,%rax), %r15d
addl %r15d, %esi
leal (%rbx,%rbx,4), %ebx
subl %ebx, %esi
addl $0x10, %esi
sarl $0x5, %esi
addl $0x50, %esi
movb (%rsi,%r14), %sil
movb %sil, (%r11,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x978d
movq -0x50(%rbp), %rax
addq %rax, %rdx
addq -0x40(%rbp), %r11
movq -0x58(%rbp), %rsi
incl %esi
addq %rax, %rdi
addq %rax, %r8
addq %rax, %r9
addq %rax, %r13
addq %rax, %r10
cmpl -0x30(%rbp), %esi
jne 0x9781
cmpl $0x0, -0x30(%rbp)
movq -0x48(%rbp), %r10
movl -0x34(%rbp), %eax
jle 0x9852
movslq %eax, %rdx
leaq -0x160(%rbp), %rsi
xorl %edi, %edi
cmpl $0x0, -0x2c(%rbp)
jle 0x983e
xorl %eax, %eax
movzbl (%r12,%rax), %r8d
movzbl (%rsi,%rax), %r9d
addl %r9d, %r8d
incl %r8d
shrl %r8d
movb %r8b, (%r10,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x981f
addq %rdx, %r10
movq -0x40(%rbp), %rax
addq %rax, %r12
addq %rax, %rsi
incl %edi
cmpl -0x30(%rbp), %edi
jne 0x9817
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/mc.c
// Function: mc_xy23(unsigned char*, int, unsigned char*, int, int, int)
static void mc_xy23( uint8_t *src, int i_src_stride, uint8_t *dst, int i_dst_stride, int i_width, int i_height )
{
    uint8_t tmp1[16*16];
    uint8_t tmp2[16*16];

    mc_hc( src,              i_src_stride, tmp1, i_width, i_width, i_height );
    mc_hh( src+i_src_stride, i_src_stride, tmp2, i_width, i_width, i_height );
    pixel_avg( dst, i_dst_stride, tmp1, i_width, tmp2, i_width, i_width, i_height );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %r9d, %ebx
movl %ecx, -0x34(%rbp)
movq %rdx, %r15
movq %rdi, %r13
leaq -0x240(%rbp), %r12
movl %esi, %r14d
movq %r12, %rdx
movl %r8d, %ecx
movl %r8d, -0x2c(%rbp)
callq 0x9491
movl %ebx, -0x30(%rbp)
testl %ebx, %ebx
jle 0x9cd4
movslq %r14d, %rdx
movl -0x2c(%rbp), %ecx
movslq %ecx, %rax
movl %ecx, %ecx
addq %rdx, %r13
leaq -0x140(%rbp), %rsi
xorl %edi, %edi
leaq 0x1c2e7(%rip), %r8      # 0x25f00
cmpl $0x0, -0x2c(%rbp)
jle 0x9c7a
xorl %r9d, %r9d
movzbl -0x2(%r13,%r9), %r10d
movzbl -0x1(%r13,%r9), %r11d
movzbl (%r13,%r9), %ebx
movzbl 0x1(%r13,%r9), %r14d
addl %ebx, %r14d
leal (%r14,%r14,4), %ebx
movzbl 0x2(%r13,%r9), %r14d
addl %r11d, %r14d
movzbl 0x3(%r13,%r9), %r11d
leal (%r14,%r14,4), %r14d
leal (%r10,%rbx,4), %r10d
addl %r11d, %r10d
subl %r14d, %r10d
addl $0x10, %r10d
sarl $0x5, %r10d
addl $0x50, %r10d
movb (%r10,%r8), %r10b
movb %r10b, (%rsi,%r9)
incq %r9
cmpq %r9, %rcx
jne 0x9c22
addq %rax, %rsi
incl %edi
addq %rdx, %r13
cmpl -0x30(%rbp), %edi
jne 0x9c19
cmpl $0x0, -0x30(%rbp)
movl -0x34(%rbp), %edx
jle 0x9cd4
movslq %edx, %rdx
leaq -0x140(%rbp), %rsi
xorl %edi, %edi
cmpl $0x0, -0x2c(%rbp)
jle 0x9cc4
xorl %r8d, %r8d
movzbl (%r12,%r8), %r9d
movzbl (%rsi,%r8), %r10d
addl %r10d, %r9d
incl %r9d
shrl %r9d
movb %r9b, (%r15,%r8)
incq %r8
cmpq %r8, %rcx
jne 0x9ca5
addq %rdx, %r15
addq %rax, %r12
addq %rax, %rsi
incl %edi
cmpl -0x30(%rbp), %edi
jne 0x9c9c
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/pixel.c
// Function: pixel_sub_4x4(short (*) [4], unsigned char*, int, unsigned char*, int)
static void pixel_sub_4x4( int16_t diff[4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
{
    int y, x;
    for( y = 0; y < 4; y++ )
    {
        for( x = 0; x < 4; x++ )
        {
            diff[y][x] = pix1[x] - pix2[x];
        }
        pix1 += i_pix1;
        pix2 += i_pix2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
movslq %r8d, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movzbl (%rsi,%r9), %r10d
movzbl (%rcx,%r9), %r11d
subl %r11d, %r10d
movw %r10w, (%rdi,%r9,2)
incq %r9
cmpq $0x4, %r9
jne 0xa4c5
addq %rax, %rsi
addq %rdx, %rcx
incq %r8
addq $0x8, %rdi
cmpq $0x4, %r8
jne 0xa4c2
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/pixel.c
// Function: pixel_sub_8x8(short (*) [4][4], unsigned char*, int, unsigned char*, int)
static void pixel_sub_8x8( int16_t diff[4][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
{
    pixel_sub_4x4( diff[0], &pix1[0],          i_pix1, &pix2[0],          i_pix2 );
    pixel_sub_4x4( diff[1], &pix1[4],          i_pix1, &pix2[4],          i_pix2 );
    pixel_sub_4x4( diff[2], &pix1[4*i_pix1],   i_pix1, &pix2[4*i_pix2],   i_pix2 );
    pixel_sub_4x4( diff[3], &pix1[4*i_pix1+4], i_pix1, &pix2[4*i_pix2+4], i_pix2 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %edx, %rax
movslq %r8d, %r9
xorl %r10d, %r10d
movq %rdi, %r11
movq %rsi, %rbx
movq %rcx, %r14
xorl %r15d, %r15d
movzbl (%rbx,%r15), %r12d
movzbl (%r14,%r15), %r13d
subl %r13d, %r12d
movw %r12w, (%r11,%r15,2)
incq %r15
cmpq $0x4, %r15
jne 0xa517
addq %rax, %rbx
addq %r9, %r14
incq %r10
addq $0x8, %r11
cmpq $0x4, %r10
jne 0xa514
leaq 0x20(%rdi), %r10
leaq 0x4(%rsi), %r11
leaq 0x4(%rcx), %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movzbl (%r11,%r15), %r12d
movzbl (%rbx,%r15), %r13d
subl %r13d, %r12d
movw %r12w, (%r10,%r15,2)
incq %r15
cmpq $0x4, %r15
jne 0xa557
addq %rax, %r11
addq %r9, %rbx
incq %r14
addq $0x8, %r10
cmpq $0x4, %r14
jne 0xa554
leaq 0x40(%rdi), %r10
shll $0x2, %edx
movslq %edx, %rdx
addq %rdx, %rsi
shll $0x2, %r8d
movslq %r8d, %rdx
addq %rdx, %rcx
xorl %edx, %edx
movq %rsi, %r8
movq %rcx, %r11
xorl %ebx, %ebx
movzbl (%r8,%rbx), %r14d
movzbl (%r11,%rbx), %r15d
subl %r15d, %r14d
movw %r14w, (%r10,%rbx,2)
incq %rbx
cmpq $0x4, %rbx
jne 0xa5a6
addq %rax, %r8
addq %r9, %r11
incq %rdx
addq $0x8, %r10
cmpq $0x4, %rdx
jne 0xa5a4
addq $0x60, %rdi
addq $0x4, %rsi
addq $0x4, %rcx
xorl %edx, %edx
xorl %r8d, %r8d
movzbl (%rsi,%r8), %r10d
movzbl (%rcx,%r8), %r11d
subl %r11d, %r10d
movw %r10w, (%rdi,%r8,2)
incq %r8
cmpq $0x4, %r8
jne 0xa5e5
addq %rax, %rsi
addq %r9, %rcx
incq %rdx
addq $0x8, %rdi
cmpq $0x4, %rdx
jne 0xa5e2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/pixel.c
// Function: pixel_sub_16x16(short (*) [4][4], unsigned char*, int, unsigned char*, int)
static void pixel_sub_16x16( int16_t diff[16][4][4], uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2 )
{
    pixel_sub_8x8( &diff[ 0], &pix1[0],          i_pix1, &pix2[0],          i_pix2 );
    pixel_sub_8x8( &diff[ 4], &pix1[8],          i_pix1, &pix2[8],          i_pix2 );
    pixel_sub_8x8( &diff[ 8], &pix1[8*i_pix1],   i_pix1, &pix2[8*i_pix2],   i_pix2 );
    pixel_sub_8x8( &diff[12], &pix1[8*i_pix1+8], i_pix1, &pix2[8*i_pix2+8], i_pix2 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r15
movq %rcx, -0x30(%rbp)
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %r12
callq 0xa4f5
leaq 0x80(%r12), %rdi
leaq 0x8(%r13), %rsi
leaq 0x8(%r15), %rcx
movl %r14d, %edx
movl %ebx, %r8d
callq 0xa4f5
leaq 0x100(%r12), %rdi
leal (,%r14,8), %eax
cltq
movq %rax, -0x38(%rbp)
leaq (%r13,%rax), %rsi
leal (,%rbx,8), %eax
movslq %eax, %r15
movq -0x30(%rbp), %rax
leaq (%rax,%r15), %rcx
movl %r14d, %edx
movl %ebx, %r8d
callq 0xa4f5
addq $0x180, %r12            # imm = 0x180
movq -0x38(%rbp), %rax
leaq (%rax,%r13), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rax
leaq 0x8(%rax,%r15), %rcx
movq %r12, %rdi
movl %r14d, %edx
movl %ebx, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa4f5
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/pixel.c
// Function: pixel_add_8x8(unsigned char*, int, short (*) [4][4])
static void pixel_add_8x8( uint8_t *dst, int i_dst, int16_t diff[4][4][4] )
{
    pixel_add_4x4( &dst[0],         i_dst, diff[0] );
    pixel_add_4x4( &dst[4],         i_dst, diff[1] );
    pixel_add_4x4( &dst[0+4*i_dst], i_dst, diff[2] );
    pixel_add_4x4( &dst[4+4*i_dst], i_dst, diff[3] );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq %esi, %rax
xorl %ecx, %ecx
movl $0xff, %r8d
movq %rdx, %r9
xorl %r10d, %r10d
movq %rdi, %r11
xorl %ebx, %ebx
movzbl (%r11,%rbx), %r14d
movswl (%r9,%rbx,2), %r15d
addl %r14d, %r15d
cmpl %r8d, %r15d
cmovgel %r8d, %r15d
testl %r15d, %r15d
cmovlel %ecx, %r15d
movb %r15b, (%r11,%rbx)
incq %rbx
cmpq $0x4, %rbx
jne 0xa73f
addq %rax, %r11
incq %r10
addq $0x8, %r9
cmpq $0x4, %r10
jne 0xa73d
leaq 0x4(%rdi), %rcx
leaq 0x20(%rdx), %r8
xorl %r9d, %r9d
movl $0xff, %r10d
xorl %r11d, %r11d
xorl %ebx, %ebx
movzbl (%rcx,%rbx), %r14d
movswl (%r8,%rbx,2), %r15d
addl %r14d, %r15d
cmpl %r10d, %r15d
cmovgel %r10d, %r15d
testl %r15d, %r15d
cmovlel %r9d, %r15d
movb %r15b, (%rcx,%rbx)
incq %rbx
cmpq $0x4, %rbx
jne 0xa78d
addq %rax, %rcx
incq %r11
addq $0x8, %r8
cmpq $0x4, %r11
jne 0xa78b
shll $0x2, %esi
movslq %esi, %rcx
addq %rcx, %rdi
leaq 0x40(%rdx), %rcx
xorl %esi, %esi
movl $0xff, %r8d
xorl %r9d, %r9d
movq %rdi, %r10
xorl %r11d, %r11d
movzbl (%r10,%r11), %ebx
movswl (%rcx,%r11,2), %r14d
addl %ebx, %r14d
cmpl %r8d, %r14d
cmovgel %r8d, %r14d
testl %r14d, %r14d
cmovlel %esi, %r14d
movb %r14b, (%r10,%r11)
incq %r11
cmpq $0x4, %r11
jne 0xa7e3
addq %rax, %r10
incq %r9
addq $0x8, %rcx
cmpq $0x4, %r9
jne 0xa7e0
addq $0x4, %rdi
addq $0x60, %rdx
xorl %ecx, %ecx
movl $0xff, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
movzbl (%rdi,%r9), %r10d
movswl (%rdx,%r9,2), %r11d
addl %r10d, %r11d
cmpl %esi, %r11d
cmovgel %esi, %r11d
testl %r11d, %r11d
cmovlel %ecx, %r11d
movb %r11b, (%rdi,%r9)
incq %r9
cmpq $0x4, %r9
jne 0xa830
addq %rax, %rdi
incq %r8
addq $0x8, %rdx
cmpq $0x4, %r8
jne 0xa82d
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/pixel.c
// Function: pixel_add_16x16(unsigned char*, int, short (*) [4][4])
static void pixel_add_16x16( uint8_t *dst, int i_dst, int16_t diff[16][4][4] )
{
    pixel_add_8x8( &dst[0],         i_dst, &diff[ 0] );
    pixel_add_8x8( &dst[8],         i_dst, &diff[ 4] );
    pixel_add_8x8( &dst[0+8*i_dst], i_dst, &diff[ 8] );
    pixel_add_8x8( &dst[8+8*i_dst], i_dst, &diff[12] );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
callq 0xa720
leaq 0x8(%r15), %rdi
leaq 0x80(%rbx), %rdx
movl %r14d, %esi
callq 0xa720
leal (,%r14,8), %eax
movslq %eax, %r12
leaq (%r15,%r12), %rdi
leaq 0x100(%rbx), %rdx
movl %r14d, %esi
callq 0xa720
leaq (%r15,%r12), %rdi
addq $0x8, %rdi
addq $0x180, %rbx            # imm = 0x180
movl %r14d, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa720
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: x264_predict_16x16_init(int, void (**)(unsigned char*, int))
void x264_predict_16x16_init( int cpu, x264_predict_t pf[7] )
{
    pf[I_PRED_16x16_V ]     = predict_16x16_v;
    pf[I_PRED_16x16_H ]     = predict_16x16_h;
    pf[I_PRED_16x16_DC]     = predict_16x16_dc;
    pf[I_PRED_16x16_P ]     = predict_16x16_p;
    pf[I_PRED_16x16_DC_LEFT]= predict_16x16_dc_left;
    pf[I_PRED_16x16_DC_TOP ]= predict_16x16_dc_top;
    pf[I_PRED_16x16_DC_128 ]= predict_16x16_dc_128;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x47(%rip), %rax        # 0xaae6
movq %rax, (%rsi)
leaq 0x6d(%rip), %rax        # 0xab16
movq %rax, 0x8(%rsi)
leaq 0x91(%rip), %rax        # 0xab45
movq %rax, 0x10(%rsi)
leaq 0xe4(%rip), %rax        # 0xaba3
movq %rax, 0x18(%rsi)
leaq 0x1db(%rip), %rax       # 0xaca5
movq %rax, 0x20(%rsi)
leaq 0x21e(%rip), %rax       # 0xacf3
movq %rax, 0x28(%rsi)
leaq 0x262(%rip), %rax       # 0xad42
movq %rax, 0x30(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_16x16_v(unsigned char*, int)
static void predict_16x16_v( uint8_t *src, int i_stride )
{
    int i,j;

    for( i = 0; i < 16; i++ )
    {
        for( j = 0; j < 16; j++ )
        {
            src[i * i_stride +j] = src[j - i_stride];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
movq %rdi, %rcx
subq %rax, %rcx
xorl %edx, %edx
xorl %esi, %esi
movb (%rcx,%rsi), %r8b
movb %r8b, (%rdi,%rsi)
incq %rsi
cmpq $0x10, %rsi
jne 0xaaf7
incq %rdx
addq %rax, %rdi
cmpq $0x10, %rdx
jne 0xaaf5
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_16x16_dc(unsigned char*, int)
static void predict_16x16_dc( uint8_t *src, int i_stride )
{
    int dc = 0;
    int i, j;

    /* calculate DC value */
    for( i = 0; i < 16; i++ )
    {
        dc += src[-1 + i * i_stride];
        dc += src[i - i_stride];
    }
    dc = ( dc + 16 ) >> 5;

    for( i = 0; i < 16; i++ )
    {
        for( j = 0; j < 16; j++ )
        {
            src[j] = dc;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x1(%rdi), %rcx
movslq %esi, %rax
movq %rdi, %rsi
subq %rax, %rsi
xorl %r8d, %r8d
xorl %edx, %edx
movzbl (%rcx), %r9d
addl %edx, %r9d
movzbl (%rsi,%r8), %edx
addl %r9d, %edx
incq %r8
addq %rax, %rcx
cmpq $0x10, %r8
jne 0xab5b
addl $0x10, %edx
shrl $0x5, %edx
movl $0x10, %ecx
movzbl %dl, %edx
movd %edx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, (%rdi)
addq %rax, %rdi
decl %ecx
jne 0xab96
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_16x16_p(unsigned char*, int)
static void predict_16x16_p( uint8_t *src, int i_stride )
{
    int x, y, i;
    int a, b, c;
    int H = 0;
    int V = 0;
    int i00;

    /* calcule H and V */
    for( i = 0; i <= 7; i++ )
    {
        H += ( i + 1 ) * ( src[ 8 + i - i_stride ] - src[6 -i -i_stride] );
        V += ( i + 1 ) * ( src[-1 + (8+i)*i_stride] - src[-1 + (6-i)*i_stride] );
    }

    a = 16 * ( src[-1 + 15*i_stride] + src[15 - i_stride] );
    b = ( 5 * H + 32 ) >> 6;
    c = ( 5 * V + 32 ) >> 6;

    i00 = a - b * 7 - c * 7 + 16;

    for( y = 0; y < 16; y++ )
    {
        for( x = 0; x < 16; x++ )
        {
            int pix;

            pix = (i00+b*x)>>5;

            src[x] = X264_CLIP3( pix, 0, 255 );
        }
        src += i_stride;
        i00 += c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %esi, %rax
leaq (%rax,%rax,2), %rcx
leaq (%rdi,%rcx,2), %rsi
decq %rsi
movq %rax, %r8
negq %r8
movq %rdi, %rdx
subq %rax, %rdx
leaq 0x6(%rdx), %r10
leaq (%rdi,%rax,8), %r11
decq %r11
xorl %ecx, %ecx
movl $0x8, %ebx
xorl %r9d, %r9d
movzbl (%rdx,%rbx), %r14d
movzbl (%r10), %r15d
subl %r15d, %r14d
leal -0x7(%rbx), %r15d
imull %r15d, %r14d
addl %r14d, %r9d
movzbl (%r11), %r14d
movzbl (%rsi), %r12d
subl %r12d, %r14d
imull %r15d, %r14d
addl %r14d, %ecx
addq %r8, %rsi
decq %r10
incq %rbx
addq %rax, %r11
cmpq $0x10, %rbx
jne 0xabdd
leaq (%rax,%rax,4), %rsi
leaq (%rsi,%rsi,2), %rsi
movzbl -0x1(%rdi,%rsi), %esi
movzbl 0xf(%rdx), %r8d
addl %esi, %r8d
shll $0x4, %r8d
leal (%r9,%r9,4), %edx
addl $0x20, %edx
sarl $0x6, %edx
leal (%rcx,%rcx,4), %ecx
addl $0x20, %ecx
sarl $0x6, %ecx
leal (%rcx,%rdx), %esi
leal (,%rsi,8), %r9d
subl %r9d, %esi
addl %r8d, %esi
addl $0x10, %esi
xorl %r8d, %r8d
movl $0xff, %r9d
xorl %r10d, %r10d
movl %esi, %r11d
xorl %ebx, %ebx
movl %r11d, %r14d
sarl $0x5, %r14d
cmpl %r9d, %r14d
cmovgel %r9d, %r14d
testl %r14d, %r14d
cmovlel %r8d, %r14d
movb %r14b, (%rdi,%rbx)
incq %rbx
addl %edx, %r11d
cmpq $0x10, %rbx
jne 0xac69
addq %rax, %rdi
incl %r10d
addl %ecx, %esi
cmpl $0x10, %r10d
jne 0xac64
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_16x16_dc_left(unsigned char*, int)
static void predict_16x16_dc_left( uint8_t *src, int i_stride )
{
    int dc = 0;
    int i,j;

    for( i = 0; i < 16; i++ )
    {
        dc += src[-1 + i * i_stride];
    }
    dc = ( dc + 8 ) >> 4;

    for( i = 0; i < 16; i++ )
    {
        for( j = 0; j < 16; j++ )
        {
            src[j] = dc;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x1(%rdi), %rdx
movslq %esi, %rax
xorl %ecx, %ecx
movl $0x10, %esi
movzbl (%rdx), %r8d
addl %r8d, %ecx
addq %rax, %rdx
decq %rsi
jne 0xacb7
addl $0x8, %ecx
shrl $0x4, %ecx
movl $0x10, %edx
movzbl %cl, %ecx
movd %ecx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, (%rdi)
addq %rax, %rdi
decl %edx
jne 0xace6
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: x264_predict_8x8_init(int, void (**)(unsigned char*, int))
void x264_predict_8x8_init( int cpu, x264_predict_t pf[7] )
{
    pf[I_PRED_CHROMA_V ]     = predict_8x8_v;
    pf[I_PRED_CHROMA_H ]     = predict_8x8_h;
    pf[I_PRED_CHROMA_DC]     = predict_8x8_dc;
    pf[I_PRED_CHROMA_P ]     = predict_8x8_p;
    pf[I_PRED_CHROMA_DC_LEFT]= predict_8x8_dc_left;
    pf[I_PRED_CHROMA_DC_TOP ]= predict_8x8_dc_top;
    pf[I_PRED_CHROMA_DC_128 ]= predict_8x8_dc_128;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x47(%rip), %rax        # 0xadb3
movq %rax, 0x10(%rsi)
leaq 0x6c(%rip), %rax        # 0xade3
movq %rax, 0x8(%rsi)
leaq 0x8b(%rip), %rax        # 0xae0d
movq %rax, (%rsi)
leaq 0x132(%rip), %rax       # 0xaebe
movq %rax, 0x18(%rsi)
leaq 0x22d(%rip), %rax       # 0xafc4
movq %rax, 0x20(%rsi)
leaq 0x28b(%rip), %rax       # 0xb02d
movq %rax, 0x28(%rsi)
leaq 0x2f1(%rip), %rax       # 0xb09e
movq %rax, 0x30(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_8x8_v(unsigned char*, int)
static void predict_8x8_v( uint8_t *src, int i_stride )
{
    int i,j;

    for( i = 0; i < 8; i++ )
    {
        for( j = 0; j < 8; j++ )
        {
            src[i * i_stride +j] = src[j - i_stride];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
movq %rdi, %rcx
subq %rax, %rcx
xorl %edx, %edx
xorl %esi, %esi
movb (%rcx,%rsi), %r8b
movb %r8b, (%rdi,%rsi)
incq %rsi
cmpq $0x8, %rsi
jne 0xadc4
incq %rdx
addq %rax, %rdi
cmpq $0x8, %rdx
jne 0xadc2
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_8x8_dc(unsigned char*, int)
static void predict_8x8_dc( uint8_t *src, int i_stride )
{
    int x,y;
    int s0 = 0, s1 = 0, s2 = 0, s3 = 0;
    int dc0, dc1, dc2, dc3;
    int i;

    /* First do :
          s0 s1
       s2
       s3
    */
    for( i = 0; i < 4; i++ )
    {
        s0 += src[i - i_stride];
        s1 += src[i + 4 - i_stride];
        s2 += src[-1 + i * i_stride];
        s3 += src[-1 + (i+4)*i_stride];
    }
    /* now calculate
       dc0 dc1
       dc2 dc3
     */
    dc0 = ( s0 + s2 + 4 ) >> 3;
    dc1 = ( s1 + 2 ) >> 2;
    dc2 = ( s3 + 2 ) >> 2;
    dc3 = ( s1 + s3 + 4 ) >> 3;

    for( y = 0; y < 4; y++ )
    {
        for( x = 0; x < 4; x++ )
        {
            src[             x    ] = dc0;
            src[             x + 4] = dc1;
            src[4*i_stride + x    ] = dc2;
            src[4*i_stride + x + 4] = dc3;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq -0x1(%rdi), %rcx
movslq %esi, %rax
movq %rdi, %r8
subq %rax, %r8
addq $0x4, %r8
xorl %r10d, %r10d
movq $-0x4, %r11
xorl %edx, %edx
xorl %ebx, %ebx
xorl %r9d, %r9d
movzbl (%r8,%r11), %r14d
addl %r14d, %r10d
movzbl 0x4(%r8,%r11), %r14d
addl %r14d, %r9d
movzbl (%rcx), %r14d
addl %r14d, %ebx
movzbl (%rcx,%rax,4), %r14d
addl %r14d, %edx
addq %rax, %rcx
incq %r11
jne 0xae36
leal (%rbx,%r10), %ecx
addl $0x4, %ecx
shrl $0x3, %ecx
leal 0x2(%r9), %r8d
shrl $0x2, %r8d
leal 0x2(%rdx), %r10d
shrl $0x2, %r10d
addl %r9d, %edx
addl $0x4, %edx
shrl $0x3, %edx
shll $0x2, %esi
movslq %esi, %rsi
xorl %r9d, %r9d
leaq (%rdi,%rsi), %r11
movl $0x4, %ebx
movb %cl, -0x4(%rdi,%rbx)
movb %r8b, (%rdi,%rbx)
movb %r10b, -0x4(%r11,%rbx)
movb %dl, (%r11,%rbx)
incq %rbx
cmpq $0x8, %rbx
jne 0xae93
addq %rax, %rdi
incl %r9d
cmpl $0x4, %r9d
jne 0xae8a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_8x8_p(unsigned char*, int)
static void predict_8x8_p( uint8_t *src, int i_stride )
{
    int i;
    int x,y;
    int a, b, c;
    int H = 0;
    int V = 0;
    int i00;

    for( i = 0; i < 4; i++ )
    {
        H += ( i + 1 ) * ( src[4+i - i_stride] - src[2 - i -i_stride] );
        V += ( i + 1 ) * ( src[-1 +(i+4)*i_stride] - src[-1+(2-i)*i_stride] );
    }

    a = 16 * ( src[-1+7*i_stride] + src[7 - i_stride] );
    b = ( 17 * H + 16 ) >> 5;
    c = ( 17 * V + 16 ) >> 5;
    i00 = a -3*b -3*c + 16;

    for( y = 0; y < 8; y++ )
    {
        for( x = 0; x < 8; x++ )
        {
            int pix;

            pix = (i00 +b*x) >> 5;
            src[x] = X264_CLIP3( pix, 0, 255 );
        }
        src += i_stride;
        i00 += c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %esi, %rax
leaq (%rdi,%rax,2), %r8
decq %r8
movq %rax, %r9
negq %r9
movq %rdi, %rcx
subq %rax, %rcx
leaq 0x2(%rcx), %r10
leaq (%rdi,%rax,4), %r11
decq %r11
xorl %edx, %edx
movl $0x4, %ebx
xorl %esi, %esi
movzbl (%rcx,%rbx), %r14d
movzbl (%r10), %r15d
subl %r15d, %r14d
leal -0x3(%rbx), %r15d
imull %r15d, %r14d
addl %r14d, %esi
movzbl (%r11), %r14d
movzbl (%r8), %r12d
subl %r12d, %r14d
imull %r15d, %r14d
addl %r14d, %edx
addq %r9, %r8
decq %r10
incq %rbx
addq %rax, %r11
cmpq $0x8, %rbx
jne 0xaef3
leaq (,%rax,8), %r8
subq %rax, %r8
movzbl -0x1(%rdi,%r8), %r8d
movzbl 0x7(%rcx), %ecx
addl %r8d, %ecx
shll $0x4, %ecx
movl %esi, %r8d
shll $0x4, %r8d
addl %r8d, %esi
addl $0x10, %esi
sarl $0x5, %esi
movl %edx, %r8d
shll $0x4, %r8d
addl %r8d, %edx
addl $0x10, %edx
sarl $0x5, %edx
leal (%rdx,%rsi), %r8d
leal (%r8,%r8,2), %r8d
subl %r8d, %ecx
addl $0x10, %ecx
xorl %r8d, %r8d
movl $0xff, %r9d
xorl %r10d, %r10d
movl %ecx, %r11d
xorl %ebx, %ebx
movl %r11d, %r14d
sarl $0x5, %r14d
cmpl %r9d, %r14d
cmovgel %r9d, %r14d
testl %r14d, %r14d
cmovlel %r8d, %r14d
movb %r14b, (%rdi,%rbx)
incq %rbx
addl %esi, %r11d
cmpq $0x8, %rbx
jne 0xaf88
addq %rax, %rdi
incl %r10d
addl %edx, %ecx
cmpl $0x8, %r10d
jne 0xaf83
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq