LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
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, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xaede
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xaeb1
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
callq 0xb8a0
movl %eax, %edi
addl $0x10, %edi
sarl $0x5, %edi
callq 0xb880
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xae74
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 -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xae65
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/mc.c
// Function: pixel_avg(unsigned char*, int, unsigned char*, int, unsigned char*, int, int, int)
static inline void pixel_avg( uint8_t *dst,  int i_dst_stride,
                              uint8_t *src1, int i_src1_stride,
                              uint8_t *src2, int i_src2_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] = ( src1[x] + src2[x] + 1 ) >> 1;
        }
        dst  += i_dst_stride;
        src1 += i_src1_stride;
        src2 += i_src2_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x18(%rbp), %eax
jge 0xb87a
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0xb839
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x1, %eax
sarl %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xb7fa
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 -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xb7e7
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0xc3ed
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jge 0xc3c0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x2c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc37b
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc36e
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0xc350
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
addq $0x4, %rcx
movl -0x24(%rbp), %r8d
callq 0xc350
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
callq 0xc350
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
shll $0x2, %eax
addl $0x4, %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
shll $0x2, %eax
addl $0x4, %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
callq 0xc350
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0xc3f0
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movl -0x24(%rbp), %r8d
callq 0xc3f0
movq -0x8(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
shll $0x3, %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
shll $0x3, %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
callq 0xc3f0
movq -0x8(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
shll $0x3, %eax
addl $0x8, %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
shll $0x3, %eax
addl $0x8, %eax
cltq
addq %rax, %rcx
movl -0x24(%rbp), %r8d
callq 0xc3f0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/pixel.c
// Function: pixel_add_4x4(unsigned char*, int, short (*) [4])
static void pixel_add_4x4( uint8_t *dst, int i_dst, int16_t diff[4][4] )
{
    int x, y;

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

            pix = dst[x] + diff[y][x];
            if( pix < 0 )
            {
                dst[x] = 0;
            }
            else if( pix > 255 )
            {
                dst[x] = 255;
            }
            else
            {
                dst[x] = pix;

            }
        }
        dst += i_dst;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0xc64e
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0xc62f
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movslq -0x1c(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0xc5f9
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xc622
cmpl $0xff, -0x24(%rbp)
jle 0xc610
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $-0x1, (%rax,%rcx)
jmp 0xc620
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xc622
jmp 0xc624
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc5b7
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc5a6
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xc590
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x20, %rdx
callq 0xc590
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
addl $0x0, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x40, %rdx
callq 0xc590
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
addl $0x4, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x60, %rdx
callq 0xc590
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xc650
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x80, %rdx
callq 0xc650
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x3, %eax
addl $0x0, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x100, %rdx            # imm = 0x100
callq 0xc650
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x3, %eax
addl $0x8, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
addq $0x180, %rdx            # imm = 0x180
callq 0xc650
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/pixel.c
// Function: pixel_avg_wxh(unsigned char*, int, unsigned char*, int, int, int)
static inline void pixel_avg_wxh( uint8_t *dst, int i_dst, uint8_t *src, int i_src, int width, int height )
{
    int x, y;
    for( y = 0; y < height; y++ )
    {
        for( x = 0; x < width; x++ )
        {
            dst[x] = ( dst[x] + src[x] + 1 ) >> 1;
        }
        dst += i_dst;
        src += i_src;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xcaac
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xca7f
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x1, %eax
sarl %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xca40
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 -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xca31
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x6a(%rip), %rcx        # 0xcb30
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0xcc(%rip), %rcx        # 0xcba0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x12d(%rip), %rcx       # 0xcc10
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x1de(%rip), %rcx       # 0xccd0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x38f(%rip), %rcx       # 0xce90
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x430(%rip), %rcx       # 0xcf40
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
leaq 0x4c1(%rip), %rcx       # 0xcfe0
movq %rcx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0xcb91
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xcb84
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcb4f
jmp 0xcb86
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcb42
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_16x16_h(unsigned char*, int)
static void predict_16x16_h( uint8_t *src, int i_stride )
{
    int i,j;

    for( i = 0; i < 16; i++ )
    {
        uint8_t v;

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

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0xcc04
movq -0x8(%rbp), %rax
movb -0x1(%rax), %al
movb %al, -0x15(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xcbe8
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcbc9
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcbb2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xcc6f
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcc29
movl -0x10(%rbp), %eax
addl $0x10, %eax
sarl $0x5, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xcccc
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0xccb0
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xcc8f
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcc82
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xced8
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcea9
movl -0x10(%rbp), %eax
addl $0x8, %eax
sarl $0x4, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xcf35
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0xcf19
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xcef8
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xceeb
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_16x16_dc_128(unsigned char*, int)
static void predict_16x16_dc_128( uint8_t *src, int i_stride )
{
    int i,j;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0xd038
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xd01c
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $-0x80, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcfff
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcff2
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x6a(%rip), %rcx        # 0xd0c0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0xcb(%rip), %rcx        # 0xd130
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x12c(%rip), %rcx       # 0xd1a0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x2ae(%rip), %rcx       # 0xd330
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x45f(%rip), %rcx       # 0xd4f0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x540(%rip), %rcx       # 0xd5e0
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
leaq 0x621(%rip), %rcx       # 0xd6d0
movq %rcx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xd121
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xd114
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd0df
jmp 0xd116
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd0d2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_8x8_h(unsigned char*, int)
static void predict_8x8_h( uint8_t *src, int i_stride )
{
    int i,j;

    for( i = 0; i < 8; i++ )
    {
        uint8_t v;

        v = src[-1];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xd194
movq -0x8(%rbp), %rax
movb -0x1(%rax), %al
movb %al, -0x15(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xd178
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd159
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd142
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_8x8_dc_left(unsigned char*, int)
static void predict_8x8_dc_left( uint8_t *src, int i_stride )
{
    int x,y;
    int dc0 = 0, dc1 = 0;

    for( y = 0; y < 4; y++ )
    {
        dc0 += src[y * i_stride     - 1];
        dc1 += src[(y+4) * i_stride - 1];
    }
    dc0 = ( dc0 + 2 ) >> 2;
    dc1 = ( dc1 + 2 ) >> 2;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd55a
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
imull -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x4, %ecx
imull -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd510
movl -0x18(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd5db
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xd5bf
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd586
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd579
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_8x8_dc_top(unsigned char*, int)
static void predict_8x8_dc_top( uint8_t *src, int i_stride )
{
    int x,y;
    int dc0 = 0, dc1 = 0;

    for( x = 0; x < 4; x++ )
    {
        dc0 += src[x     - i_stride];
        dc1 += src[x + 4 - i_stride];
    }
    dc0 = ( dc0 + 2 ) >> 2;
    dc1 = ( dc1 + 2 ) >> 2;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xd642
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x4, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd600
movl -0x18(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xd6c0
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xd6a4
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd66e
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd661
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_8x8_dc_128(unsigned char*, int)
static void predict_8x8_dc_128( uint8_t *src, int i_stride )
{
    int x,y;

    for( y = 0; y < 8; y++ )
    {
        for( x = 0; x < 8; x++ )
        {
            src[x] = 128;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xd728
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xd70c
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $-0x80, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd6ef
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd6e2
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: x264_predict_4x4_init(int, void (**)(unsigned char*, int))
void x264_predict_4x4_init( int cpu, x264_predict_t pf[12] )
{
    pf[I_PRED_4x4_V]      = predict_4x4_v;
    pf[I_PRED_4x4_H]      = predict_4x4_h;
    pf[I_PRED_4x4_DC]     = predict_4x4_dc;
    pf[I_PRED_4x4_DDL]    = predict_4x4_ddl;
    pf[I_PRED_4x4_DDR]    = predict_4x4_ddr;
    pf[I_PRED_4x4_VR]     = predict_4x4_vr;
    pf[I_PRED_4x4_HD]     = predict_4x4_hd;
    pf[I_PRED_4x4_VL]     = predict_4x4_vl;
    pf[I_PRED_4x4_HU]     = predict_4x4_hu;
    pf[I_PRED_4x4_DC_LEFT]= predict_4x4_dc_left;
    pf[I_PRED_4x4_DC_TOP] = predict_4x4_dc_top;
    pf[I_PRED_4x4_DC_128] = predict_4x4_dc_128;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0xaa(%rip), %rcx        # 0xd7f0
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x10c(%rip), %rcx       # 0xd860
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq 0x16d(%rip), %rcx       # 0xd8d0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x27e(%rip), %rcx       # 0xd9f0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
leaq 0x4ff(%rip), %rcx       # 0xdc80
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
leaq 0x790(%rip), %rcx       # 0xdf20
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
leaq 0xa41(%rip), %rcx       # 0xe1e0
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
leaq 0xd02(%rip), %rcx       # 0xe4b0
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
leaq 0xfa3(%rip), %rcx       # 0xe760
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
leaq 0x1194(%rip), %rcx      # 0xe960
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
leaq 0x1255(%rip), %rcx      # 0xea30
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
leaq 0x1306(%rip), %rcx      # 0xeaf0
movq %rcx, 0x58(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_4x4_v(unsigned char*, int)
static void predict_4x4_v( uint8_t *src, int i_stride )
{
    int i,j;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xd851
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd844
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd80f
jmp 0xd846
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd802
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_4x4_h(unsigned char*, int)
static void predict_4x4_h( uint8_t *src, int i_stride )
{
    int i,j;

    for( i = 0; i < 4; i++ )
    {
        uint8_t v;

        v = src[-1];

        for( j = 0; j < 4; j++ )
        {
            src[j] = v;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xd8c4
movq -0x8(%rbp), %rax
movb -0x1(%rax), %al
movb %al, -0x15(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd8a8
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd889
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd872
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_4x4_dc(unsigned char*, int)
static void predict_4x4_dc( uint8_t *src, int i_stride )
{
    int x,y;
    int dc = ( src[-1+0*i_stride] + src[-1+i_stride]+
               src[-1+2*i_stride] + src[-1+3*i_stride] +
               src[0 - i_stride]  + src[1 - i_stride] +
               src[2 - i_stride]  + src[3 - i_stride] + 4 ) >> 3;

    for( y = 0; y < 4; y++ )
    {
        for( x = 0; x < 4; x++ )
        {
            src[x] = dc;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
imull $0x0, -0xc(%rbp), %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
shll %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
imull $0x3, -0xc(%rbp), %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl $0x1, %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl $0x2, %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl $0x3, %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x4, %eax
sarl $0x3, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xd9e0
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xd9c4
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd9a3
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd996
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_4x4_dc_left(unsigned char*, int)
static void predict_4x4_dc_left( uint8_t *src, int i_stride )
{
    int x,y;
    int dc = ( src[-1+0*i_stride] + src[-1+i_stride]+
               src[-1+2*i_stride] + src[-1+3*i_stride] + 2 ) >> 2;

    for( y = 0; y < 4; y++ )
    {
        for( x = 0; x < 4; x++ )
        {
            src[x] = dc;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
imull $0x0, -0xc(%rbp), %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
shll %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
imull $0x3, -0xc(%rbp), %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xea1f
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xea03
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe9e2
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe9d5
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_4x4_dc_top(unsigned char*, int)
static void predict_4x4_dc_top( uint8_t *src, int i_stride )
{
    int x,y;
    int dc = ( src[0 - i_stride] + src[1 - i_stride] +
               src[2 - i_stride] + src[3 - i_stride] + 2 ) >> 2;

    for( y = 0; y < 4; y++ )
    {
        for( x = 0; x < 4; x++ )
        {
            src[x] = dc;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl $0x1, %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl $0x2, %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl $0x3, %edx
subl -0xc(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xeae4
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xeac8
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xeaa7
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xea9a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/core/predict.c
// Function: predict_4x4_dc_128(unsigned char*, int)
static void predict_4x4_dc_128( uint8_t *src, int i_stride )
{
    int x,y;
    for( y = 0; y < 4; y++ )
    {
        for( x = 0; x < 4; x++ )
        {
            src[x] = 128;
        }
        src += i_stride;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xeb48
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xeb2c
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $-0x80, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xeb0f
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xeb02
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/decoder/decoder.c
// Function: x264_nal_decode(x264_nal_t*, unsigned char*, int)
int x264_nal_decode(x264_nal_t *nal, uint8_t *p_data, int i_data) {LOG_CALL;
    uint8_t *src = p_data;
    uint8_t *end = &src[i_data];
    uint8_t *dst = nal->p_payload;

    nal->i_type = src[0]&0x1f;
    nal->i_ref_idc = (src[0] >> 5)&0x03;

    src++;

    while (src < end)
    {
        if (src < end - 3 && src[0] == 0x00 && src[1] == 0x00 && src[2] == 0x03)
        {
            *dst++ = 0x00;
            *dst++ = 0x00;

            src += 3;
            continue;
        }
        *dst++ = *src++;
    }

    //nal->i_payload = (int)(dst - (uint8_t*)p_data);
    nal->i_payload = (int) (dst - (uint8_t*) nal->p_payload);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1a346(%rip), %rdi     # 0x28eb0
leaq 0x1c747(%rip), %rsi     # 0x2b2b8
leaq 0x1c752(%rip), %rdx     # 0x2b2ca
movb $0x0, %al
callq 0x4d20
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
andl $0x1f, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
sarl $0x5, %ecx
andl $0x3, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xec70
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jae 0xec49
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xec49
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0xec49
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x3, %eax
jne 0xec49
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
jmp 0xebd2
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0xebd2
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/decoder/../core/bs.h
// Function: bs_init(bs_s*, unsigned char*, int)
static inline void
bs_init(bs_t *s, uint8_t *p_data, int i_data) {LOG_CALL;
    s->p_start = p_data;
    s->p = p_data;
    s->p_end = s->p + i_data;
    s->i_left = 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x19d16(%rip), %rdi     # 0x28eb0
leaq 0x1c22b(%rip), %rsi     # 0x2b3cc
leaq 0x1c239(%rip), %rdx     # 0x2b3e1
movb $0x0, %al
callq 0x4d20
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/decoder/decoder.c
// Function: x264_slice_idr(x264_t*)
static void x264_slice_idr(x264_t *h) {LOG_CALL;
    int i;

    h->i_poc_msb = 0;
    h->i_poc_lsb = 0;
    h->i_frame_offset = 0;
    h->i_frame_num = 0;

    if (h->sps)
    {
        for (i = 0; i < h->sps->i_num_ref_frames + 1; i++)
        {
            h->freference[i]->i_poc = -1;
        }

        h->fdec = h->freference[0];
        h->i_ref0 = 0;
        h->i_ref1 = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x19cad(%rip), %rdi     # 0x28eb0
leaq 0x1c0ae(%rip), %rsi     # 0x2b2b8
leaq 0x1c1d8(%rip), %rdx     # 0x2b3e9
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rax
movl $0x0, 0xd0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xd4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xcc(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8ed8(%rax)
je 0xf2d4
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8ed8(%rcx), %rcx
movl 0x434(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xf2a2
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x10eff0(%rax,%rcx,8), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf265
movq -0x8(%rbp), %rax
movq 0x10eff0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10efe0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10f078(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10f100(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/decoder/decoder.c
// Function: x264_decoder_close(x264_t*)
void x264_decoder_close(x264_t *h) {LOG_CALL;
    int i;

    if (h->picture->i_width != 0 && h->picture->i_height != 0)
    {
        for (i = 0; i < h->sps->i_num_ref_frames + 1; i++)
        {
            x264_frame_delete(h->freference[i]);
        }
        x264_free(h->mb);
    }

    /* free vlc table */
    for (i = 0; i < 5; i++)
    {
        x264_vlc_table_lookup_delete(h->x264_coeff_token_lookup[i]);
    }
    x264_vlc_table_lookup_delete(h->x264_level_prefix_lookup);

    for (i = 0; i < 15; i++)
    {
        x264_vlc_table_lookup_delete(h->x264_total_zeros_lookup[i]);
    }
    for (i = 0; i < 3; i++)
    {
        x264_vlc_table_lookup_delete(h->x264_total_zeros_dc_lookup[i]);
    }
    for (i = 0; i < 7; i++)
    {
        x264_vlc_table_lookup_delete(h->x264_run_before_lookup[i]);
    }

    x264_free(h->picture);
    x264_free(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1909d(%rip), %rdi     # 0x28eb0
leaq 0x1b49e(%rip), %rsi     # 0x2b2b8
leaq 0x1b598(%rip), %rdx     # 0x2b3b9
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rax
movq 0x10ee48(%rax), %rax
cmpl $0x0, (%rax)
je 0xfe9b
movq -0x8(%rbp), %rax
movq 0x10ee48(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0xfe9b
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8ed8(%rcx), %rcx
movl 0x434(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xfe8b
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x10eff0(%rax,%rcx,8), %rdi
callq 0x5440
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfe50
movq -0x8(%rbp), %rax
movq 0x10efe8(%rax), %rdi
callq 0x41d0
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0xfec8
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x10f3c8(%rax,%rcx,8), %rdi
callq 0x153a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfea2
movq -0x8(%rbp), %rax
movq 0x10f3f0(%rax), %rdi
callq 0x153a0
movl $0x0, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0xff05
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x10f3f8(%rax,%rcx,8), %rdi
callq 0x153a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfedf
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xff32
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x10f470(%rax,%rcx,8), %rdi
callq 0x153a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xff0c
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0xff5f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x10f488(%rax,%rcx,8), %rdi
callq 0x153a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xff39
movq -0x8(%rbp), %rax
movq 0x10ee48(%rax), %rdi
callq 0x41d0
movq -0x8(%rbp), %rdi
callq 0x41d0
addq $0x10, %rsp
popq %rbp
retq
nop