LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/cabac.c
// Function: x264_cabac_encode_flush(x264_cabac_t*)
void x264_cabac_encode_flush( x264_cabac_t *cb )
{
    x264_cabac_putbit( cb, (cb->i_low >> 9)&0x01 );
    _bs_write1( cb->s, (cb->i_low >> 8)&0x01 );

    /* check that */
    _bs_write1( cb->s, 0x01 );
    bs_align_0( cb->s );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x12cc(%rax), %esi
sarl $0x9, %esi
andl $0x1, %esi
callq 0x3c80
movq -0x8(%rbp), %rax
movq 0x12e0(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x12cc(%rax), %esi
sarl $0x8, %esi
andl $0x1, %esi
callq 0x3e00
movq -0x8(%rbp), %rax
movq 0x12e0(%rax), %rdi
movl $0x1, %esi
callq 0x3e00
movq -0x8(%rbp), %rax
movq 0x12e0(%rax), %rdi
callq 0x3ea0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/bs.h
// Function: bs_write1(bs_s*, unsigned int)
static inline void
_bs_write1(bs_t *s, uint32_t i_bits) {


    if (s->p < s->p_end)
    {
        s->i_left--;

        if (i_bits & 0x01)
        {
            *s->p |= 1 << s->i_left;
        }
        else
        {
            *s->p &= ~(1 << s->i_left);
        }
        if (s->i_left == 0)
        {
            s->p++;
            s->i_left = 8;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3e9b
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3e54
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
jmp 0x3e74
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x3e99
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x18(%rax)
jmp 0x3e9b
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/bs.h
// Function: bs_write(bs_s*, int, unsigned int)
static inline void
_bs_write(bs_t *s, int i_count, uint32_t i_bits) {

    while (i_count > 0)
    {
        if (s->p >= s->p_end)
        {
            break;
        }

        i_count--;

        if ((i_bits >> i_count)&0x01)
        {
            *s->p |= 1 << (s->i_left - 1);
        }
        else
        {
            *s->p &= ~(1 << (s->i_left - 1));
        }
        s->i_left--;
        if (s->i_left == 0)
        {
            s->p++;
            s->i_left = 8;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x3fb4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x3f1f
jmp 0x3fb4
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3f5a
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
jmp 0x3f7d
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x3faf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x18(%rax)
jmp 0x3efe
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/common.c
// Function: x264_picture_delete(x264_picture_t*)
void x264_picture_delete( x264_picture_t *pic )
{
    int i;

    for( i = 0; i < pic->i_plane; i++ )
    {
        x264_free( pic->plane[i] );
    }
    x264_free( pic );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x41bc
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rdi
callq 0x41d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4193
movq -0x8(%rbp), %rdi
callq 0x41d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dct.c
// Function: x264_dct_init(int, x264_dct_function_t*)
void x264_dct_init( int cpu, x264_dct_function_t *dctf )
{
    dctf->dct4x4    = dct4x4;
    dctf->dct4x4dc  = dct4x4dc;
    dctf->idct4x4   = idct4x4;
    dctf->idct4x4dc = idct4x4dc;
    dctf->dct2x2dc  = dct2x2dc;
    dctf->idct2x2dc = idct2x2dc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x5a(%rip), %rcx        # 0x44a0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x21c(%rip), %rcx       # 0x4670
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x3ed(%rip), %rcx       # 0x4850
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x5ce(%rip), %rcx       # 0x4a40
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x78f(%rip), %rcx       # 0x4c10
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x830(%rip), %rcx       # 0x4cc0
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dct.c
// Function: dct2x2dc(short (*) [2], short (*) [2])
static void dct2x2dc( int16_t dct[2][2], int16_t diff[2][2] )
{
    int tmp[2][2];

    tmp[0][0] = diff[0][0] + diff[0][1];
    tmp[1][0] = diff[0][0] - diff[0][1];
    tmp[0][1] = diff[1][0] + diff[1][1];
    tmp[1][1] = diff[1][0] - diff[1][1];

    dct[0][0] = tmp[0][0] + tmp[0][1];
    dct[0][1] = tmp[1][0] + tmp[1][1];
    dct[1][0] = tmp[0][0] - tmp[0][1];
    dct[1][1] = tmp[1][0] - tmp[1][1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x2(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movswl (%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x2(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x6(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x6(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: myPrintf(char const*, ...)
void myPrintf(const char *fmt, ...)
{
    va_list parms;
    char buf[256];

    // Try to print in the allocated space.
    va_start(parms, fmt);
    vsprintf(buf, fmt, parms);
    va_end(parms);

    // Write the information out to a txt file
    if(fpDump)
    {    
      fprintf(fpDump, "%s", buf);
      fflush( fpDump);
    }
    printf("%s", buf);
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
testb %al, %al
je 0x4d67
movaps %xmm0, -0x1a0(%rbp)
movaps %xmm1, -0x190(%rbp)
movaps %xmm2, -0x180(%rbp)
movaps %xmm3, -0x170(%rbp)
movaps %xmm4, -0x160(%rbp)
movaps %xmm5, -0x150(%rbp)
movaps %xmm6, -0x140(%rbp)
movaps %xmm7, -0x130(%rbp)
movq %r9, -0x1a8(%rbp)
movq %r8, -0x1b0(%rbp)
movq %rcx, -0x1b8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rsi, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0x1d0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x120(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2060
leaq -0x20(%rbp), %rax
cmpq $0x0, 0x30e41e(%rip)    # 0x3131f0
je 0x4dfc
movq 0x30e415(%rip), %rdi    # 0x3131f0
leaq -0x120(%rbp), %rdx
leaq 0x24128(%rip), %rsi     # 0x28f11
movb $0x0, %al
callq 0x2160
movq 0x30e3f9(%rip), %rdi    # 0x3131f0
callq 0x20d0
leaq 0x2410e(%rip), %rdi     # 0x28f11
xorl %eax, %eax
leaq -0x120(%rbp), %rsi
callq 0x2040
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: IntToBinary(int, int)
char* IntToBinary(int val, int bits)
{
	int i;
	int c = 0;
    for (i = 0; i < 32; i++) g_bigBuf[i] = '\0';
 
    for (i = bits - 1; i >= 0; i--)
    {
        int on = (val & (1 << i)) ? 1 : 0;
        g_bigBuf[c] = on ? '1' : '0';
        c++;
    }

    return &g_bigBuf[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x4e58
movslq -0xc(%rbp), %rcx
leaq 0x30e3b7(%rip), %rax    # 0x313200
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e38
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4ec3
movl -0x4(%rbp), %edx
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
andl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movb $0x31, %al
movb $0x30, %dl
movb %dl, -0x16(%rbp)
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x4e9e
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %dl
movslq -0x10(%rbp), %rcx
leaq 0x30e354(%rip), %rax    # 0x313200
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e61
leaq 0x30e336(%rip), %rax    # 0x313200
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: DumpDCTValues(short*)
void DumpDCTValues(short dct[64])
{

	int i;
    int c = 0;
	myPrintf("\n#Extracted DCT values from SOS#\n");
    for ( i = 0; i < 64; i++)
    {
        myPrintf("% 4d  ", dct[c++]);

        if ((c > 0) && (c % 8 == 0)) myPrintf("\n");
    }
    myPrintf("\n");
    
    fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0x2402a(%rip), %rdi     # 0x28f14
movb $0x0, %al
callq 0x4d20
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x4f53
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %esi
leaq 0x2401b(%rip), %rdi     # 0x28f36
movb $0x0, %al
callq 0x4d20
cmpl $0x0, -0x10(%rbp)
jle 0x4f46
movl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4f46
leaq 0x20779(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
jmp 0x4f48
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ef8
leaq 0x2075e(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
movq 0x31038(%rip), %rax     # 0x35fa0
movq (%rax), %rdi
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: dumpByte(unsigned char*, int, int)
void dumpByte(BYTE *dct, int dx, int dy)
{
	int j;
	int i;
    for (j = 0; j < dy; j++)
    {
        for ( i = 0; i < dx; i++)
        {
            myPrintf("%03d  ", dct[j * dx + i]);

        }
        myPrintf("\n");
    }
    myPrintf("\n");
    myPrintf("*********************************************************************************************************\n");
    fflush(stdout);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4ff7
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4fde
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
leaq 0x23f71(%rip), %rdi     # 0x28f3d
movb $0x0, %al
callq 0x4d20
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4fa8
leaq 0x206d3(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f99
leaq 0x206ba(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
leaq 0x23f38(%rip), %rdi     # 0x28f44
movb $0x0, %al
callq 0x4d20
movq 0x30f86(%rip), %rax     # 0x35fa0
movq (%rax), %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: printColor(long*, int)
void printColor(long *col, int size)
{
	int i;
    for (i = 0; i < size; i++)
        myPrintf("%d ", col[i]);

    myPrintf("\n");
    myPrintf("\n");
    fflush(stdout);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5073
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x23f4e(%rip), %rdi     # 0x28faf
movb $0x0, %al
callq 0x4d20
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5046
leaq 0x2063e(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
leaq 0x20630(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
movq 0x30f0a(%rip), %rax     # 0x35fa0
movq (%rax), %rdi
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: printLong(long*, int, int)
void printLong(long *dct, int dx,  int dy)
{
	int i;
	int j;
    for (j = 0; j < dy; j++)
    {
        for (i = 0; i < dx; i++)
        {
            myPrintf("%d  ", dct[j * dx + i]);

        }
        myPrintf("\n");
    }
    myPrintf("\n");
    
    fflush(stdout);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5127
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x510e
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x23eb7(%rip), %rdi     # 0x28fb3
movb $0x0, %al
callq 0x4d20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50d8
leaq 0x205a3(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x50c9
leaq 0x2058a(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
movq 0x30e64(%rip), %rax     # 0x35fa0
movq (%rax), %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: printRangeLimit(unsigned char*, int)
void printRangeLimit(BYTE* range_limit, int size)
{
	int i;
    for ( i = 0; i < size; i++)
        myPrintf("%d ", range_limit[i]);

    myPrintf("\n");
    myPrintf("\n");
    fflush(stdout);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5193
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x23e2e(%rip), %rdi     # 0x28faf
movb $0x0, %al
callq 0x4d20
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5166
leaq 0x2051e(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
leaq 0x20510(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
movq 0x30dea(%rip), %rax     # 0x35fa0
movq (%rax), %rdi
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: dump8x8(long*)
void dump8x8(long dct[64])
{

    int c = 0;
    int i = 0;
    for (; i < 64; i++)
    {
        myPrintf("%4d  ", (int) dct[c++]);

        if ((c > 0) && (c % 8 == 0)) myPrintf("\n");
    }
    myPrintf("\n");
    fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0x10(%rbp)
jge 0x5247
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
leaq 0x23da9(%rip), %rdi     # 0x28fb8
movb $0x0, %al
callq 0x4d20
cmpl $0x0, -0xc(%rbp)
jle 0x523a
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x523a
leaq 0x20485(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
jmp 0x523c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x51ea
leaq 0x2046a(%rip), %rdi     # 0x256b8
movb $0x0, %al
callq 0x4d20
movq 0x30d44(%rip), %rax     # 0x35fa0
movq (%rax), %rdi
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/dump.c
// Function: log_set_file(char const*)
int log_set_file(const char* filename)
{
        FILE* fp = fopen(filename, "w");
        if (fp == NULL) return -1;
        fpDump = fp;
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2427f(%rip), %rsi     # 0x29506
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x52a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x52b2
movq -0x18(%rbp), %rax
movq %rax, 0x30df45(%rip)    # 0x3131f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/frame.c
// Function: x264_frame_new(x264_t*)
x264_frame_t *x264_frame_new( x264_t *h )
{
    x264_frame_t   *frame = (x264_frame_t *)x264_aligned_alloc( sizeof( x264_frame_t ) );
    int i;

    int i_stride;
    int i_lines;

    /* allocate frame data (+64 for extra data for me) */
    i_stride = ( ( h->param.i_width  + 15 )&0xfffff0 )+ 64;
    i_lines  = ( ( h->param.i_height + 15 )&0xfffff0 );

    frame->i_plane = 3;
    for( i = 0; i < 3; i++ )
    {
        int i_div;
        i_div = ( i == 0 ) ? 1 : 2;

        frame->i_stride[i] = i_stride / i_div;
        frame->i_lines[i] = i_lines / i_div;
        frame->buffer[i] = x264_aligned_alloc( frame->i_stride[i] * ( frame->i_lines[i] + 64 / i_div ));

        frame->plane[i] = ((uint8_t*)frame->buffer[i]) + ( frame->i_stride[i] * 32 + 32 ) / i_div;
    }
    frame->i_stride[3] = 0;
    frame->i_lines[3] = 0;
    frame->buffer[3] = NULL;
    frame->plane[3] = NULL;

    frame->i_poc = -1;

    return frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x70, %edi
callq 0x4160
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x84(%rax), %eax
addl $0xf, %eax
andl $0xfffff0, %eax         # imm = 0xFFFFF0
addl $0x40, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
addl $0xf, %eax
andl $0xfffff0, %eax         # imm = 0xFFFFF0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, 0x20(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x53ef
movl -0x14(%rbp), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cltd
idivl -0x20(%rbp)
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x24(%rax,%rcx,4)
movl -0x1c(%rbp), %eax
cltd
idivl -0x20(%rbp)
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x34(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x24(%rax,%rcx,4), %edi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x34(%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl $0x40, %eax
cltd
idivl -0x20(%rbp)
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
imull %eax, %edi
callq 0x4160
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x24(%rax,%rcx,4), %eax
shll $0x5, %eax
addl $0x20, %eax
cltd
idivl -0x20(%rbp)
movq -0x28(%rbp), %rdx
cltq
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x48(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5319
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/frame.c
// Function: x264_frame_delete(x264_frame_t*)
void x264_frame_delete( x264_frame_t *frame )
{
    int i;
    for( i = 0; i < frame->i_plane; i++ )
    {
        x264_free( frame->buffer[i] );
    }
    x264_free( frame );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x547b
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x41d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5453
movq -0x8(%rbp), %rdi
callq 0x41d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_macroblocks_new(int, int)
x264_macroblock_t *x264_macroblocks_new(int i_mb_width, int i_mb_height) {LOG_CALL;
    x264_macroblock_t *mb =( x264_macroblock_t *) x264_aligned_alloc(i_mb_width * i_mb_height * sizeof ( x264_macroblock_t));
    int x, y;

    for (y = 0; y < i_mb_height; y++)
    {
        for (x = 0; x < i_mb_width; x++)
        {
            int i_mb_xy = y * i_mb_width + x;

            mb[i_mb_xy].i_mb_x = x;
            mb[i_mb_xy].i_mb_y = y;

            mb[i_mb_xy].i_neighbour = 0;
            mb[i_mb_xy].i_neighbour |= (x > 0) ? MB_LEFT : 0x00;
            mb[i_mb_xy].i_neighbour |= (y > 0) ? MB_TOP : 0x00;
            mb[i_mb_xy].i_neighbour |= (y > 0 && x + 1 < i_mb_width) ? MB_TOPRIGHT : 0;
        }
    }

    return mb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x21c1b(%rip), %rdi     # 0x28eb0
leaq 0x22245(%rip), %rsi     # 0x294e1
leaq 0x22250(%rip), %rdx     # 0x294f3
movb $0x0, %al
callq 0x4d20
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
cltq
imulq $0xf88, %rax, %rax      # imm = 0xF88
movl %eax, %edi
callq 0x4160
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x73f0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x73e0
movl -0x18(%rbp), %eax
imull -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0xf88, %rdx, %rdx      # imm = 0xF88
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0xf88, %rdx, %rdx      # imm = 0xF88
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xf88, %rcx, %rcx      # imm = 0xF88
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovgl %eax, %ecx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0xf88, %rdx, %rdx      # imm = 0xF88
addq %rdx, %rax
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %edx
xorl %ecx, %ecx
movl $0x2, %eax
cmpl $0x0, %edx
cmovgl %eax, %ecx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0xf88, %rdx, %rdx      # imm = 0xF88
addq %rdx, %rax
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
jle 0x73aa
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl -0x4(%rbp), %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %dl
xorl %ecx, %ecx
movl $0x4, %eax
testb $0x1, %dl
cmovnel %eax, %ecx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0xf88, %rdx, %rdx      # imm = 0xF88
addq %rdx, %rax
orl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x72df
jmp 0x73e2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x72cc
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_predict_intra4x4_mode(x264_t*, x264_macroblock_t*, int)
int x264_mb_predict_intra4x4_mode(x264_t *h, x264_macroblock_t *mb, int idx) {LOG_CALL;
    x264_macroblock_t *mba = mb->context->block[idx].mba;
    x264_macroblock_t *mbb = mb->context->block[idx].mbb;

    int i_mode_a = I_PRED_4x4_DC;
    int i_mode_b = I_PRED_4x4_DC;

    if (!mba || !mbb)
    {
        return I_PRED_4x4_DC;
    }

    if (mba->i_type == I_4x4)
    {
        i_mode_a = mb->context->block[idx].bka->i_intra4x4_pred_mode;
    }
    if (mbb->i_type == I_4x4)
    {
        i_mode_b = mb->context->block[idx].bkb->i_intra4x4_pred_mode;
    }

    return X264_MIN(i_mode_a, i_mode_b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq 0x21a96(%rip), %rdi     # 0x28eb0
leaq 0x220c0(%rip), %rsi     # 0x294e1
leaq 0x220e0(%rip), %rdx     # 0x29508
movb $0x0, %al
callq 0x4d20
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x2, -0x34(%rbp)
movl $0x2, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x748c
cmpq $0x0, -0x30(%rbp)
jne 0x7495
movl $0x2, -0x4(%rbp)
jmp 0x7509
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x74c1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x74ed
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x74fd
movl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x7503
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_predict_non_zero_code(x264_t*, x264_macroblock_t*, int)
int x264_mb_predict_non_zero_code(x264_t *h, x264_macroblock_t *mb, int idx) {LOG_CALL;
    int i_z_a = 0x80, i_z_b = 0x80;
    int i_ret;

    /* none avail -> 0, one avail -> this one, both -> (a+b+1)>>1 */
    if (mb->context->block[idx].mba)
    {
        i_z_a = mb->context->block[idx].bka->i_non_zero_count;
    }
    if (mb->context->block[idx].mbb)
    {
        i_z_b = mb->context->block[idx].bkb->i_non_zero_count;
    }

    i_ret = i_z_a + i_z_b;
    if (i_ret < 0x80)
    {
        i_ret = (i_ret + 1) >> 1;
    }
    return i_ret & 0x7f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x21976(%rip), %rdi     # 0x28eb0
leaq 0x21fa0(%rip), %rsi     # 0x294e1
leaq 0x21fde(%rip), %rdx     # 0x29526
movb $0x0, %al
callq 0x4d20
movl $0x80, -0x18(%rbp)
movl $0x80, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x759f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x75e2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x4e8, %rax            # imm = 0x4E8
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x80, -0x20(%rbp)
jge 0x75ff
movl -0x20(%rbp), %eax
addl $0x1, %eax
sarl %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $0x7f, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_dequant_2x2_dc(short (*) [2], int)
void x264_mb_dequant_2x2_dc(int16_t dct[2][2], int i_qscale) {LOG_CALL;
    const int i_qbits = i_qscale / 6 - 1;

    if (i_qbits >= 0)
    {
        const int i_dmf = dequant_mf[i_qscale % 6][0][0] << i_qbits;

        dct[0][0] = dct[0][0] * i_dmf;
        dct[0][1] = dct[0][1] * i_dmf;
        dct[1][0] = dct[1][0] * i_dmf;
        dct[1][1] = dct[1][1] * i_dmf;
    } else
    {
        const int i_dmf = dequant_mf[i_qscale % 6][0][0];

        dct[0][0] = (dct[0][0] * i_dmf) >> 1;
        dct[0][1] = (dct[0][1] * i_dmf) >> 1;
        dct[1][0] = (dct[1][0] * i_dmf) >> 1;
        dct[1][1] = (dct[1][1] * i_dmf) >> 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2188a(%rip), %rdi     # 0x28eb0
leaq 0x21eb4(%rip), %rsi     # 0x294e1
leaq 0x21f10(%rip), %rdx     # 0x29544
movb $0x0, %al
callq 0x4d20
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x76db
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x22145(%rip), %rax     # 0x297b0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl -0x10(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movswl (%rax), %eax
imull -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
imull -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
imull -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movswl 0x6(%rax), %eax
imull -0x14(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
jmp 0x775e
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x220c0(%rip), %rax     # 0x297b0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movswl (%rax), %eax
imull -0x18(%rbp), %eax
sarl %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movswl 0x2(%rax), %eax
imull -0x18(%rbp), %eax
sarl %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movswl 0x4(%rax), %eax
imull -0x18(%rbp), %eax
sarl %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movswl 0x6(%rax), %eax
imull -0x18(%rbp), %eax
sarl %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_dequant_4x4_dc(short (*) [4], int)
void x264_mb_dequant_4x4_dc(int16_t dct[4][4], int i_qscale) {LOG_CALL;
    const int i_qbits = i_qscale / 6 - 2;
    int x, y;

    if (i_qbits >= 0)
    {
        const int i_dmf = dequant_mf[i_qscale % 6][0][0] << i_qbits;

        for (y = 0; y < 4; y++)
        {
            for (x = 0; x < 4; x++)
            {
                dct[y][x] = dct[y][x] * i_dmf;
            }
        }
    } else
    {
        const int i_dmf = dequant_mf[i_qscale % 6][0][0];
        const int f = 1 << (1 + i_qbits);

        for (y = 0; y < 4; y++)
        {
            for (x = 0; x < 4; x++)
            {
                dct[y][x] = (dct[y][x] * i_dmf + f) >> (-i_qbits);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2172a(%rip), %rdi     # 0x28eb0
leaq 0x21d54(%rip), %rsi     # 0x294e1
leaq 0x21dc7(%rip), %rdx     # 0x2955b
movb $0x0, %al
callq 0x4d20
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
subl $0x2, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x7848
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x21fe5(%rip), %rax     # 0x297b0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl -0x10(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x7843
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x7836
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
imull -0x1c(%rbp), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x77f0
jmp 0x7838
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x77e3
jmp 0x78ec
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x21f53(%rip), %rax     # 0x297b0
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x78ea
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x78dd
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
imull -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
xorl %ecx, %ecx
subl -0x10(%rbp), %ecx
sarl %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x788d
jmp 0x78df
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7880
jmp 0x78ec
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_dequant_4x4(short (*) [4], int)
void x264_mb_dequant_4x4(int16_t dct[4][4], int i_qscale) {LOG_CALL;
    const int i_mf = i_qscale % 6;
    const int i_qbits = i_qscale / 6;
    int y;

    for (y = 0; y < 4; y++)
    {
        dct[y][0] = (dct[y][0] * dequant_mf[i_mf][y][0]) << i_qbits;
        dct[y][1] = (dct[y][1] * dequant_mf[i_mf][y][1]) << i_qbits;
        dct[y][2] = (dct[y][2] * dequant_mf[i_mf][y][2]) << i_qbits;
        dct[y][3] = (dct[y][3] * dequant_mf[i_mf][y][3]) << i_qbits;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2159a(%rip), %rdi     # 0x28eb0
leaq 0x21bc4(%rip), %rsi     # 0x294e1
leaq 0x21c4e(%rip), %rdx     # 0x29572
movb $0x0, %al
callq 0x4d20
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x7a6f
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl (%rax,%rcx,8), %eax
movslq -0x10(%rbp), %rdx
leaq 0x21e41(%rip), %rcx     # 0x297b0
shlq $0x6, %rdx
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
imull (%rcx), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl 0x2(%rax,%rcx,8), %eax
movslq -0x10(%rbp), %rdx
leaq 0x21e00(%rip), %rcx     # 0x297b0
shlq $0x6, %rdx
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
imull 0x4(%rcx), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, 0x2(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl 0x4(%rax,%rcx,8), %eax
movslq -0x10(%rbp), %rdx
leaq 0x21dbd(%rip), %rcx     # 0x297b0
shlq $0x6, %rdx
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
imull 0x8(%rcx), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, 0x4(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movswl 0x6(%rax,%rcx,8), %eax
movslq -0x10(%rbp), %rdx
leaq 0x21d7a(%rip), %rcx     # 0x297b0
shlq $0x6, %rdx
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
imull 0xc(%rcx), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, 0x6(%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x794e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
leaq 0x21409(%rip), %rdi     # 0x28eb0
leaq 0x21a33(%rip), %rsi     # 0x294e1
leaq 0x21ad1(%rip), %rdx     # 0x29586
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
callq 0x7be0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x28(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x7d70
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x7bcf
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x7bbf
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
addq $0x30, %rax
movl -0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movl -0x24(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
addq $0x30, %rax
movl -0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movl -0x24(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x8(%rax,%rcx,8)
movl 0x10(%rbp), %edx
movq -0x8(%rbp), %rax
addq $0x30, %rax
movl -0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movl -0x24(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0xc(%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7b04
jmp 0x7bc1
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7af1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.h
// Function: x264_mb_partition_size(x264_macroblock_t*, int, int, int*, int*)
static inline void x264_mb_partition_size( x264_macroblock_t *mb, int i_part, int i_sub, int *w, int *h )
{
    if( mb->i_partition == D_16x16 )
    {
        *w  = 4;
        *h  = 4;
    }
    else if( mb->i_partition == D_16x8 )
    {
        *w = 4;
        *h = 2;
    }
    else if( mb->i_partition == D_8x16 )
    {
        *w = 2;
        *h = 4;
    }
    else if( mb->i_partition == D_8x8 )
    {
        if( IS_SUB4x4( mb->i_sub_partition[i_part] ) )
        {
            *w = 1;
            *h = 1;
        }
        else if( IS_SUB4x8( mb->i_sub_partition[i_part] ) )
        {
            *w = 1;
            *h = 2;
        }
        else if( IS_SUB8x4( mb->i_sub_partition[i_part] ) )
        {
            *w = 2;
            *h = 1;
        }
        else
        {
            *w = 2;
            *h = 2;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x10, 0x1c(%rax)
jne 0x7da9
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
jmp 0x7ee9
movq -0x8(%rbp), %rax
cmpl $0xe, 0x1c(%rax)
jne 0x7dcc
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
jmp 0x7ee7
movq -0x8(%rbp), %rax
cmpl $0xf, 0x1c(%rax)
jne 0x7def
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
jmp 0x7ee5
movq -0x8(%rbp), %rax
cmpl $0xd, 0x1c(%rax)
jne 0x7ee3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, 0x20(%rax,%rcx,4)
je 0x7e2a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x4, 0x20(%rax,%rcx,4)
je 0x7e2a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x8, 0x20(%rax,%rcx,4)
jne 0x7e43
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
jmp 0x7ee1
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x2, 0x20(%rax,%rcx,4)
je 0x7e70
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x6, 0x20(%rax,%rcx,4)
je 0x7e70
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0xa, 0x20(%rax,%rcx,4)
jne 0x7e86
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
jmp 0x7edf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, 0x20(%rax,%rcx,4)
je 0x7eb3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x5, 0x20(%rax,%rcx,4)
je 0x7eb3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x9, 0x20(%rax,%rcx,4)
jne 0x7ec9
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
jmp 0x7edd
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
jmp 0x7edf
jmp 0x7ee1
jmp 0x7ee3
jmp 0x7ee5
jmp 0x7ee7
jmp 0x7ee9
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq 0x20f98(%rip), %rdi     # 0x28eb0
leaq 0x215c2(%rip), %rsi     # 0x294e1
leaq 0x21676(%rip), %rdx     # 0x2959c
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x2c(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x7be0
cmpq $0x0, -0x20(%rbp)
je 0x7f79
movq -0x8(%rbp), %rax
addq $0x30, %rax
movslq -0x2c(%rbp), %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x7fe5
cmpq $0x0, 0x10(%rbp)
je 0x7fe5
movq -0x8(%rbp), %rax
addq $0x30, %rax
movslq -0x2c(%rbp), %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl 0x8(%rax,%rcx,8), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rax
movslq -0x2c(%rbp), %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl 0xc(%rax,%rcx,8), %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/macroblock.h
// Function: x264_median(int, int, int)
static inline int x264_median( int a, int b, int c )
{
    int min = a, max =a;
    if( b < min )
        min = b;
    else
        max = b;    /* no need to do 'b > max' (more consuming than always doing affectation) */

    if( c < min )
        min = c;
    else if( c > max )
        max = c;

    return a + b + c - min - max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x8749
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x874f
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x875f
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x876f
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x876d
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x876f
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
subl -0x14(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xadab
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x20a0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xad65
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)