LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/cabac.c
// Function: x264_cabac_encode_decision(x264_cabac_t*, int, int)
void x264_cabac_encode_decision( x264_cabac_t *cb, int i_ctx, int b )
{
    int i_state = cb->ctxstate[i_ctx].i_state;
    int i_mps   = cb->ctxstate[i_ctx].i_mps;

    int i_range_lps = x264_cabac_range_lps[i_state][(cb->i_range>>6)&0x03];

#ifdef TRACE
    if( binCount >= 0 )
    {
        fprintf( stderr, "%d  ctx=%d b=%d\n", binCount, i_ctx, b );
    }
    fprintf( stderr, "%d  0x%04x  %d  %d\n", binCount++, cb->i_range, i_state, i_mps );
#endif

    cb->i_range -= i_range_lps;

    if( b != i_mps )
    {
        cb->i_low += cb->i_range;
        cb->i_range = i_range_lps;

        if( i_state == 0 )
        {
            cb->ctxstate[i_ctx].i_mps = 1 - i_mps;
        }
        cb->ctxstate[i_ctx].i_state = x264_transition_lps[i_state];
    }
    else
    {
        cb->ctxstate[i_ctx].i_state = x264_transition_mps[i_state];
    }
    cb->ctxstate[i_ctx].i_count++;

    x264_cabac_encode_renorm( cb );

    cb->i_sym_cnt++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rax,%rax,2), %rax
leaq 0x18(%rdi,%rax,4), %rax
movslq (%rax), %rcx
movl 0x4(%rax), %esi
movl 0x12d0(%rdi), %edi
movq %rcx, %r8
shlq $0x4, %r8
leaq 0x20637(%rip), %r9      # 0x24730
addq %r8, %r9
movl %edi, %r8d
shrl $0x4, %r8d
andl $0xc, %r8d
movl (%r8,%r9), %r8d
subl %r8d, %edi
movl %edi, 0x12d0(%rbx)
cmpl %edx, %esi
jne 0x4121
leaq 0x20b11(%rip), %rdx     # 0x24c30
jmp 0x4143
addl %edi, 0x12cc(%rbx)
movl %r8d, 0x12d0(%rbx)
leaq 0x209fb(%rip), %rdx     # 0x24b30
testl %ecx, %ecx
jne 0x4143
movl $0x1, %edi
subl %esi, %edi
movl %edi, 0x4(%rax)
movl (%rdx,%rcx,4), %ecx
movl %ecx, (%rax)
incl 0x8(%rax)
movq %rbx, %rdi
callq 0x4160
incl 0x12d4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/cabac.c
// Function: x264_cabac_encode_renorm(x264_cabac_t*)
static inline void x264_cabac_encode_renorm( x264_cabac_t *cb )
{
    /* RenormE */
    while( cb->i_range < 0x0100 )
    {
        if( cb->i_low < 0x100 )
        {
            x264_cabac_putbit( cb, 0 );
        }
        else
        {
            if( cb->i_low >= 0x200 )
            {
                cb->i_low -= 0x200;
                x264_cabac_putbit( cb, 1 );
            }
            else
            {
                cb->i_low -= 0x100;
                cb->i_bits_outstanding++;
            }
        }

        cb->i_range <<= 1;
        cb->i_low   <<= 1;
    }
}

// Assembly:
cmpl $0xff, 0x12d0(%rdi)
jg 0x4313
pushq %rbp
movq %rsp, %rbp
movl 0x12cc(%rdi), %eax
cmpl $0xff, %eax
jg 0x4196
cmpl $0x0, 0x12d8(%rdi)
je 0x41da
movl $0x0, 0x12d8(%rdi)
jmp 0x4211
cmpl $0x200, %eax            # imm = 0x200
jl 0x41c4
addl $0xfffffe00, %eax       # imm = 0xFFFFFE00
movl %eax, 0x12cc(%rdi)
cmpl $0x0, 0x12d8(%rdi)
je 0x426b
movl $0x0, 0x12d8(%rdi)
jmp 0x429f
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, 0x12cc(%rdi)
incl 0x12dc(%rdi)
jmp 0x42f3
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x4211
movl 0x18(%rax), %ecx
decl %ecx
movl %ecx, 0x18(%rax)
movl $0x1, %esi
shll %cl, %esi
notb %sil
andb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x4211
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
cmpl $0x0, 0x12dc(%rdi)
jle 0x42f3
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x4252
movl 0x18(%rax), %ecx
decl %ecx
movl $0x1, %esi
shll %cl, %esi
movl %ecx, 0x18(%rax)
orb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x4252
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
movl 0x12dc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x12dc(%rdi)
cmpl $0x1, %eax
jg 0x421e
jmp 0x42f3
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x429f
movl 0x18(%rax), %ecx
decl %ecx
movl $0x1, %esi
shll %cl, %esi
movl %ecx, 0x18(%rax)
orb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x429f
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
cmpl $0x0, 0x12dc(%rdi)
jle 0x42f3
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x42df
movl 0x18(%rax), %ecx
decl %ecx
movl %ecx, 0x18(%rax)
movl $0x1, %esi
shll %cl, %esi
notb %sil
andb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x42df
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
movl 0x12dc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x12dc(%rdi)
cmpl $0x1, %eax
jg 0x42a8
movl 0x12d0(%rdi), %eax
addl %eax, %eax
movl %eax, 0x12d0(%rdi)
shll 0x12cc(%rdi)
cmpl $0x100, %eax            # imm = 0x100
jl 0x4174
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/cabac.c
// Function: x264_cabac_encode_bypass(x264_cabac_t*, int)
void x264_cabac_encode_bypass( x264_cabac_t *cb, int b )
{
#ifdef TRACE
    fprintf( stderr, "%d  0x%04x\n", binCount++, cb->i_range );
#endif

    cb->i_low <<= 1;
    if( b )
    {
        cb->i_low += cb->i_range;
    }

    if( cb->i_low >= 0x400 )
    {
        x264_cabac_putbit( cb, 1 );
        cb->i_low -= 0x400;
    }
    else
    {
        if( cb->i_low < 0x200 )
        {
            x264_cabac_putbit( cb, 0 );
        }
        else
        {
            cb->i_low -= 0x200;
            cb->i_bits_outstanding++;
        }
    }
    cb->i_sym_cnt++;
}

// Assembly:
leaq 0x12cc(%rdi), %rax
movl 0x12cc(%rdi), %ecx
addl %ecx, %ecx
movl %ecx, 0x12cc(%rdi)
testl %esi, %esi
je 0x4339
addl 0x12d0(%rdi), %ecx
movl %ecx, 0x12cc(%rdi)
pushq %rbp
movq %rsp, %rbp
movl (%rax), %ecx
cmpl $0x400, %ecx            # imm = 0x400
jl 0x435c
cmpl $0x0, 0x12d8(%rdi)
je 0x439d
movl $0x0, 0x12d8(%rdi)
jmp 0x43d3
cmpl $0x1ff, %ecx            # imm = 0x1FF
jg 0x4380
cmpl $0x0, 0x12d8(%rdi)
je 0x4438
movl $0x0, 0x12d8(%rdi)
jmp 0x446f
addl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
movl %ecx, 0x12cc(%rdi)
leaq 0x12dc(%rdi), %rax
movl $0x1, %edx
jmp 0x442e
movq 0x12e0(%rdi), %rdx
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
jae 0x43d3
movl 0x18(%rdx), %ecx
decl %ecx
movl $0x1, %r8d
shll %cl, %r8d
movl %ecx, 0x18(%rdx)
orb %r8b, (%rsi)
cmpl $0x0, 0x18(%rdx)
jne 0x43d3
incq 0x8(%rdx)
movl $0x8, 0x18(%rdx)
movl $0xfffffc00, %edx       # imm = 0xFFFFFC00
cmpl $0x0, 0x12dc(%rdi)
jle 0x442e
movq 0x12e0(%rdi), %rsi
movq 0x8(%rsi), %r8
cmpq 0x10(%rsi), %r8
jae 0x441a
movl 0x18(%rsi), %ecx
decl %ecx
movl %ecx, 0x18(%rsi)
movl $0x1, %r9d
shll %cl, %r9d
notb %r9b
andb %r9b, (%r8)
cmpl $0x0, 0x18(%rsi)
jne 0x441a
incq 0x8(%rsi)
movl $0x8, 0x18(%rsi)
movl 0x12dc(%rdi), %ecx
leal -0x1(%rcx), %esi
movl %esi, 0x12dc(%rdi)
cmpl $0x1, %ecx
jg 0x43e1
addl %edx, (%rax)
incl 0x12d4(%rdi)
popq %rbp
retq
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x446f
movl 0x18(%rax), %ecx
decl %ecx
movl %ecx, 0x18(%rax)
movl $0x1, %esi
shll %cl, %esi
notb %sil
andb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x446f
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
cmpl $0x0, 0x12dc(%rdi)
jle 0x4430
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x44ac
movl 0x18(%rax), %ecx
decl %ecx
movl $0x1, %esi
shll %cl, %esi
movl %ecx, 0x18(%rax)
orb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x44ac
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
movl 0x12dc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x12dc(%rdi)
cmpl $0x1, %eax
jg 0x4478
jmp 0x4430
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/cabac.c
// Function: x264_cabac_encode_terminal(x264_cabac_t*, int)
void x264_cabac_encode_terminal( x264_cabac_t *cb, int b )
{
#ifdef TRACE
    fprintf( stderr, "%d  0x%04x\n", binCount++, cb->i_range );
#endif

    cb->i_range -= 2;
    if( b )
    {
        cb->i_low += cb->i_range;
        cb->i_range = 2;
    }
    x264_cabac_encode_renorm( cb );

    cb->i_sym_cnt++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x12d0(%rdi), %eax
addl $-0x2, %eax
movl %eax, 0x12d0(%rdi)
testl %esi, %esi
je 0x44f1
addl %eax, 0x12cc(%rbx)
movl $0x2, 0x12d0(%rbx)
movq %rbx, %rdi
callq 0x4160
incl 0x12d4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x12cc(%rdi), %eax
shrl $0x9, %eax
cmpl $0x0, 0x12d8(%rdi)
je 0x4524
movl $0x0, 0x12d8(%rdi)
jmp 0x4576
movq 0x12e0(%rdi), %rdx
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
jae 0x4576
movl 0x18(%rdx), %ecx
decl %ecx
movl $0x1, %r8d
shll %cl, %r8d
movl %ecx, 0x18(%rdx)
movb (%rsi), %cl
movl %ecx, %r9d
orb %r8b, %r9b
notb %r8b
andb %cl, %r8b
testb $0x1, %al
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovnel %ecx, %r8d
movb %r8b, (%rsi)
cmpl $0x0, 0x18(%rdx)
jne 0x4576
incq 0x8(%rdx)
movl $0x8, 0x18(%rdx)
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x12dc(%rdi)
jle 0x45eb
movq 0x12e0(%rdi), %rdx
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
jae 0x45d7
movl 0x18(%rdx), %ecx
decl %ecx
movl $0x1, %r8d
shll %cl, %r8d
movl %ecx, 0x18(%rdx)
movb (%rsi), %cl
movl %ecx, %r9d
orb %r8b, %r9b
notb %r8b
andb %cl, %r8b
testb $0x1, %al
movzbl %r9b, %ecx
movzbl %r8b, %r8d
cmovel %ecx, %r8d
movb %r8b, (%rsi)
cmpl $0x0, 0x18(%rdx)
jne 0x45d7
incq 0x8(%rdx)
movl $0x8, 0x18(%rdx)
movl 0x12dc(%rdi), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x12dc(%rdi)
cmpl $0x1, %ecx
jg 0x4585
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x4644
movl 0x18(%rax), %ecx
decl %ecx
movl $0x1, %esi
shll %cl, %esi
movl 0x12cc(%rdi), %r8d
movl %ecx, 0x18(%rax)
movb (%rdx), %cl
movl %ecx, %r9d
orb %sil, %r9b
notb %sil
andb %cl, %sil
btl $0x8, %r8d
movzbl %r9b, %ecx
movzbl %sil, %esi
cmovbl %ecx, %esi
movb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x4644
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
movq 0x12e0(%rdi), %rax
movq 0x8(%rax), %rdx
cmpq 0x10(%rax), %rdx
jae 0x4678
movl 0x18(%rax), %ecx
decl %ecx
movl $0x1, %esi
shll %cl, %esi
movl %ecx, 0x18(%rax)
orb %sil, (%rdx)
cmpl $0x0, 0x18(%rax)
jne 0x4678
incq 0x8(%rax)
movl $0x8, 0x18(%rax)
movq 0x12e0(%rdi), %rbx
leaq 0x20b2e(%rip), %rdi     # 0x251b4
leaq 0x23236(%rip), %rsi     # 0x278c3
leaq 0x20b27(%rip), %rdx     # 0x251bb
xorl %eax, %eax
callq 0x4c22
movl 0x18(%rbx), %eax
cmpl $0x8, %eax
je 0x46dc
testl %eax, %eax
jle 0x46dc
incl %eax
movq 0x8(%rbx), %rdx
cmpq 0x10(%rbx), %rdx
jae 0x46dc
movb 0x18(%rbx), %cl
decb %cl
movl $0x1, %esi
shll %cl, %esi
notb %sil
andb %sil, (%rdx)
decl 0x18(%rbx)
jne 0x46d5
incq 0x8(%rbx)
movl $0x8, 0x18(%rbx)
decl %eax
cmpl $0x1, %eax
jg 0x46a9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/common.c
// Function: x264_picture_new(x264_t*)
x264_picture_t *x264_picture_new( x264_t *h )
{
    x264_picture_t *pic =(x264_picture_t *) x264_aligned_alloc( sizeof( x264_picture_t ) );
    int i_stride;
    int i_lines;

    pic->i_width = h->param.i_width;
    pic->i_height= h->param.i_height;

    i_stride = ( h->param.i_width + 15 )&0xfffff0;
    i_lines  = ( h->param.i_height + 15 )&0xfffff0;

    pic->i_plane = 3;

    pic->i_stride[0] = i_stride;
    pic->i_stride[1] = i_stride / 2;
    pic->i_stride[2] = i_stride / 2;
    pic->i_stride[3] = 0;

    pic->plane[0] =  (uint8_t *)x264_aligned_alloc( i_lines * pic->i_stride[0] );
    pic->plane[1] = (uint8_t *)x264_aligned_alloc( i_lines / 2 * pic->i_stride[1] );
    pic->plane[2] = (uint8_t *)x264_aligned_alloc( i_lines / 2 * pic->i_stride[2] );
    pic->plane[3] = NULL;

    memset( pic->plane[0],  128, i_lines * pic->i_stride[0] );
    memset( pic->plane[1], 128, i_lines / 2 * pic->i_stride[1] );
    memset( pic->plane[2], 128, i_lines / 2 * pic->i_stride[2] );

    return pic;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x10, %edi
movl $0x40, %esi
callq 0x2080
movq %rax, %rbx
movl 0x84(%r14), %r12d
movl %r12d, (%rax)
movl 0x88(%r14), %r14d
movl %r14d, 0x4(%rax)
addl $0xf, %r12d
movl $0xfffff0, %eax         # imm = 0xFFFFF0
andl %eax, %r12d
addl $0xf, %r14d
andl %eax, %r14d
movl $0x3, 0x8(%rbx)
movl %r12d, 0xc(%rbx)
movl %r14d, %r15d
imull %r12d, %r15d
shrl %r12d
movl %r12d, 0x10(%rbx)
movl %r12d, 0x14(%rbx)
movl $0x0, 0x18(%rbx)
movl $0x10, %edi
movq %r15, %rsi
callq 0x2080
movq %rax, -0x30(%rbp)
movq %rax, 0x20(%rbx)
shrl %r14d
imull %r12d, %r14d
movl $0x10, %edi
movq %r14, %rsi
callq 0x2080
movq %rax, %r13
movq %rax, 0x28(%rbx)
movl $0x10, %edi
movq %r14, %rsi
callq 0x2080
movq %rax, %r12
movq %rax, 0x30(%rbx)
movq $0x0, 0x38(%rbx)
movq -0x30(%rbp), %rdi
movl $0x80, %esi
movq %r15, %rdx
callq 0x2070
movq %r13, %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0x2070
movq %r12, %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0x2070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x4822
xorl %r14d, %r14d
movq 0x20(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4816
callq 0x2110
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x4807
testq %rbx, %rbx
je 0x4833
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2110
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x3c(%rip), %rax        # 0x48bb
movq %rax, (%rsi)
leaq 0xdc(%rip), %rax        # 0x4965
movq %rax, 0x8(%rsi)
leaq 0x187(%rip), %rax       # 0x4a1b
movq %rax, 0x10(%rsi)
leaq 0x24f(%rip), %rax       # 0x4aee
movq %rax, 0x18(%rsi)
leaq 0x2ec(%rip), %rax       # 0x4b96
movq %rax, 0x20(%rsi)
leaq 0x31c(%rip), %rax       # 0x4bd1
movq %rax, 0x28(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/dct.c
// Function: dct4x4(short (*) [4], short (*) [4])
static void dct4x4( int16_t dct[4][4], int16_t diff[4][4] )
{
    int16_t tmp[4][4];
    int s03, s12;
    int d03, d12;
    int i;

    for( i = 0; i < 4; i++ )
    {
        s03 = diff[i][0] + diff[i][3];
        s12 = diff[i][1] + diff[i][2];
        d03 = diff[i][0] - diff[i][3];
        d12 = diff[i][1] - diff[i][2];

        tmp[0][i] =   s03 +   s12;
        tmp[1][i] = 2*d03 +   d12;
        tmp[2][i] =   s03 -   s12;
        tmp[3][i] =   d03 - 2*d12;
    }

    for( i = 0; i < 4; i++ )
    {
        s03 = tmp[i][0] + tmp[i][3];
        s12 = tmp[i][1] + tmp[i][2];
        d03 = tmp[i][0] - tmp[i][3];
        d12 = tmp[i][1] - tmp[i][2];

        dct[0][i] =   s03 +   s12;
        dct[1][i] = 2*d03 +   d12;
        dct[2][i] =   s03 -   s12;
        dct[3][i] =   d03 - 2*d12;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movswl (%rsi,%rax,8), %ecx
movswl 0x6(%rsi,%rax,8), %edx
leal (%rdx,%rcx), %r8d
movswl 0x2(%rsi,%rax,8), %r9d
movswl 0x4(%rsi,%rax,8), %r10d
leal (%r10,%r9), %r11d
subl %edx, %ecx
subl %r10d, %r9d
leal (%r11,%r8), %edx
movw %dx, -0x20(%rbp,%rax,2)
leal (%r9,%rcx,2), %edx
movw %dx, -0x18(%rbp,%rax,2)
subl %r11d, %r8d
movw %r8w, -0x10(%rbp,%rax,2)
addl %r9d, %r9d
subl %r9d, %ecx
movw %cx, -0x8(%rbp,%rax,2)
incq %rax
cmpq $0x4, %rax
jne 0x48c1
xorl %eax, %eax
movswl -0x20(%rbp,%rax,8), %ecx
movswl -0x1a(%rbp,%rax,8), %edx
leal (%rdx,%rcx), %esi
movswl -0x1e(%rbp,%rax,8), %r8d
movswl -0x1c(%rbp,%rax,8), %r9d
leal (%r9,%r8), %r10d
subl %edx, %ecx
subl %r9d, %r8d
leal (%r10,%rsi), %edx
movw %dx, (%rdi,%rax,2)
leal (%r8,%rcx,2), %edx
movw %dx, 0x8(%rdi,%rax,2)
subl %r10d, %esi
movw %si, 0x10(%rdi,%rax,2)
addl %r8d, %r8d
subl %r8d, %ecx
movw %cx, 0x18(%rdi,%rax,2)
incq %rax
cmpq $0x4, %rax
jne 0x4914
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/dct.c
// Function: dct4x4dc(short (*) [4], short (*) [4])
static void dct4x4dc( int16_t dct[4][4], int16_t diff[4][4] )
{
    int16_t tmp[4][4];
    int s01, s23;
    int d01, d23;
    int i;

    for( i = 0; i < 4; i++ )
    {
        s01 = diff[i][0] + diff[i][1];
        d01 = diff[i][0] - diff[i][1];
        s23 = diff[i][2] + diff[i][3];
        d23 = diff[i][2] - diff[i][3];

        tmp[0][i] = s01 + s23;
        tmp[1][i] = s01 - s23;
        tmp[2][i] = d01 - d23;
        tmp[3][i] = d01 + d23;
    }

    for( i = 0; i < 4; i++ )
    {
        s01 = tmp[i][0] + tmp[i][1];
        d01 = tmp[i][0] - tmp[i][1];
        s23 = tmp[i][2] + tmp[i][3];
        d23 = tmp[i][2] - tmp[i][3];

        dct[0][i] = ( s01 + s23 + 1 ) >> 1;
        dct[1][i] = ( s01 - s23 + 1 ) >> 1;
        dct[2][i] = ( d01 - d23 + 1 ) >> 1;
        dct[3][i] = ( d01 + d23 + 1 ) >> 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movzwl (%rsi,%rax,8), %ecx
movzwl 0x2(%rsi,%rax,8), %edx
leal (%rdx,%rcx), %r8d
subl %edx, %ecx
movzwl 0x4(%rsi,%rax,8), %edx
movzwl 0x6(%rsi,%rax,8), %r9d
leal (%r9,%rdx), %r10d
subl %r9d, %edx
leal (%r10,%r8), %r9d
movw %r9w, -0x20(%rbp,%rax,2)
subl %r10d, %r8d
movw %r8w, -0x18(%rbp,%rax,2)
movl %ecx, %r8d
subl %edx, %r8d
movw %r8w, -0x10(%rbp,%rax,2)
addl %ecx, %edx
movw %dx, -0x8(%rbp,%rax,2)
incq %rax
cmpq $0x4, %rax
jne 0x496b
xorl %eax, %eax
movswl -0x20(%rbp,%rax,8), %ecx
movswl -0x1e(%rbp,%rax,8), %edx
leal (%rdx,%rcx), %esi
subl %edx, %ecx
movswl -0x1c(%rbp,%rax,8), %edx
movswl -0x1a(%rbp,%rax,8), %r8d
leal (%r8,%rdx), %r9d
subl %r8d, %edx
leal (%rsi,%r9), %r8d
incl %r8d
shrl %r8d
movw %r8w, (%rdi,%rax,2)
subl %r9d, %esi
incl %esi
shrl %esi
movw %si, 0x8(%rdi,%rax,2)
leal (%rcx,%rdx), %esi
incl %esi
subl %edx, %ecx
incl %ecx
shrl %ecx
movw %cx, 0x10(%rdi,%rax,2)
shrl %esi
movw %si, 0x18(%rdi,%rax,2)
incq %rax
cmpq $0x4, %rax
jne 0x49bd
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/dct.c
// Function: idct4x4(short (*) [4], short (*) [4])
static void idct4x4( int16_t diff[4][4], int16_t dct[4][4] )
{
    int16_t tmp[4][4];
    int s02, d02;
    int s13, d13;
    int i;

    for( i = 0; i < 4; i++ )
    {
        s02 = dct[0][i]      + dct[2][i];
        d02 = dct[0][i]      - dct[2][i];
        s13 = dct[1][i]      + (dct[3][i]>>1);
        d13 = (dct[1][i]>>1) -  dct[3][i];

        tmp[0][i] = s02 + s13;
        tmp[1][i] = d02 + d13;
        tmp[2][i] = d02 - d13;
        tmp[3][i] = s02 - s13;
    }

    for( i = 0; i < 4; i++ )
    {
        s02 =  tmp[i][0]     +  tmp[i][2];
        d02 =  tmp[i][0]     -  tmp[i][2];
        s13 =  tmp[i][1]     + (tmp[i][3]>>1);
        d13 = (tmp[i][1]>>1) -  tmp[i][3];

        diff[i][0] = ( s02 + s13 + 32 ) >> 6;
        diff[i][1] = ( d02 + d13 + 32 ) >> 6;
        diff[i][2] = ( d02 - d13 + 32 ) >> 6;
        diff[i][3] = ( s02 - s13 + 32 ) >> 6;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xc, %eax
movzwl -0x18(%rsi,%rax,2), %edx
movzwl -0x8(%rsi,%rax,2), %r8d
leal (%r8,%rdx), %ecx
subl %r8d, %edx
movswl -0x10(%rsi,%rax,2), %r8d
movswl (%rsi,%rax,2), %r9d
movl %r9d, %r10d
sarl %r10d
addl %r8d, %r10d
sarl %r8d
subl %r9d, %r8d
leal (%r10,%rcx), %r9d
movw %r9w, -0x38(%rbp,%rax,2)
leal (%r8,%rdx), %r9d
movw %r9w, -0x30(%rbp,%rax,2)
subl %r8d, %edx
movw %dx, -0x28(%rbp,%rax,2)
subl %r10d, %ecx
movw %cx, -0x20(%rbp,%rax,2)
incq %rax
cmpq $0x10, %rax
jne 0x4a24
xorl %eax, %eax
movswl -0x20(%rbp,%rax,8), %r8d
movswl -0x1c(%rbp,%rax,8), %r9d
movswl -0x1e(%rbp,%rax,8), %edx
movswl -0x1a(%rbp,%rax,8), %esi
movl %esi, %ecx
sarl %ecx
addl %edx, %ecx
sarl %edx
subl %esi, %edx
leal (%r9,%r8), %esi
addl $0x20, %esi
subl %r9d, %r8d
leal (%rsi,%rcx), %r9d
shrl $0x6, %r9d
movw %r9w, (%rdi,%rax,8)
leal (%r8,%rdx), %r9d
addl $0x20, %r9d
addl $0x20, %r8d
shrl $0x6, %r9d
movw %r9w, 0x2(%rdi,%rax,8)
subl %edx, %r8d
shrl $0x6, %r8d
movw %r8w, 0x4(%rdi,%rax,8)
subl %ecx, %esi
shrl $0x6, %esi
movw %si, 0x6(%rdi,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x4a7f
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/dct.c
// Function: idct4x4dc(short (*) [4], short (*) [4])
static void idct4x4dc( int16_t diff[4][4], int16_t dct[4][4] )
{
    int16_t tmp[4][4];
    int s01, s23;
    int d01, d23;
    int i;

    for( i = 0; i < 4; i++ )
    {
        s01 = dct[0][i] + dct[1][i];
        d01 = dct[0][i] - dct[1][i];
        s23 = dct[2][i] + dct[3][i];
        d23 = dct[2][i] - dct[3][i];

        tmp[0][i] = s01 + s23;
        tmp[1][i] = s01 - s23;
        tmp[2][i] = d01 - d23;
        tmp[3][i] = d01 + d23;
    }

    for( i = 0; i < 4; i++ )
    {
        s01 = tmp[i][0] + tmp[i][1];
        d01 = tmp[i][0] - tmp[i][1];
        s23 = tmp[i][2] + tmp[i][3];
        d23 = tmp[i][2] - tmp[i][3];

        diff[i][0] = s01 + s23;
        diff[i][1] = s01 - s23;
        diff[i][2] = d01 - d23;
        diff[i][3] = d01 + d23;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xc, %eax
movzwl -0x18(%rsi,%rax,2), %ecx
movzwl -0x10(%rsi,%rax,2), %edx
leal (%rdx,%rcx), %r8d
subl %edx, %ecx
movzwl -0x8(%rsi,%rax,2), %edx
movzwl (%rsi,%rax,2), %r9d
leal (%r9,%rdx), %r10d
subl %r9d, %edx
leal (%r10,%r8), %r9d
movw %r9w, -0x38(%rbp,%rax,2)
subl %r10d, %r8d
movw %r8w, -0x30(%rbp,%rax,2)
movl %ecx, %r8d
subl %edx, %r8d
movw %r8w, -0x28(%rbp,%rax,2)
addl %ecx, %edx
movw %dx, -0x20(%rbp,%rax,2)
incq %rax
cmpq $0x10, %rax
jne 0x4af7
xorl %eax, %eax
movzwl -0x20(%rbp,%rax,8), %ecx
movzwl -0x1e(%rbp,%rax,8), %edx
leal (%rdx,%rcx), %esi
subl %edx, %ecx
movzwl -0x1c(%rbp,%rax,8), %edx
movzwl -0x1a(%rbp,%rax,8), %r8d
leal (%r8,%rdx), %r9d
subl %r8d, %edx
leal (%r9,%rsi), %r8d
movw %r8w, (%rdi,%rax,8)
subl %r9d, %esi
movw %si, 0x2(%rdi,%rax,8)
movl %ecx, %esi
subl %edx, %esi
movw %si, 0x4(%rdi,%rax,8)
addl %ecx, %edx
movw %dx, 0x6(%rdi,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x4b49
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzwl (%rsi), %eax
movzwl 0x2(%rsi), %ecx
leal (%rcx,%rax), %edx
subl %ecx, %eax
movzwl 0x4(%rsi), %ecx
movzwl 0x6(%rsi), %esi
leal (%rsi,%rcx), %r8d
subl %esi, %ecx
leal (%r8,%rdx), %esi
movw %si, (%rdi)
leal (%rcx,%rax), %esi
movw %si, 0x2(%rdi)
subl %r8d, %edx
movw %dx, 0x4(%rdi)
subl %ecx, %eax
movw %ax, 0x6(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r10
leaq -0x1d0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x4c87
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)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
leaq -0x120(%rbp), %rdi
movq %r10, %rsi
callq 0x2060
movq 0x309cd6(%rip), %rsi    # 0x30e990
testq %rsi, %rsi
je 0x4cd7
leaq -0x120(%rbp), %rdi
callq 0x20d0
movq 0x309cbe(%rip), %rdi    # 0x30e990
callq 0x20e0
leaq 0x20571(%rip), %rdi     # 0x2524f
leaq -0x120(%rbp), %rsi
xorl %eax, %eax
callq 0x2040
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, 0x309cad(%rip)   # 0x30e9b0
movaps %xmm0, 0x309c96(%rip)   # 0x30e9a0
testl %esi, %esi
jle 0x4d3a
movl %esi, %eax
negq %rax
decl %esi
xorl %ecx, %ecx
leaq 0x309c82(%rip), %rdx    # 0x30e9a0
btl %esi, %edi
setae %r8b
xorb $0x31, %r8b
movb %r8b, (%rcx,%rdx)
incq %rcx
decl %esi
movq %rax, %r8
addq %rcx, %r8
jne 0x4d1e
leaq 0x309c5f(%rip), %rax    # 0x30e9a0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x204fa(%rip), %rdi     # 0x25252
xorl %eax, %eax
callq 0x4c22
movl $0x1, %r12d
leaq 0x20508(%rip), %r14     # 0x25274
leaq 0x1c7b9(%rip), %r15     # 0x2152c
movswl -0x2(%rbx,%r12,2), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4c22
testb $0x7, %r12b
jne 0x4d93
movq %r15, %rdi
xorl %eax, %eax
callq 0x4c22
incq %r12
cmpq $0x41, %r12
jne 0x4d73
leaq 0x1c789(%rip), %rdi     # 0x2152c
xorl %eax, %eax
callq 0x4c22
movq 0x2d1ef(%rip), %rax     # 0x31fa0
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x2c(%rbp)
testl %edx, %edx
jle 0x4e29
movq %rdi, %r14
movl -0x2c(%rbp), %r13d
movl %edx, %eax
movq %rax, -0x38(%rbp)
leaq 0x2048e(%rip), %r15     # 0x2527b
xorl %ebx, %ebx
cmpl $0x0, -0x2c(%rbp)
jle 0x4e0f
xorl %r12d, %r12d
movzbl (%r14,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4c22
incq %r12
cmpq %r12, %r13
jne 0x4df8
leaq 0x1c716(%rip), %rdi     # 0x2152c
xorl %eax, %eax
callq 0x4c22
incq %rbx
addq %r13, %r14
cmpq -0x38(%rbp), %rbx
jne 0x4def
leaq 0x1c6fc(%rip), %rdi     # 0x2152c
xorl %eax, %eax
callq 0x4c22
leaq 0x20444(%rip), %rdi     # 0x25282
xorl %eax, %eax
callq 0x4c22
movq 0x2d154(%rip), %rax     # 0x31fa0
movq (%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
jle 0x4e97
movq %rdi, %rbx
movl %esi, %r15d
leaq 0x2046f(%rip), %r14     # 0x252ed
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4c22
incq %r12
cmpq %r12, %r15
jne 0x4e81
leaq 0x1c68e(%rip), %rbx     # 0x2152c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c22
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c22
movq 0x2d0e7(%rip), %rax     # 0x31fa0
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x2c(%rbp)
testl %edx, %edx
jle 0x4f3d
movq %rdi, %r14
movl -0x2c(%rbp), %r13d
movl %edx, %eax
movq %rax, -0x40(%rbp)
leaq (,%r13,8), %rax
movq %rax, -0x38(%rbp)
leaq 0x203f0(%rip), %r15     # 0x252f1
xorl %r12d, %r12d
cmpl $0x0, -0x2c(%rbp)
jle 0x4f22
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4c22
incq %rbx
cmpq %rbx, %r13
jne 0x4f0c
leaq 0x1c603(%rip), %rdi     # 0x2152c
xorl %eax, %eax
callq 0x4c22
incq %r12
addq -0x38(%rbp), %r14
cmpq -0x40(%rbp), %r12
jne 0x4f04
leaq 0x1c5e8(%rip), %rdi     # 0x2152c
xorl %eax, %eax
callq 0x4c22
movq 0x2d04e(%rip), %rax     # 0x31fa0
movq (%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
jle 0x4f9e
movq %rdi, %rbx
movl %esi, %r15d
leaq 0x20369(%rip), %r14     # 0x252ed
xorl %r12d, %r12d
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4c22
incq %r12
cmpq %r12, %r15
jne 0x4f87
leaq 0x1c587(%rip), %rbx     # 0x2152c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c22
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c22
movq 0x2cfe0(%rip), %rax     # 0x31fa0
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %r12d
leaq 0x2030b(%rip), %r14     # 0x252f6
leaq 0x1c53a(%rip), %r15     # 0x2152c
movl -0x8(%rbx,%r12,8), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4c22
testb $0x7, %r12b
jne 0x5011
movq %r15, %rdi
xorl %eax, %eax
callq 0x4c22
incq %r12
cmpq $0x41, %r12
jne 0x4ff2
leaq 0x1c50b(%rip), %rdi     # 0x2152c
xorl %eax, %eax
callq 0x4c22
movq 0x2cf71(%rip), %rax     # 0x31fa0
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x70, %edi
callq 0x47e2
movq %rax, %rbx
movl 0x84(%r14), %r15d
movl 0x88(%r14), %r14d
addl $0xf, %r15d
movl $0xfffff0, %eax         # imm = 0xFFFFF0
andl %eax, %r15d
addl $0x40, %r15d
addl $0xf, %r14d
andl %eax, %r14d
movl $0x3, 0x20(%rbx)
xorl %r12d, %r12d
xorl %eax, %eax
xorl %ecx, %ecx
testq %r12, %r12
sete %al
setne %cl
movl %r15d, %edx
shrl %cl, %edx
leal 0x1(%rcx), %r13d
movl %edx, 0x24(%rbx,%r12)
movl %r14d, %esi
shrl %cl, %esi
movl %esi, 0x34(%rbx,%r12)
shll $0x5, %eax
leal (%rax,%rsi), %edi
addl $0x20, %edi
imull %edx, %edi
callq 0x47e2
movq %rax, %rcx
movq %rax, (%rbx,%r12,2)
movl 0x24(%rbx,%r12), %eax
shll $0x5, %eax
addl $0x20, %eax
cltd
idivl %r13d
cltq
addq %rcx, %rax
movq %rax, 0x48(%rbx,%r12,2)
addq $0x4, %r12
cmpq $0xc, %r12
jne 0x50b5
xorl %eax, %eax
movl %eax, 0x30(%rbx)
movl %eax, 0x40(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x60(%rbx)
movl $0xffffffff, 0x68(%rbx) # imm = 0xFFFFFFFF
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jle 0x5166
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x4838
incq %r14
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jl 0x5151
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4838
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/frame.c
// Function: x264_frame_copy_picture(x264_frame_t*, x264_picture_t*)
void x264_frame_copy_picture( x264_frame_t *dst, x264_picture_t *src )
{
    int i;
    int ch;
    int i_stride;

    /* y */
    i_stride = X264_MIN( src->i_stride[0], dst->i_stride[0] );
    for( i = 0; i < src->i_height; i++ )
    {
        memcpy( &dst->plane[0][ i * dst->i_stride[0]],
                &src->plane[0][ i * src->i_stride[0]],
                i_stride );
    }

    /* uv */
    for( ch = 0; ch < 2; ch++ )
    {
        i_stride = X264_MIN( src->i_stride[1+ch], dst->i_stride[1+ch] );
        for( i = 0; i < src->i_height/2; i++ )
        {
            memcpy( &dst->plane[1+ch][ i * dst->i_stride[1+ch]],
                    &src->plane[1+ch][ i * src->i_stride[1+ch]],
                    i_stride );
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x4(%rsi)
jle 0x51ca
movl 0xc(%rbx), %eax
movl 0x24(%r14), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %r15
xorl %r12d, %r12d
movslq 0x24(%r14), %rdi
movslq %r12d, %r12
imulq %r12, %rdi
addq 0x48(%r14), %rdi
movslq 0xc(%rbx), %rsi
imulq %r12, %rsi
addq 0x20(%rbx), %rsi
movq %r15, %rdx
callq 0x20a0
incl %r12d
cmpl 0x4(%rbx), %r12d
jl 0x519e
xorl %r12d, %r12d
movq %r12, -0x30(%rbp)
incq %r12
cmpl $0x2, 0x4(%rbx)
jl 0x522a
movl 0xc(%rbx,%r12,4), %eax
movl 0x24(%r14,%r12,4), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %r15
xorl %r13d, %r13d
movslq 0x24(%r14,%r12,4), %rdi
movslq %r13d, %r13
imulq %r13, %rdi
addq 0x48(%r14,%r12,8), %rdi
movslq 0xc(%rbx,%r12,4), %rsi
imulq %r13, %rsi
addq 0x20(%rbx,%r12,8), %rsi
movq %r15, %rdx
callq 0x20a0
incl %r13d
movl 0x4(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %r13d
jl 0x51ef
cmpq $0x0, -0x30(%rbp)
je 0x51cd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
leaq 0x1eb16(%rip), %rdi     # 0x251b4
leaq 0x1f18b(%rip), %rsi     # 0x25830
leaq 0x1f196(%rip), %rdx     # 0x25842
xorl %eax, %eax
callq 0x4c22
movl %ebx, %eax
imull %r14d, %eax
imull $0xf88, %eax, %edi      # imm = 0xF88
callq 0x47e2
testl %r14d, %r14d
jle 0x6744
movslq %ebx, %rcx
movl %ecx, %edx
movl %r14d, %esi
movq %rax, %rdi
addq $0x8, %rdi
imulq $0xf88, %rdx, %r8       # imm = 0xF88
xorl %r9d, %r9d
testl %ebx, %ebx
jle 0x6739
xorl %r10d, %r10d
testq %r9, %r9
setne %r10b
addl %r10d, %r10d
movq %rdi, %r11
xorl %r14d, %r14d
testq %r9, %r9
setne %r15b
movl %r14d, -0x8(%r11)
movl %r9d, -0x4(%r11)
xorl %r12d, %r12d
testq %r14, %r14
setne %r12b
orl %r10d, %r12d
incq %r14
cmpq %rcx, %r14
setl %r13b
andb %r15b, %r13b
movzbl %r13b, %r15d
leal (%r12,%r15,4), %r15d
movl %r15d, (%r11)
addq $0xf88, %r11            # imm = 0xF88
cmpq %r14, %rdx
jne 0x66f9
incq %r9
addq %r8, %rdi
cmpq %rsi, %r9
jne 0x66e2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/akumrao[P]videoAnalyzer/core/macroblock.c
// Function: x264_mb_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
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
leaq 0x1ea4e(%rip), %rdi     # 0x251b4
leaq 0x1f0c3(%rip), %rsi     # 0x25830
leaq 0x1f0e3(%rip), %rdx     # 0x25857
xorl %eax, %eax
callq 0x4c22
movq 0x10(%r14), %rcx
movslq %ebx, %rdx
shlq $0x5, %rdx
movq 0x4e8(%rcx,%rdx), %rdi
movq 0x4f0(%rcx,%rdx), %rsi
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %r8b
andb %al, %r8b
movl $0x2, %eax
cmpb $0x1, %r8b
jne 0x67e6
cmpl $0x0, 0x18(%rdi)
movl $0x2, %edi
jne 0x67cd
leaq (%rcx,%rdx), %rdi
addq $0x4e8, %rdi            # imm = 0x4E8
movq 0x10(%rdi), %rdi
movl (%rdi), %edi
cmpl $0x0, 0x18(%rsi)
jne 0x67e1
addq $0x4e8, %rcx            # imm = 0x4E8
movq 0x18(%rcx,%rdx), %rax
movl (%rax), %eax
cmpl %eax, %edi
cmovll %edi, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
leaq 0x1e9b6(%rip), %rdi     # 0x251b4
leaq 0x1f02b(%rip), %rsi     # 0x25830
leaq 0x1f069(%rip), %rdx     # 0x25875
xorl %eax, %eax
callq 0x4c22
movq 0x10(%r14), %rax
movslq %ebx, %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdx
addq $0x4e8, %rdx            # imm = 0x4E8
movl $0x80, %eax
cmpq $0x0, (%rdx)
movl $0x80, %ecx
je 0x6840
movq 0x10(%rdx), %rcx
movl 0x4(%rcx), %ecx
cmpq $0x0, 0x8(%rdx)
je 0x684e
movq 0x18(%rdx), %rax
movl 0x4(%rax), %eax
leal (%rax,%rcx), %edx
addl %ecx, %eax
incl %eax
shrl %eax
cmpl $0x80, %edx
cmovgel %edx, %eax
andl $0x7f, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x1e938(%rip), %rdi     # 0x251b4
leaq 0x1efad(%rip), %rsi     # 0x25830
leaq 0x1f009(%rip), %rdx     # 0x25893
xorl %eax, %eax
callq 0x4c22
cmpl $0x6, %r14d
jl 0x68f0
movl %r14d, %eax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rax, %rcx
shrq $0x22, %rcx
leal (%rcx,%rcx), %eax
leal (%rax,%rax,2), %eax
subl %eax, %r14d
shll $0x6, %r14d
leaq 0x1f245(%rip), %rax     # 0x25b00
movl (%r14,%rax), %eax
decb %cl
shll %cl, %eax
movzwl (%rbx), %ecx
imulw %ax, %cx
movw %cx, (%rbx)
movzwl 0x2(%rbx), %ecx
imulw %ax, %cx
movw %cx, 0x2(%rbx)
movzwl 0x4(%rbx), %ecx
imulw %ax, %cx
movw %cx, 0x4(%rbx)
imulw 0x6(%rbx), %ax
movw %ax, 0x6(%rbx)
jmp 0x6952
movslq %r14d, %rax
imulq $0x2aaaaaab, %rax, %rax # imm = 0x2AAAAAAB
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
addl %eax, %eax
leal (%rax,%rax,2), %eax
subl %eax, %r14d
movslq %r14d, %rax
shlq $0x6, %rax
leaq 0x1f1e3(%rip), %rcx     # 0x25b00
movl (%rax,%rcx), %eax
movswl (%rbx), %ecx
imull %eax, %ecx
shrl %ecx
movw %cx, (%rbx)
movswl 0x2(%rbx), %ecx
imull %eax, %ecx
shrl %ecx
movw %cx, 0x2(%rbx)
movswl 0x4(%rbx), %ecx
imull %eax, %ecx
shrl %ecx
movw %cx, 0x4(%rbx)
movswl 0x6(%rbx), %ecx
imull %eax, %ecx
shrl %ecx
movw %cx, 0x6(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x1e849(%rip), %rdi     # 0x251b4
leaq 0x1eebe(%rip), %rsi     # 0x25830
leaq 0x1ef31(%rip), %rdx     # 0x258aa
xorl %eax, %eax
callq 0x4c22
movslq %r14d, %rax
imulq $0x2aaaaaab, %rax, %rax # imm = 0x2AAAAAAB
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
cmpl $0xc, %r14d
jl 0x69f2
movl %r14d, %ecx
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
imulq %rcx, %rdx
shrq $0x22, %rdx
addl %edx, %edx
leal (%rdx,%rdx,2), %ecx
subl %ecx, %r14d
shll $0x6, %r14d
leaq 0x1f140(%rip), %rcx     # 0x25b00
movl (%r14,%rcx), %edx
addb $-0x2, %al
movl %eax, %ecx
shll %cl, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movzwl (%rbx,%rcx,2), %esi
imulw %dx, %si
movw %si, (%rbx,%rcx,2)
incq %rcx
cmpq $0x4, %rcx
jne 0x69ce
incq %rax
addq $0x8, %rbx
cmpq $0x4, %rax
jne 0x69cc
jmp 0x6a4b
leal (%rax,%rax), %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %r14d
movslq %r14d, %rsi
shlq $0x6, %rsi
leaq 0x1f0f7(%rip), %rdi     # 0x25b00
leal -0x1(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movl (%rsi,%rdi), %esi
movl $0x2, %ecx
subl %eax, %ecx
xorl %eax, %eax
xorl %edi, %edi
movswl (%rbx,%rdi,2), %r8d
imull %esi, %r8d
addl %edx, %r8d
sarl %cl, %r8d
movw %r8w, (%rbx,%rdi,2)
incq %rdi
cmpq $0x4, %rdi
jne 0x6a21
incq %rax
addq $0x8, %rbx
cmpq $0x4, %rax
jne 0x6a1f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x1e74d(%rip), %rdi     # 0x251b4
leaq 0x1edc2(%rip), %rsi     # 0x25830
leaq 0x1ee4c(%rip), %rdx     # 0x258c1
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x4c22
movslq %r14d, %rax
imulq $0x2aaaaaab, %rax, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx), %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %eax
cltq
shlq $0x6, %rax
leaq 0x1f055(%rip), %rdx     # 0x25b00
addq %rdx, %rax
addq $0xc, %rax
movzwl (%rbx,%r15), %edx
imull -0xc(%rax,%r15,2), %edx
shll %cl, %edx
movw %dx, (%rbx,%r15)
movzwl 0x2(%rbx,%r15), %edx
imull -0x8(%rax,%r15,2), %edx
shll %cl, %edx
movw %dx, 0x2(%rbx,%r15)
movzwl 0x4(%rbx,%r15), %edx
imull -0x4(%rax,%r15,2), %edx
shll %cl, %edx
movw %dx, 0x4(%rbx,%r15)
movzwl 0x6(%rbx,%r15), %edx
imull (%rax,%r15,2), %edx
shll %cl, %edx
movw %dx, 0x6(%rbx,%r15)
addq $0x8, %r15
cmpq $0x20, %r15
jne 0x6ab2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq