LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/encoder.c
// Function: x264_encoder_frame_get(x264_frame_t**)
static x264_frame_t *x264_encoder_frame_get(x264_frame_t *buffer[X264_BFRAME_MAX]) {LOG_CALL;
    int i;
    x264_frame_t *frame = buffer[0];

    for (i = 0; i < X264_BFRAME_MAX - 1; i++)
    {
        buffer[i] = buffer[i + 1];
    }
    buffer[X264_BFRAME_MAX - 1] = NULL;

    return frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf4ad(%rip), %rdi      # 0x28eb0
leaq 0x1308a(%rip), %rsi     # 0x2ca94
leaq 0x13291(%rip), %rdx     # 0x2cca2
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x19a58
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19a2a
movq -0x8(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/encoder.c
// Function: x264_encoder_frame_put(x264_frame_t**, x264_frame_t*)
static void x264_encoder_frame_put(x264_frame_t *buffer[X264_BFRAME_MAX], x264_frame_t *frame) {LOG_CALL;
    int i;

    /* put the frame in buffer */
    for (i = 0; buffer[i] != NULL; i++)
    {
        if (i >= X264_BFRAME_MAX)
        {
            fprintf(stderr, "not enough room\n");
            return;
        }
    }
    buffer[i] = frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xf429(%rip), %rdi      # 0x28eb0
leaq 0x13006(%rip), %rsi     # 0x2ca94
leaq 0x13224(%rip), %rdx     # 0x2ccb9
movb $0x0, %al
callq 0x4d20
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x19adf
cmpl $0x10, -0x14(%rbp)
jl 0x19ad2
movq 0x1c511(%rip), %rax     # 0x35fd0
movq (%rax), %rdi
leaq 0x13207(%rip), %rsi     # 0x2ccd0
movb $0x0, %al
callq 0x2160
jmp 0x19aef
jmp 0x19ad4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19aa3
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/../core/bs.h
// Function: bs_write_ue(bs_s*, unsigned int, char const*)
static inline void
bs_write_ue(bs_t *s, unsigned int val, const char str[]) {
    myPrintf( "bs_write_ue %u %s\n", val, str);
    int i_size = 0;
    static const int i_size0_255[256] = {
                                         1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
                                         6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
                                         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
                                         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8
    };

    if (val == 0)
    {
        _bs_write(s, 1, 1);
    }
    else
    {
        unsigned int tmp = ++val;

        if (tmp >= 0x00010000)
        {
            i_size += 16;
            tmp >>= 16;
        }
        if (tmp >= 0x100)
        {
            i_size += 8;
            tmp >>= 8;
        }
        i_size += i_size0_255[tmp];

        _bs_write(s, 2 * i_size - 1, val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x12d19(%rip), %rdi     # 0x2cdea
movb $0x0, %al
callq 0x4d20
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1a0f7
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1a6e0
jmp 0x1a162
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl %eax, -0x20(%rbp)
cmpl $0x10000, -0x20(%rbp)   # imm = 0x10000
jb 0x1a11e
movl -0x1c(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x20(%rbp)
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jb 0x1a139
movl -0x1c(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
leaq 0x130fb(%rip), %rax     # 0x2d240
movl (%rax,%rcx,4), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
shll %esi
subl $0x1, %esi
movl -0xc(%rbp), %edx
callq 0x1a6e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/../core/bs.h
// Function: bs_write(bs_s*, int, unsigned int, char const*)
static inline void
bs_write(bs_t *s, int i_count, uint32_t i_bits, const char str[]) {

    myPrintf( "bs_write %d , %u, %s\n",  i_count, i_bits, str);

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

        i_count--;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x12c0d(%rip), %rdi     # 0x2ce04
movb $0x0, %al
callq 0x4d20
cmpl $0x0, -0xc(%rbp)
jle 0x1a2b4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x1a21f
jmp 0x1a2b4
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1a25a
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
jmp 0x1a27d
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x1a2af
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x18(%rax)
jmp 0x1a1fe
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/../core/bs.h
// Function: bs_rbsp_trailing(bs_s*)
static inline void
bs_rbsp_trailing(bs_t *s) {LOG_CALL;
    _bs_write(s, 1, 1);
    if (s->i_left != 8)
    {
        _bs_write(s, s->i_left, 0x00);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xebdd(%rip), %rdi      # 0x28eb0
leaq 0x12752(%rip), %rsi     # 0x2ca2c
leaq 0x12b39(%rip), %rdx     # 0x2ce1a
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1a6e0
movq -0x8(%rbp), %rax
cmpl $0x8, 0x18(%rax)
je 0x1a314
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
xorl %edx, %edx
callq 0x1a6e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/encoder.c
// Function: x264_psnr(unsigned char*, int, unsigned char*, int, int, int)
static float x264_psnr(uint8_t *pix1, int i_pix_stride, uint8_t *pix2, int i_pix2_stride, int i_width, int i_height) {LOG_CALL;
    int64_t i_sqe = 0;

    int x, y;

    for (y = 0; y < i_height; y++)
    {
        for (x = 0; x < i_width; x++)
        {
            int tmp;

            tmp = pix1[y * i_pix_stride + x] - pix2[y * i_pix2_stride + x];

            i_sqe += tmp * tmp;
        }
    }

    if (i_sqe == 0)
    {
        return -1.0;
    }
    return (float) (10.0 * log((double) 65025.0 * (double) i_height * (double) i_width / (double) i_sqe) / log(10.0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
leaq 0xeb6b(%rip), %rdi      # 0x28eb0
leaq 0x12748(%rip), %rsi     # 0x2ca94
leaq 0x12ad8(%rip), %rdx     # 0x2ce2b
movb $0x0, %al
callq 0x4d20
movq $0x0, -0x38(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x1a3d8
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1a3cb
movq -0x10(%rbp), %rax
movl -0x40(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movl -0x40(%rbp), %edx
imull -0x24(%rbp), %edx
addl -0x3c(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
imull -0x44(%rbp), %eax
cltq
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1a378
jmp 0x1a3cd
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x1a369
cmpq $0x0, -0x38(%rbp)
jne 0x1a3ee
movss 0x126a9(%rip), %xmm0    # 0x2ca90
movss %xmm0, -0x4(%rbp)
jmp 0x1a44d
cvtsi2sdl -0x2c(%rbp), %xmm1
movsd 0x1268d(%rip), %xmm0    # 0x2ca88
mulsd %xmm1, %xmm0
cvtsi2sdl -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdq -0x38(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x2090
movaps %xmm0, %xmm1
movsd 0x1265e(%rip), %xmm0    # 0x2ca80
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x1264d(%rip), %xmm0    # 0x2ca80
callq 0x2090
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/../core/bs.h
// Function: bs_write1(bs_s*, unsigned int, char const*)
static inline void
bs_write1(bs_t *s, uint32_t i_bits, const char str[]) {

    myPrintf( "bs_write1 %d , %u ,%s\n",  1, i_bits, str);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x12597(%rip), %rdi     # 0x2cdc8
movl $0x1, %esi
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1a8cd
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1a886
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
jmp 0x1a8a6
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x1a8cb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x18(%rax)
jmp 0x1a8cd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/../core/bs.h
// Function: bs_write_ue(bs_s*, unsigned int)
static inline void
_bs_write_ue(bs_t *s, unsigned int val) {;
    int i_size = 0;
    static const int i_size0_255[256] = {
                                         1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
                                         6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
                                         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
                                         7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
                                         8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8
    };

    if (val == 0)
    {
        _bs_write(s, 1, 1);
    }
    else
    {
        unsigned int tmp = ++val;

        if (tmp >= 0x00010000)
        {
            i_size += 16;
            tmp >>= 16;
        }
        if (tmp >= 0x100)
        {
            i_size += 8;
            tmp >>= 8;
        }
        i_size += i_size0_255[tmp];

        _bs_write(s, 2 * i_size - 1, val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1a90e
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1a6e0
jmp 0x1a979
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl %eax, -0x14(%rbp)
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jb 0x1a935
movl -0x10(%rbp), %eax
addl $0x10, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jb 0x1a950
movl -0x10(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x124e4(%rip), %rax     # 0x2ce40
movl (%rax,%rcx,4), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
shll %esi
subl $0x1, %esi
movl -0xc(%rbp), %edx
callq 0x1a6e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_mb_partition_mvd(x264_macroblock_t*, int, int, int, int*)
void x264_mb_partition_mvd(x264_macroblock_t *mb, int i_list, int i_part, int i_sub, int mvd[2]) {LOG_CALL;
    int mvp[2];

    int x, y;
    int w, h;
    int dx, dy;

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

    mvd[0] = mb->partition[x][y].mv[i_list][0] - mvp[0];
    mvd[1] = mb->partition[x][y].mv[i_list][1] - mvp[1];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
leaq 0xe510(%rip), %rdi      # 0x28eb0
leaq 0x1512d(%rip), %rsi     # 0x2fad4
leaq 0x1513b(%rip), %rdx     # 0x2fae9
movb $0x0, %al
callq 0x4d20
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x2c(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x1ab20
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x34(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x1acb0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq -0x28(%rbp), %r8
callq 0x7ff0
movq -0x8(%rbp), %rax
addq $0x30, %rax
movslq -0x2c(%rbp), %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl 0x8(%rax,%rcx,8), %ecx
subl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rax
movslq -0x2c(%rbp), %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl 0xc(%rax,%rcx,8), %ecx
subl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x1ab15
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x1ab05
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
addq $0x30, %rax
movl -0x2c(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movl -0x30(%rbp), %ecx
addl -0x40(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x18(%rax,%rcx,8)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rax
addq $0x30, %rax
movl -0x2c(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movl -0x30(%rbp), %ecx
addl -0x40(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x1c(%rax,%rcx,8)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x1aa78
jmp 0x1ab07
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1aa65
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: quant_4x4(short (*) [4], int, int)
static void quant_4x4(int16_t dct[4][4], int i_qscale, int b_intra) {LOG_CALL;
    const int i_qbits = 15 + i_qscale / 6;
    const int i_mf = i_qscale % 6;
    const int f = (1 << i_qbits) / (b_intra ? 3 : 6);

    int x, y;
    for (y = 0; y < 4; y++)
    {
        for (x = 0; x < 4; x++)
        {
            if (dct[y][x] > 0)
            {
                dct[y][x] = (f + dct[y][x] * quant_mf[i_mf][y][x]) >> i_qbits;
            } else
            {
                dct[y][x] = -((f - dct[y][x] * quant_mf[i_mf][y][x]) >> i_qbits);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0xded7(%rip), %rdi      # 0x28eb0
leaq 0x14af4(%rip), %rsi     # 0x2fad4
leaq 0xe595(%rip), %rdx      # 0x2957c
movb $0x0, %al
callq 0x4d20
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
addl $0xf, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl -0x10(%rbp), %esi
movl $0x6, %ecx
movl $0x3, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x1b156
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x1b146
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x1b0d0
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movslq -0x20(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
movslq -0x18(%rbp), %rsi
leaq 0x128fd(%rip), %rdx     # 0x2d990
shlq $0x6, %rsi
addq %rsi, %rdx
movslq -0x24(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movslq -0x20(%rbp), %rsi
imull (%rdx,%rsi,4), %ecx
addl %ecx, %eax
movl -0x14(%rbp), %ecx
sarl %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x1b136
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movslq -0x20(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
movslq -0x18(%rbp), %rsi
leaq 0x1289b(%rip), %rdx     # 0x2d990
shlq $0x6, %rsi
addq %rsi, %rdx
movslq -0x24(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movslq -0x20(%rbp), %rsi
imull (%rdx,%rsi,4), %ecx
subl %ecx, %eax
movl -0x14(%rbp), %ecx
sarl %cl, %eax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x1b138
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b048
jmp 0x1b148
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b037
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: scan_zigzag_4x4full(int*, short (*) [4])
static inline void scan_zigzag_4x4full(int level[16], int16_t dct[4][4]) {LOG_CALL;
    int i;

    for (i = 0; i < 16; i++)
    {
        level[i] = dct[scan_zigzag_y[i]][scan_zigzag_x[i]];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xdd39(%rip), %rdi      # 0x28eb0
leaq 0x14956(%rip), %rsi     # 0x2fad4
leaq 0x10cc5(%rip), %rdx     # 0x2be4a
movb $0x0, %al
callq 0x4d20
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x1b1dc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0x12968(%rip), %rcx     # 0x2db10
movslq (%rcx,%rdx,4), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rdx
leaq 0x12992(%rip), %rcx     # 0x2db50
movslq (%rcx,%rdx,4), %rcx
movswl (%rax,%rcx,2), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b193
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_mb_decimate_score(int*, int)
static int x264_mb_decimate_score(int *dct, int i_max) {LOG_CALL;
    static const int i_ds_table[16] = {3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    int i_score = 0;
    int idx = i_max - 1;

    while (idx >= 0 && dct[idx] == 0)
    {
        idx--;
    }

    while (idx >= 0)
    {
        int i_run;

        if (abs(dct[idx--]) > 1)
        {
            return 9;
        }

        i_run = 0;
        while (idx >= 0 && dct[idx] == 0)
        {
            idx--;
            i_run++;
        }
        i_score += i_ds_table[i_run];
    }

    return i_score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0xce7a(%rip), %rdi      # 0x28eb0
leaq 0x13a97(%rip), %rsi     # 0x2fad4
leaq 0x13e63(%rip), %rdx     # 0x2fea7
movb $0x0, %al
callq 0x4d20
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jl 0x1c078
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1c081
jmp 0x1c08c
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c05b
jmp 0x1c08e
cmpl $0x0, -0x1c(%rbp)
jl 0x1c11c
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x1, %eax
jle 0x1c0c2
movl $0x9, -0x4(%rbp)
jmp 0x1c122
movl $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x22(%rbp)
jl 0x1c0e6
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x1c0ef
jmp 0x1c103
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1c0c9
movslq -0x20(%rbp), %rcx
leaq 0x11a82(%rip), %rax     # 0x2db90
movl (%rax,%rcx,4), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1c08e
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: array_non_zero_count(int*, int)
static inline int array_non_zero_count(int *v, int i_count) {LOG_CALL;
    int i;
    int i_nz;

    for (i = 0, i_nz = 0; i < i_count; i++)
    {
        if (v[i])
        {
            i_nz++;
        }
    }
    return i_nz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xc8aa(%rip), %rdi      # 0x28eb0
leaq 0x134c7(%rip), %rsi     # 0x2fad4
leaq 0x138bd(%rip), %rdx     # 0x2fed1
movb $0x0, %al
callq 0x4d20
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1c655
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1c648
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c64a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c629
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/../core/bs.h
// Function: bs_write_te(bs_s*, int, int, char const*)
static inline void
bs_write_te(bs_t *s, int x, int val, const char str[]) {
    myPrintf( "bs_write_te %d %s\n", val,str);
    if (x == 1)
    {
        _bs_write(s, 1, ~val);
    }
    else if (x > 1)
    {
        _bs_write_ue(s, val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x12472(%rip), %rdi     # 0x2fee6
movb $0x0, %al
callq 0x4d20
cmpl $0x1, -0xc(%rbp)
jne 0x1da97
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl $-0x1, %edx
movl $0x1, %esi
callq 0x207e0
jmp 0x1daab
cmpl $0x1, -0xc(%rbp)
jle 0x1daa9
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x208b0
jmp 0x1daab
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_cabac_mb_skip(x264_t*, x264_macroblock_t*, int)
void x264_cabac_mb_skip(x264_t *h, x264_macroblock_t *mb, int b_skip) {LOG_CALL;
    x264_macroblock_t *mba = mb->context->mba;
    x264_macroblock_t *mbb = mb->context->mbb;
    int i_ctxIdxInc = 0;

    if (mba != NULL && !IS_SKIP(mba->i_type))
    {
        i_ctxIdxInc++;
    }
    if (mbb != NULL && !IS_SKIP(mbb->i_type))
    {
        i_ctxIdxInc++;
    }

    if (h->sh.i_type == SLICE_TYPE_P)
    {
        x264_cabac_encode_decision(&h->cabac, 11 + i_ctxIdxInc, b_skip ? 1 : 0);
    } else /* SLICE_TYPE_B */
    {
        x264_cabac_encode_decision(&h->cabac, 24 + i_ctxIdxInc, b_skip ? 1 : 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0xaba6(%rip), %rdi      # 0x28eb0
leaq 0x117c3(%rip), %rsi     # 0x2fad4
leaq 0x11afe(%rip), %rdx     # 0x2fe16
movb $0x0, %al
callq 0x4d20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e369
movq -0x20(%rbp), %rax
cmpl $0x5, 0x18(%rax)
je 0x1e369
movq -0x20(%rbp), %rax
cmpl $0x11, 0x18(%rax)
je 0x1e369
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1e38d
movq -0x28(%rbp), %rax
cmpl $0x5, 0x18(%rax)
je 0x1e38d
movq -0x28(%rbp), %rax
cmpl $0x11, 0x18(%rax)
je 0x1e38d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10db00(%rax)
jne 0x1e3c2
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl -0x2c(%rbp), %esi
addl $0xb, %esi
movl -0x14(%rbp), %ecx
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0x3970
jmp 0x1e3e8
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl -0x2c(%rbp), %esi
addl $0x18, %esi
movl -0x14(%rbp), %ecx
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0x3970
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_cabac_mb_intra4x4_pred_mode(x264_t*, x264_macroblock_t*, int, int)
static void x264_cabac_mb_intra4x4_pred_mode(x264_t *h, x264_macroblock_t *mb, int i_pred, int i_mode) {LOG_CALL;
    if (i_pred == i_mode)
    {
        /* b_prev_intra4x4_pred_mode */
        x264_cabac_encode_decision(&h->cabac, 68, 1);
    } else
    {
        /* b_prev_intra4x4_pred_mode */
        x264_cabac_encode_decision(&h->cabac, 68, 0);
        if (i_mode > i_pred)
        {
            i_mode--;
        }
        x264_cabac_encode_decision(&h->cabac, 69, (i_mode)&0x01);
        x264_cabac_encode_decision(&h->cabac, 69, (i_mode >> 1)&0x01);
        x264_cabac_encode_decision(&h->cabac, 69, (i_mode >> 2)&0x01);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq 0x9e73(%rip), %rdi      # 0x28eb0
leaq 0x10a90(%rip), %rsi     # 0x2fad4
leaq 0x10fdb(%rip), %rdx     # 0x30026
movb $0x0, %al
callq 0x4d20
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x1f076
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x44, %esi
movl $0x1, %edx
callq 0x3970
jmp 0x1f0f4
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x44, %esi
xorl %edx, %edx
callq 0x3970
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x1f09e
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl -0x18(%rbp), %edx
andl $0x1, %edx
movl $0x45, %esi
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl -0x18(%rbp), %edx
sarl %edx
andl $0x1, %edx
movl $0x45, %esi
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl -0x18(%rbp), %edx
sarl $0x2, %edx
andl $0x1, %edx
movl $0x45, %esi
callq 0x3970
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_cabac_mb_intra8x8_pred_mode(x264_t*, x264_macroblock_t*)
static void x264_cabac_mb_intra8x8_pred_mode(x264_t *h, x264_macroblock_t *mb) {LOG_CALL;
    x264_macroblock_t *mba = mb->context->mba;
    x264_macroblock_t *mbb = mb->context->mbb;

    int i_ctxIdxInc = 0;

    if (mba != NULL && (mba->i_type == I_4x4 || mba->i_type == I_16x16) && mba->i_chroma_pred_mode != 0)
    {
        i_ctxIdxInc++;
    }
    if (mbb != NULL && (mbb->i_type == I_4x4 || mbb->i_type == I_16x16) && mbb->i_chroma_pred_mode != 0)
    {
        i_ctxIdxInc++;
    }
    if (mb->i_chroma_pred_mode == 0)
    {
        x264_cabac_encode_decision(&h->cabac, 64 + i_ctxIdxInc, 0);
    } else
    {
        x264_cabac_encode_decision(&h->cabac, 64 + i_ctxIdxInc, 1);
        x264_cabac_encode_decision(&h->cabac, 64 + 3, (mb->i_chroma_pred_mode == 1 ? 0 : 1));
        if (mb->i_chroma_pred_mode > 1)
        {
            x264_cabac_encode_decision(&h->cabac, 64 + 3, (mb->i_chroma_pred_mode == 2 ? 0 : 1));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x9d99(%rip), %rdi      # 0x28eb0
leaq 0x109b6(%rip), %rsi     # 0x2fad4
leaq 0x10f22(%rip), %rdx     # 0x30047
movb $0x0, %al
callq 0x4d20
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f183
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1f16d
movq -0x18(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x1f183
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c0(%rax)
je 0x1f183
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1f1b4
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1f19e
movq -0x20(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x1f1b4
movq -0x20(%rbp), %rax
cmpl $0x0, 0x2c0(%rax)
je 0x1f1b4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c0(%rax)
jne 0x1f1de
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl -0x24(%rbp), %esi
addl $0x40, %esi
xorl %edx, %edx
callq 0x3970
jmp 0x1f260
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl -0x24(%rbp), %esi
addl $0x40, %esi
movl $0x1, %edx
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movq -0x10(%rbp), %rax
movl 0x2c0(%rax), %ecx
movl $0x1, %edx
xorl %eax, %eax
cmpl $0x1, %ecx
cmovel %eax, %edx
movl $0x43, %esi
callq 0x3970
movq -0x10(%rbp), %rax
cmpl $0x1, 0x2c0(%rax)
jle 0x1f25e
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movq -0x10(%rbp), %rax
movl 0x2c0(%rax), %ecx
movl $0x1, %edx
xorl %eax, %eax
cmpl $0x2, %ecx
cmovel %eax, %edx
movl $0x43, %esi
callq 0x3970
jmp 0x1f260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_cabac_mb_sub_partition(x264_t*, int)
static void x264_cabac_mb_sub_partition(x264_t *h, int i_sub) {LOG_CALL;
    switch (i_sub)
    {
        case D_L0_8x8:
            x264_cabac_encode_decision(&h->cabac, 21, 1);
            break;
        case D_L0_8x4:
            x264_cabac_encode_decision(&h->cabac, 21, 0);
            x264_cabac_encode_decision(&h->cabac, 22, 0);
            break;
        case D_L0_4x8:
            x264_cabac_encode_decision(&h->cabac, 21, 0);
            x264_cabac_encode_decision(&h->cabac, 22, 1);
            x264_cabac_encode_decision(&h->cabac, 23, 1);
            break;
        case D_L0_4x4:
            x264_cabac_encode_decision(&h->cabac, 21, 0);
            x264_cabac_encode_decision(&h->cabac, 22, 1);
            x264_cabac_encode_decision(&h->cabac, 23, 0);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x9c2a(%rip), %rdi      # 0x28eb0
leaq 0x10847(%rip), %rsi     # 0x2fad4
leaq 0x10dd4(%rip), %rdx     # 0x30068
xorl %eax, %eax
callq 0x4d20
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x1f3a7
movq -0x18(%rbp), %rax
leaq 0xe399(%rip), %rcx      # 0x2d650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x15, %esi
movl $0x1, %edx
callq 0x3970
jmp 0x1f3a7
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x15, %esi
xorl %edx, %edx
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x16, %esi
xorl %edx, %edx
callq 0x3970
jmp 0x1f3a7
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x15, %esi
xorl %edx, %edx
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x16, %esi
movl $0x1, %edx
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x17, %esi
movl $0x1, %edx
callq 0x3970
jmp 0x1f3a7
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x15, %esi
xorl %edx, %edx
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x16, %esi
movl $0x1, %edx
callq 0x3970
movq -0x8(%rbp), %rdi
addq $0x10db60, %rdi         # imm = 0x10DB60
movl $0x17, %esi
xorl %edx, %edx
callq 0x3970
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: scan_zigzag_4x4(int*, short (*) [4])
static inline void scan_zigzag_4x4(int level[15], int16_t dct[4][4]) {LOG_CALL;
    int i;

    for (i = 1; i < 16; i++)
    {
        level[i - 1] = dct[scan_zigzag_y[i]][scan_zigzag_x[i]];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x8aa9(%rip), %rdi      # 0x28eb0
leaq 0xf6c6(%rip), %rsi      # 0x2fad4
leaq 0xba4b(%rip), %rdx      # 0x2be60
movb $0x0, %al
callq 0x4d20
movl $0x1, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x20471
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0xd6d8(%rip), %rcx      # 0x2db10
movslq (%rcx,%rdx,4), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rdx
leaq 0xd702(%rip), %rcx      # 0x2db50
movslq (%rcx,%rdx,4), %rcx
movswl (%rax,%rcx,2), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x20423
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: quant_4x4_dc(short (*) [4], int)
static void quant_4x4_dc(int16_t dct[4][4], int i_qscale) {LOG_CALL;
    const int i_qbits = 15 + i_qscale / 6;
    const int f2 = (2 << i_qbits) / 3;
    const int i_qmf = quant_mf[i_qscale % 6][0][0];
    int x, y;

    for (y = 0; y < 4; y++)
    {
        for (x = 0; x < 4; x++)
        {
            if (dct[y][x] > 0)
            {
                dct[y][x] = (f2 + dct[y][x] * i_qmf) >> (1 + i_qbits);
            } else
            {
                dct[y][x] = -((f2 - dct[y][x] * i_qmf) >> (1 + i_qbits));
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x8a1a(%rip), %rdi      # 0x28eb0
leaq 0xf637(%rip), %rsi      # 0x2fad4
leaq 0x90c1(%rip), %rdx      # 0x29565
movb $0x0, %al
callq 0x4d20
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
addl $0xf, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x2, %eax
shll %cl, %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0xd4aa(%rip), %rax      # 0x2d990
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x205dc
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x205cc
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x20574
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movslq -0x1c(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
imull -0x18(%rbp), %ecx
addl %ecx, %eax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
sarl %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x205bc
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movslq -0x1c(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
imull -0x18(%rbp), %ecx
subl %ecx, %eax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
sarl %cl, %eax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x205be
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2050a
jmp 0x205ce
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x204f9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: quant_2x2_dc(short (*) [2], int, int)
static void quant_2x2_dc(int16_t dct[2][2], int i_qscale, int b_intra) {LOG_CALL;
    int const i_qbits = 15 + i_qscale / 6;
    const int f2 = (2 << i_qbits) / (b_intra ? 3 : 6);
    const int i_qmf = quant_mf[i_qscale % 6][0][0];

    int x, y;
    for (y = 0; y < 2; y++)
    {
        for (x = 0; x < 2; x++)
        {
            if (dct[y][x] > 0)
            {
                dct[y][x] = (f2 + dct[y][x] * i_qmf) >> (1 + i_qbits);
            } else
            {
                dct[y][x] = -((f2 - dct[y][x] * i_qmf) >> (1 + i_qbits));
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x88a7(%rip), %rdi      # 0x28eb0
leaq 0xf4c4(%rip), %rsi      # 0x2fad4
leaq 0x8f37(%rip), %rdx      # 0x2954e
movb $0x0, %al
callq 0x4d20
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
addl $0xf, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x2, %eax
shll %cl, %eax
movl -0x10(%rbp), %esi
movl $0x6, %ecx
movl $0x3, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0xd329(%rip), %rax      # 0x2d990
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0x2075d
movl $0x0, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x2074d
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x206f5
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x20(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
imull -0x1c(%rbp), %ecx
addl %ecx, %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
sarl %cl, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x2073d
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x20(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
imull -0x1c(%rbp), %ecx
subl %ecx, %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
sarl %cl, %eax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x2073f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2068b
jmp 0x2074f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2067a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: scan_zigzag_2x2_dc(int*, short (*) [2])
static inline void scan_zigzag_2x2_dc(int level[4], int16_t dct[2][2]) {LOG_CALL;
    level[0] = dct[0][0];
    level[1] = dct[0][1];
    level[2] = dct[1][0];
    level[3] = dct[1][1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x8729(%rip), %rdi      # 0x28eb0
leaq 0xf346(%rip), %rsi      # 0x2fad4
leaq 0xb759(%rip), %rdx      # 0x2beee
movb $0x0, %al
callq 0x4d20
movq -0x10(%rbp), %rax
movswl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movswl 0x2(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movswl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movswl 0x6(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/me.c
// Function: me_mv_test(x264_t*, int*, int*, int*, int, unsigned char*, int, unsigned char*, int, int, int, int, int, int)
static inline int me_mv_test( x264_t *h,  
                                  int *pi_sad, int *pi_mvx, int *pi_mvy,  
                                  int i_sad_mode, uint8_t *img, int i_img, uint8_t *test, int i_test_stride,  
                                  int mvx, int mvy,  
                                  int i_lambda_motion, int mvxp, int mvyp )  
    {  
        int i_sad;  
      
        i_sad = h->pixf.sad[i_sad_mode]( img, i_img, &test[mvy*i_test_stride+mvx], i_test_stride );  
        if( i_sad + i_lambda_motion * ( bs_size_se((mvx<<2) - mvxp)+bs_size_se((mvy<<2) - mvyp) ) <  
           *pi_sad + i_lambda_motion * ( bs_size_se(((*pi_mvx)<<2) - mvxp)+bs_size_se(((*pi_mvy)<<2) - mvyp) ) )  
        {  
            *pi_sad = i_sad;  
            *pi_mvx = mvx;  
            *pi_mvy = mvy;  
            return 1;  
        }  
      
        return 0;  
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x48(%rbp), %eax
movl 0x40(%rbp), %eax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x10f2a8(%rax,%rcx,8), %rax
movq -0x38(%rbp), %rdi
movl 0x10(%rbp), %esi
movq 0x18(%rbp), %rdx
movl 0x30(%rbp), %ecx
imull 0x20(%rbp), %ecx
addl 0x28(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rdx
movl 0x20(%rbp), %ecx
callq *%rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl 0x38(%rbp), %eax
movl %eax, -0x54(%rbp)
movl 0x28(%rbp), %edi
shll $0x2, %edi
subl 0x40(%rbp), %edi
callq 0x22d30
movl %eax, -0x58(%rbp)
movl 0x30(%rbp), %edi
shll $0x2, %edi
subl 0x48(%rbp), %edi
callq 0x22d30
movl -0x58(%rbp), %edx
movl -0x54(%rbp), %ecx
movl %eax, %esi
movl -0x50(%rbp), %eax
addl %esi, %edx
imull %edx, %ecx
addl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl 0x38(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
shll $0x2, %edi
subl 0x40(%rbp), %edi
callq 0x22d30
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %edi
shll $0x2, %edi
subl 0x48(%rbp), %edi
callq 0x22d30
movl -0x4c(%rbp), %esi
movl -0x48(%rbp), %edx
movl -0x44(%rbp), %ecx
movl %eax, %edi
movl -0x40(%rbp), %eax
addl %edi, %esi
imull %esi, %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x22d1d
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl 0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl 0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x22d24
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/akumrao[P]videoAnalyzer/encoder/ratecontrol.c
// Function: x264_ratecontrol_new(x264_param_t*)
x264_ratecontrol_t *x264_ratecontrol_new( x264_param_t *param )
{
    x264_ratecontrol_t *rc = (x264_ratecontrol_t *)x264_malloc( sizeof( x264_ratecontrol_t ) );

    rc->fps = param->f_fps > 0.1 ? param->f_fps : 25.0;
    rc->i_iframe = param->i_iframe;
    rc->i_bitrate = param->i_bitrate * 1000;

    rc->i_qp_last = 26;
    rc->i_qp      = param->i_qp_constant;

    rc->i_frames  = 0;
    rc->i_size    = 0;

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x43c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd7f9(%rip), %xmm1     # 0x30668
ucomisd %xmm1, %xmm0
jbe 0x22e89
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x22e98
movsd 0xd7df(%rip), %xmm0     # 0x30670
movsd %xmm0, -0x18(%rbp)
jmp 0x22e98
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
imull $0x3e8, 0x38(%rax), %ecx # imm = 0x3E8
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1a, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)