LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Decoder.cpp
// Function: Decoder::open(char const*)
int Decoder::open(const char *input_file) {
    int ret = avformat_open_input(&mFormatCtx, input_file, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open source file %s\n", input_file);
        return ret;
    }

    /* retrieve stream information */
    ret = avformat_find_stream_info(mFormatCtx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not find stream information\n");
        return ret;
    }
    ret = open_codec_context(&mStreamIndex, &mCodecCtx, mFormatCtx, AVMEDIA_TYPE_VIDEO);
    if (ret >= 0) {
        mStream = mFormatCtx->streams[mStreamIndex];

        /* allocate image where the decoded image will be put */
        mWidth = mCodecCtx->width;
        mHeight = mCodecCtx->height;
        mPixFmt = mCodecCtx->pix_fmt;
        printf("[%s:%d]==mWidth:%d mHeight:%d mPixFmt:%d\n", __FUNCTION__, __LINE__, mWidth, mHeight, mPixFmt);
        // ret = av_image_alloc(mImageData, mImageLinesize,
        //                      mWidth, mHeight, mPixFmt, 1);
        // if (ret < 0) {
        //     fprintf(stderr, "Could not allocate raw video buffer\n");
        //     return ret;
        // }
        // video_dst_bufsize = ret;
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2100
testl %eax, %eax
js 0x27dc
movq (%r14), %rdi
xorl %esi, %esi
callq 0x2150
testl %eax, %eax
js 0x27fb
leaq 0x18(%r14), %rsi
leaq 0x8(%r14), %rdx
movq (%r14), %rcx
xorl %r8d, %r8d
callq 0x2804
movl %eax, %ebx
testl %eax, %eax
js 0x27d4
movq (%r14), %rax
movq 0x8(%r14), %rdx
movq 0x30(%rax), %rax
movslq 0x18(%r14), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%r14)
movl 0x74(%rdx), %ecx
movl %ecx, 0x20(%r14)
movl 0x78(%rdx), %r8d
movl %r8d, 0x24(%r14)
movl 0x88(%rdx), %r9d
movl %r9d, 0x1c(%r14)
leaq 0x1885(%rip), %rdi      # 0x4046
leaq 0x18a8(%rip), %rsi      # 0x4070
movl $0x34, %edx
xorl %eax, %eax
callq 0x2050
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %ebx
movq 0x37fb(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x1815(%rip), %rsi      # 0x4004
movq %r15, %rdx
xorl %eax, %eax
callq 0x2080
jmp 0x27d4
movl %eax, %ebx
callq 0x22e0
jmp 0x27d4
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Decoder.cpp
// Function: Decoder::decode(AVFrame*)
int Decoder::decode(AVFrame *frame) {
    int ret = 0;
    AVPacket pkt;
    int got_frame = 0;
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
    while (!got_frame) {
        if (!mEof) {
            // printf("[%s:%d]==\n", __FUNCTION__, __LINE__);
            ret = av_read_frame(mFormatCtx, &pkt);
            // printf("[%s:%d]==ret:%d\n", __FUNCTION__, __LINE__, ret);
            if (ret < 0) {
                mEof = true;
                return ret;
            }
        }
        AVPacket orig_pkt = pkt;
        do {
            // printf("[%s:%d]==\n", __FUNCTION__, __LINE__);
            ret = decode_packet(&pkt, frame, &got_frame);
            // printf("[%s:%d]==ret:%d\n", __FUNCTION__, __LINE__, ret);
            if (ret < 0)
                break;
            pkt.data += ret;
            pkt.size -= ret;
        } while (pkt.size > 0);
        av_packet_unref(&orig_pkt);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x4(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2190
movq $0x0, 0x18(%r15)
movl %ebp, 0x20(%r15)
cmpl %ebp, 0x4(%rsp)
jne 0x2a91
leaq 0x60(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
cmpb $0x0, 0x28(%rbx)
jne 0x2a48
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x2160
testl %eax, %eax
js 0x2a8b
movl $0xb, %ecx
movq %r15, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x28f4
movl %eax, %ebp
testl %eax, %eax
js 0x2a7a
movl %ebp, %eax
addq %rax, 0x20(%rsp)
subl %ebp, 0x28(%rsp)
jg 0x2a56
movq %r15, %rdi
callq 0x2240
cmpl $0x0, 0x4(%rsp)
je 0x2a33
jmp 0x2a91
movl %eax, %ebp
movb $0x1, 0x28(%rbx)
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::open(int, int, int)
int Envaluer::open(int width, int height, int format) {
    mWidth = width;
    mHeight = height;
    mYuvSize = width * height;
    mYuvOrg = (uint8_t *)malloc(mYuvSize * sizeof(uint8_t));
    mYuvNew = (uint8_t *)malloc(mYuvSize * sizeof(uint8_t));
    mStartClock = clock();
    switch (format) {
        case 420: {
            mYuvSize = (width * height * 3) >> 1;
        }
        break;
        default:break;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rdi, %r14
movl %esi, 0x4(%rdi)
movl %edx, 0x8(%rdi)
imull %esi, %ebx
movl %ebx, 0xc(%rdi)
movslq %ebx, %r15
movq %r15, %rdi
callq 0x21e0
movq %rax, 0x18(%r14)
movq %r15, %rdi
callq 0x21e0
movq %rax, 0x20(%r14)
callq 0x2030
movq %rax, 0x48(%r14)
cmpl $0x1a4, %ebp            # imm = 0x1A4
jne 0x2b28
movl %ebx, %eax
sarl %eax
addl %ebx, %eax
movl %eax, 0xc(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::close()
void Envaluer::close() {
    end();
    free(mYuvOrg);
    free(mYuvNew);
    free(mYPsnr);
    free(mYSsim);
    mYuvOrg = NULL;
    mYuvNew = NULL;
    mYPsnr = NULL;
    mYSsim = NULL;
    mYuvSize = 0;
    mBufSize = 0;
    mPMean = 0;
    mSMean = 0;
    mCount = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2408
movq 0x18(%rbx), %rdi
callq 0x2070
movq 0x20(%rbx), %rdi
callq 0x2070
movq 0x28(%rbx), %rdi
callq 0x2070
movq 0x30(%rbx), %rdi
callq 0x2070
movq $0x0, 0xc(%rbx)
movl $0x0, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::ssim_4x4x2_core(unsigned char const*, int, unsigned char const*, int, int (*) [4])
void Envaluer::ssim_4x4x2_core(const uint8_t *pix1, int stride1,
                               const uint8_t *pix2, int stride2,
                               int sums[2][4])
{
    int x, y, z;
    for(z=0; z<2; z++)
    {
        uint32_t s1=0, s2=0, ss=0, s12=0;
        for(y=0; y<4; y++)
            for(x=0; x<4; x++)
            {
                int a = pix1[x+y*stride1];
                int b = pix2[x+y*stride2];
                s1  += a;
                s2  += b;
                ss  += a*a;
                ss  += b*b;
                s12 += a*b;
            }
        sums[z][0] = s1;
        sums[z][1] = s2;
        sums[z][2] = ss;
        sums[z][3] = s12;
        pix1 += 4;
        pix2 += 4;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x10(%rsp)
movslq %edx, %rax
movslq %r8d, %rdx
xorl %edi, %edi
movq %rdi, -0x8(%rsp)
movq %rsi, %r11
movq %rcx, %r14
xorl %r15d, %r15d
xorl %r8d, %r8d
xorl %r10d, %r10d
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r12d, %r12d
movzbl (%r11,%r12), %r9d
movzbl (%r14,%r12), %edi
addl %r9d, %ebp
addl %edi, %ebx
movl %r9d, %r13d
imull %r9d, %r13d
addl %r10d, %r13d
movl %edi, %r10d
imull %edi, %r10d
addl %r13d, %r10d
imull %r9d, %edi
addl %edi, %r8d
incq %r12
cmpq $0x4, %r12
jne 0x2bb6
incq %r15
addq %rdx, %r14
addq %rax, %r11
cmpq $0x4, %r15
jne 0x2bb3
movq -0x8(%rsp), %r11
movq %r11, %rdi
shlq $0x4, %rdi
movq -0x10(%rsp), %r9
movl %ebp, (%r9,%rdi)
movl %ebx, 0x4(%r9,%rdi)
movl %r10d, 0x8(%r9,%rdi)
movl %r8d, 0xc(%r9,%rdi)
addq $0x4, %rsi
addq $0x4, %rcx
leaq 0x1(%r11), %rdi
testq %r11, %r11
je 0x2b9b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::ssim_end1(int, int, int, int)
float Envaluer::ssim_end1( int s1, int s2, int ss, int s12 )
{
    static const int ssim_c1 = (int)(.01*.01*255*255*64 + .5);
    static const int ssim_c2 = (int)(.03*.03*255*255*64*63 + .5);
    int vars = ss*64 - s1*s1 - s2*s2;
    int covar = s12*64 - s1*s2;
    return (float)(2*s1*s2 + ssim_c1) * (float)(2*covar + ssim_c2)\
           / ((float)(s1*s1 + s2*s2 + ssim_c1) * (float)(vars + ssim_c2));
}

// Assembly:
shll $0x6, %ecx
movl %esi, %eax
imull %esi, %eax
imull %edx, %esi
imull %edx, %edx
addl %eax, %edx
addl %esi, %esi
movl $0x1a0, %eax            # imm = 0x1A0
leal (%rsi,%rax), %edi
cvtsi2ss %edi, %xmm1
shll $0x7, %r8d
subl %esi, %r8d
movl $0x399bb, %esi          # imm = 0x399BB
addl %esi, %r8d
cvtsi2ss %r8d, %xmm0
addl %edx, %eax
cvtsi2ss %eax, %xmm2
subl %edx, %ecx
addl %esi, %ecx
cvtsi2ss %ecx, %xmm3
mulss %xmm1, %xmm0
mulss %xmm2, %xmm3
divss %xmm3, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Envaluer.cpp
// Function: Envaluer::ssim_end4(int (*) [4], int (*) [4], int)
float Envaluer::ssim_end4( int sum0[5][4], int sum1[5][4], int width )
{
    int i;
    float ssim = 0.0;
    for( i = 0; i < width; i++ )
        ssim += ssim_end1( sum0[i][0] + sum0[i+1][0] + sum1[i][0] + sum1[i+1][0],
                           sum0[i][1] + sum0[i+1][1] + sum1[i][1] + sum1[i+1][1],
                           sum0[i][2] + sum0[i+1][2] + sum1[i][2] + sum1[i+1][2],
                           sum0[i][3] + sum0[i+1][3] + sum1[i][3] + sum1[i+1][3] );
    return ssim;
}

// Assembly:
testl %ecx, %ecx
jle 0x2d61
pushq %rbp
pushq %rbx
movl %ecx, %eax
shlq $0x4, %rax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movl $0x1a0, %edi            # imm = 0x1A0
movl $0x399bb, %r8d          # imm = 0x399BB
movl 0x10(%rsi,%rcx), %r11d
movl 0x14(%rsi,%rcx), %r9d
addl (%rsi,%rcx), %r11d
addl (%rdx,%rcx), %r11d
addl 0x10(%rdx,%rcx), %r11d
addl 0x4(%rsi,%rcx), %r9d
addl 0x4(%rdx,%rcx), %r9d
addl 0x14(%rdx,%rcx), %r9d
movl 0x18(%rsi,%rcx), %r10d
addl 0x8(%rsi,%rcx), %r10d
addl 0x8(%rdx,%rcx), %r10d
addl 0x18(%rdx,%rcx), %r10d
movl %r11d, %ebx
imull %r9d, %r11d
addl %r11d, %r11d
leal (%r11,%rdi), %ebp
xorps %xmm1, %xmm1
cvtsi2ss %ebp, %xmm1
movl 0x1c(%rsi,%rcx), %ebp
addl 0xc(%rsi,%rcx), %ebp
addl 0xc(%rdx,%rcx), %ebp
addl 0x1c(%rdx,%rcx), %ebp
imull %ebx, %ebx
imull %r9d, %r9d
addl %ebx, %r9d
shll $0x7, %ebp
subl %r11d, %ebp
addl %r8d, %ebp
xorps %xmm2, %xmm2
cvtsi2ss %ebp, %xmm2
leal (%r9,%rdi), %r11d
xorps %xmm3, %xmm3
cvtsi2ss %r11d, %xmm3
shll $0x6, %r10d
mulss %xmm1, %xmm2
subl %r9d, %r10d
addl %r8d, %r10d
xorps %xmm1, %xmm1
cvtsi2ss %r10d, %xmm1
mulss %xmm3, %xmm1
divss %xmm1, %xmm2
addss %xmm2, %xmm0
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x2caa
popq %rbx
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Main.cpp
// Function: psnr_write(double, void*)
static int psnr_write(double v, void *usr) {
    Context *c = (Context *)usr;
    FILE *fp = c->psnr_file;
    char str[10] = {0};
    sprintf(str, "%.3f\n", v);
    int len = fwrite(str, sizeof(char), strlen(str), fp);
    // printf("[%s:%d]==len:%d\n", __FUNCTION__, __LINE__, len);
    fflush(fp);
    return len;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rbx
leaq 0x8(%rsp), %r14
movw $0x0, 0x8(%r14)
movq $0x0, (%r14)
leaq 0xdf8(%rip), %rsi       # 0x4308
movq %r14, %rdi
movb $0x1, %al
callq 0x2260
movq %r14, %rdi
callq 0x20a0
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2290
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/zhangk145[P]video_envalue/Main.cpp
// Function: ssim_write(double, void*)
static int ssim_write(double v, void *usr) {
    Context *c = (Context *)usr;
    FILE *fp = c->ssim_file;
    char str[10] = {0};
    sprintf(str, "%.3f\n", v);
    int len = fwrite(str, sizeof(char), strlen(str), fp);
    // printf("[%s:%d]==len:%d\n", __FUNCTION__, __LINE__, len);
    fflush(fp);
    return len;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %rbx
leaq 0x8(%rsp), %r14
movw $0x0, 0x8(%r14)
movq $0x0, (%r14)
leaq 0xd98(%rip), %rsi       # 0x4308
movq %r14, %rdi
movb $0x1, %al
callq 0x2260
movq %r14, %rdi
callq 0x20a0
movl $0x1, %esi
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2290
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/lawa.cpp
// Function: Lawa::computeMakeScore(int)
int Lawa::computeMakeScore(int lit) {
    int score = 0;
    vector<int>& occList = lit > 0 ? posOccList[lit] : negOccList[-lit];
    for (int cid : occList) {
        if (clauses[cid].satLits == 0) {
            score++;
        }
    }
    return score;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
setle %al
movl %esi, %ecx
negl %ecx
cmovsl %esi, %ecx
movq 0x28(%rdi,%rax,8), %rax
leaq (%rcx,%rcx,2), %rdx
movq (%rax,%rdx,8), %rcx
movq 0x8(%rax,%rdx,8), %rdx
cmpq %rdx, %rcx
je 0x13ee
movq 0x10(%rdi), %rsi
xorl %eax, %eax
movslq (%rcx), %rdi
shlq $0x5, %rdi
cmpb $0x1, 0x1(%rsi,%rdi)
adcl $0x0, %eax
addq $0x4, %rcx
cmpq %rdx, %rcx
jne 0x13d5
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/lawa.cpp
// Function: Lawa::computeBreakScore(int)
int Lawa::computeBreakScore(int lit) {
    int score = 0;
    vector<int>& occList = lit > 0 ? negOccList[lit] : posOccList[-lit];
    for (int cid : occList) {
        if (clauses[cid].satLits == 1) {
            score++;
        }
    }
    return score;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
setg %al
movl %esi, %ecx
negl %ecx
cmovsl %esi, %ecx
movq 0x28(%rdi,%rax,8), %rax
leaq (%rcx,%rcx,2), %rdx
movq (%rax,%rdx,8), %rcx
movq 0x8(%rax,%rdx,8), %rdx
cmpq %rdx, %rcx
je 0x143d
movq 0x10(%rdi), %rsi
xorl %eax, %eax
movslq (%rcx), %rdi
shlq $0x5, %rdi
xorl %r8d, %r8d
cmpb $0x1, 0x1(%rsi,%rdi)
sete %r8b
addl %r8d, %eax
addq $0x4, %rcx
cmpq %rdx, %rcx
jne 0x141d
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/lawa.cpp
// Function: Lawa::flipLiteral(int)
void Lawa::flipLiteral(int lit) {
    int var = abs(lit);
    vector<int>& decOccList = lit > 0 ? negOccList[var] : posOccList[var];
    vector<int>& incOccList = lit > 0 ? posOccList[var] : negOccList[var];

    for (int cid : decOccList) {
        clauses[cid].satLits--;
        if (clauses[cid].satLits == 0) {
            unsatClauseIds.push_back(cid);
        }
    }
    for (int cid : incOccList) {
        clauses[cid].satLits++;
    }

    tvalues[var] = lit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl %esi, %r13d
negl %r13d
cmovsl %esi, %r13d
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %rbp
movq 0x30(%rdi), %rax
addq %rbp, %rax
addq 0x28(%rdi), %rbp
movl %esi, (%rsp)
testl %esi, %esi
movq %rbp, %rcx
cmovgq %rax, %rcx
cmovleq %rax, %rbp
movq (%rcx), %r12
movq 0x8(%rcx), %rbx
cmpq %rbx, %r12
je 0x14d4
leaq 0x38(%r14), %r15
movslq (%r12), %rax
movl %eax, 0x4(%rsp)
movq 0x10(%r14), %rcx
movq %rax, %rdx
shlq $0x5, %rdx
decb 0x1(%rcx,%rdx)
jne 0x14cb
movq 0x40(%r14), %rsi
cmpq 0x48(%r14), %rsi
je 0x14be
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x40(%r14)
jmp 0x14cb
movq %r15, %rdi
leaq 0x4(%rsp), %rdx
callq 0x20da
addq $0x4, %r12
cmpq %rbx, %r12
jne 0x148f
movq (%rbp), %rax
movq 0x8(%rbp), %rcx
cmpq %rcx, %rax
je 0x14f9
movq 0x10(%r14), %rdx
movslq (%rax), %rsi
shlq $0x5, %rsi
incb 0x1(%rdx,%rsi)
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x14e5
movq 0x8(%r14), %rax
movl (%rsp), %ecx
movl %ecx, (%rax,%r13,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/lawa.cpp
// Function: Lawa::deallocateMemory()
void Lawa::deallocateMemory() {
    if (tvalues != nullptr) {
        delete[] tvalues;
        delete[] posOccList;
        delete[] negOccList;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x15e0
callq 0x1120
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x1583
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x156f
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x1569
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x1100
addq $-0x18, %r12
jne 0x1553
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x11c0
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
je 0x15e0
movq -0x8(%rbx), %r14
addq $-0x8, %rbx
testq %r14, %r14
je 0x15c1
leaq (,%r14,8), %rax
leaq (%rax,%rax,2), %r15
movq -0x10(%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x15bb
movq (%rbx,%r15), %rsi
subq %rdi, %rsi
callq 0x1100
addq $-0x18, %r15
jne 0x15a5
leaq (%r14,%r14,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/lawa.cpp
// Function: Lawa::addLiteral(int)
void Lawa::addLiteral(int lit) {
    int var = abs(lit);
    if (var > numVariables) {
        numVariables = var;
    }
    if (lit == 0) {
        clauses.push_back(makeClause(currentAddedClause));
        currentAddedClause.clear();
    } else {
        currentAddedClause.push_back(lit);
    }
    clausesAdded = true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
cmpl (%rdi), %eax
jle 0x1607
movl %eax, (%rbx)
testl %esi, %esi
je 0x161d
movq 0x58(%rbx), %rax
cmpq 0x60(%rbx), %rax
je 0x1687
movl %esi, (%rax)
addq $0x4, %rax
jmp 0x1681
leaq 0x50(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1f76
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x130c
leaq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21fa
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1660
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1677
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x50(%rbx), %rax
cmpq %rax, 0x58(%rbx)
je 0x1698
movq %rax, 0x58(%rbx)
jmp 0x1698
leaq 0x50(%rbx), %rdi
leaq 0xc(%rsp), %rdx
movq %rax, %rsi
callq 0x20da
movb $0x1, 0x68(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x16c3
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x16c3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x16da
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/lawa.cpp
// Function: Lawa::printDebug()
void Lawa::printDebug() {
    for (int ci = 0; ci < clauses.size(); ci++) {
        printf("%d: ",ci);
        printClause(clauses[ci]);
    }
    printModel();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x17b9
leaq 0x1886(%rip), %r14      # 0x3008
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1040
movq 0x10(%rbx), %rdi
addq %r12, %rdi
callq 0x1357
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
incq %r15
sarq $0x5, %rax
addq $0x20, %r12
cmpq %r15, %rax
ja 0x1788
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1722
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/./dimacs-parsing.h
// Function: loadSatProblem(char const*, Lawa&)
bool loadSatProblem(const char* filename, Lawa& lawa) {
    FILE* f = fopen(filename, "r");
    if (f == NULL) {
        return false;
    }
    int c = 0;
    bool neg = false;
    int clauseInd = 0;
    vector<int> tmpClause;
    while (c != EOF) {
        c = fgetc(f);

        // comment line
        if (c == 'c') {
            readLine(f);
            continue;
        }
        // problem lines
        if (c == 'p') {
            continue;
        }
        // whitespace
        if (isspace(c)) {
            continue;
        }
        // negative
        if (c == '-') {
            neg = true;
            continue;
        }

        // number
        if (isdigit(c)) {
            int num = readNextNumber(f, c);
            if (neg) {
                num *= -1;
            }
            neg = false;
            lawa.addLiteral(num);
        }
    }
    fclose(f);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x72d(%rip), %rsi       # 0x30b9
callq 0x1110
movq %rax, %r14
testq %rax, %rax
je 0x2a14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x1180
movl %eax, %ebp
cmpl $0x70, %eax
je 0x29ca
cmpl $0x63, %ebp
jne 0x29bf
movq %r14, %rdi
callq 0x2966
movl $0x63, %ebp
jmp 0x29ca
movl %ebp, %edi
callq 0x1050
testl %eax, %eax
je 0x29d1
cmpl $-0x1, %ebp
jne 0x299c
jmp 0x2a0c
cmpl $0x2d, %ebp
jne 0x29e0
movb $0x1, %r15b
movl $0x2d, %ebp
jmp 0x29ca
movl %ebp, %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x29ca
movq %r14, %rdi
movl %ebp, %esi
callq 0x2914
movl %eax, %esi
negl %esi
testb $0x1, %r15b
cmovel %eax, %esi
movq %rbx, %rdi
callq 0x15ec
xorl %r15d, %r15d
jmp 0x29ca
movq %r14, %rdi
callq 0x10e0
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/lawa/lawa-main.cpp
// Function: main
int main(int argc, char** argv) {
    printf("c This is lawa - lazy walksat local search satisfiability solver\n");
    printf("c USAGE: ./lawa <cnf-formula-in-dimacs-format> [assumptions...]\n");
    Lawa lawa;
    if (!loadSatProblem(argv[1], lawa)) {
        printf("ERROR: problem not loaded\n");
        return 1;
    }
    for (int i = 2; i < argc; i++) {
        lawa.addAssumption(atoi(argv[i]));
    }
    srand(2018);
    if (lawa.search() == 10) {
        printf("s SATISFIABLE\nv ");
        lawa.printModel();
    } else {
        printf("s UNSATISFIABLE\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x63a(%rip), %rdi       # 0x307a
callq 0x1160
leaq 0x66f(%rip), %rdi       # 0x30bb
callq 0x1160
leaq 0x8(%rsp), %rsi
movl $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x28(%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x58(%rsi)
movb $0x1, 0x68(%rsi)
movups %xmm0, 0x70(%rsi)
movups %xmm0, 0x80(%rsi)
movq $0x0, 0x90(%rsi)
movq 0x8(%rbx), %rdi
callq 0x297b
testb %al, %al
je 0x2b01
cmpl $0x3, %ebp
jl 0x2acc
movl %ebp, %r15d
movl $0x2, %r12d
leaq 0x8(%rsp), %r14
movq (%rbx,%r12,8), %rdi
callq 0x1170
movq %r14, %rdi
movl %eax, %esi
callq 0x16e2
incq %r12
cmpq %r12, %r15
jne 0x2ab1
movl $0x7e2, %edi            # imm = 0x7E2
callq 0x10d0
leaq 0x8(%rsp), %rdi
callq 0x1d24
cmpl $0xa, %eax
jne 0x2b0f
leaq 0x57d(%rip), %rdi       # 0x3069
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1040
leaq 0x8(%rsp), %rdi
callq 0x1722
jmp 0x2b1d
movl $0x1, %ebx
leaq 0x5ee(%rip), %rdi       # 0x30fb
jmp 0x2b18
xorl %ebx, %ebx
leaq 0x5fd(%rip), %rdi       # 0x3115
callq 0x1160
leaq 0x8(%rsp), %rdi
callq 0x17cc
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b3b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17cc
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: do_checksum(char const*, unsigned char const*, unsigned long)
void do_checksum(const char *prefix, const unsigned char *x, size_t len)
{
	unsigned char check = x[len - 1];
	unsigned char sum = 0;
	unsigned i;

	printf("%sChecksum: 0x%02hhx", prefix, check);

	for (i = 0; i < len-1; i++)
		sum += x[i];

	if ((unsigned char)(check + sum) != 0) {
		printf(" (should be 0x%02x)\n", -sum & 0xff);
		fail("Invalid checksum 0x%02x (should be 0x%02x).\n",
		     check, -sum & 0xff);
		return;
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
movzbl -0x1(%r15,%rdx), %ebx
decq %r14
leaq 0x1c542(%rip), %rdi     # 0x200fe
xorl %ebp, %ebp
movl %ebx, %edx
xorl %eax, %eax
callq 0x3030
testq %r14, %r14
je 0x3bde
xorl %eax, %eax
xorl %ebp, %ebp
addb (%r15,%rax), %bpl
incq %rax
movl %eax, %ecx
cmpq %rcx, %r14
ja 0x3bd0
negb %bpl
cmpb %bpl, %bl
jne 0x3bfa
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3310
movzbl %bpl, %ebp
leaq 0x1c50e(%rip), %rdi     # 0x20113
movl %ebp, %esi
xorl %eax, %eax
callq 0x3030
leaq 0x1c513(%rip), %rsi     # 0x20128
xorl %edi, %edi
movl %ebx, %edx
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x37ec
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: calc_ratio(timings*)
void calc_ratio(struct timings *t)
{
	unsigned d = gcd(t->hact, t->vact);

	if (d == 0) {
		t->hratio = t->vratio = 0;
		return;
	}
	t->hratio = t->hact / d;
	t->vratio = t->vact / d;
}

// Assembly:
movl (%rdi), %esi
movl 0x4(%rdi), %ecx
movl %esi, %r8d
testl %ecx, %ecx
je 0x3c4b
movl %esi, %eax
movl %ecx, %edx
movl %edx, %r8d
xorl %edx, %edx
divl %r8d
movl %r8d, %eax
testl %edx, %edx
jne 0x3c3c
testl %r8d, %r8d
je 0x3c68
movl %esi, %eax
xorl %edx, %edx
divl %r8d
movl %eax, 0x8(%rdi)
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
movl $0xc, %ecx
jmp 0x3c76
movl $0x0, 0xc(%rdi)
xorl %eax, %eax
movl $0x8, %ecx
movl %eax, (%rdi,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: edid_state::dtd_type[abi:cxx11](unsigned int)
std::string edid_state::dtd_type(unsigned cnt)
{
	unsigned len = std::to_string(cta.preparsed_total_dtds).length();
	char buf[16];
	sprintf(buf, "DTD %*u", len, cnt);
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl 0x180(%rsi), %r14d
movl $0x1, %eax
cmpl $0xa, %r14d
jb 0x3ce2
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r14d, %edx
cmpl $0x63, %edx
jbe 0x3cdb
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x3ce0
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x3ce2
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x3caa
addl $-0x3, %eax
jmp 0x3ce2
addl $-0x2, %eax
jmp 0x3ce2
decl %eax
movl %eax, %esi
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsp, %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x32a0
movq (%r15), %rdi
movl 0x8(%r15), %esi
movl %r14d, %edx
callq 0x8c91
movq (%r15), %rdi
movq 0x8(%r15), %r14
cmpq %r12, %rdi
je 0x3d23
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x1c42b(%rip), %rsi     # 0x20155
movq %rsp, %r15
movq %r15, %rdi
movl %r14d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3070
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x3110
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8f6e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: timings_close_match(timings const&, timings const&)
bool timings_close_match(const timings &t1, const timings &t2)
{
	// We don't want to deal with borders, you're on your own
	// if you are using those.
	if (t1.hborder || t1.vborder ||
	    t2.hborder || t2.vborder)
		return false;
	if (t1.hact != t2.hact || t1.vact != t2.vact ||
	    t1.interlaced != t2.interlaced ||
	    t1.pixclk_khz != t2.pixclk_khz ||
	    t1.hfp + t1.hsync + t1.hbp != t2.hfp + t2.hsync + t2.hbp ||
	    t1.vfp + t1.vsync + t1.vbp != t2.vfp + t2.vsync + t2.vbp)
		return false;
	if (t1.hfp == t2.hfp &&
	    t1.hsync == t2.hsync &&
	    t1.hbp == t2.hbp &&
	    t1.pos_pol_hsync == t2.pos_pol_hsync &&
	    t1.vfp == t2.vfp &&
	    t1.vsync == t2.vsync &&
	    t1.vbp == t2.vbp &&
	    t1.pos_pol_vsync == t2.pos_pol_vsync)
		return false;
	return true;
}

// Assembly:
xorl %eax, %eax
cmpl $0x0, 0x3c(%rdi)
jne 0x3eaf
cmpl $0x0, 0x40(%rdi)
jne 0x3eaf
cmpl $0x0, 0x3c(%rsi)
jne 0x3eaf
cmpl $0x0, 0x40(%rsi)
jne 0x3eaf
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x3ead
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x3ead
movb 0x18(%rdi), %al
cmpb 0x18(%rsi), %al
jne 0x3ead
movl 0x10(%rdi), %eax
cmpl 0x10(%rsi), %eax
jne 0x3ead
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x1c(%rdi), %ecx
movl 0x20(%rdi), %eax
leal (%rax,%rcx), %r8d
movl 0x24(%rdi), %edx
addl %edx, %r8d
movl 0x1c(%rsi), %r14d
movl 0x20(%rsi), %r11d
leal (%r11,%r14), %r9d
movl 0x24(%rsi), %r10d
addl %r10d, %r9d
cmpl %r9d, %r8d
jne 0x3ea9
movl 0x2c(%rdi), %r8d
movl 0x30(%rdi), %r9d
movq %r8, -0x8(%rsp)
leal (%r9,%r8), %r13d
movl 0x34(%rdi), %ebp
addl %ebp, %r13d
movl 0x2c(%rsi), %ebx
movl 0x30(%rsi), %r15d
leal (%r15,%rbx), %r8d
movl 0x34(%rsi), %r12d
addl %r12d, %r8d
cmpl %r8d, %r13d
jne 0x3ea9
xorl %r14d, %ecx
xorl %r11d, %eax
orl %ecx, %eax
xorl %r10d, %edx
orl %eax, %edx
jne 0x3eb0
cmpl %r12d, %ebp
jne 0x3eb0
cmpl %r15d, %r9d
jne 0x3eb0
cmpl %ebx, -0x8(%rsp)
jne 0x3eb0
movb 0x28(%rsi), %al
cmpb %al, 0x28(%rdi)
jne 0x3eb0
movb 0x38(%rdi), %al
cmpb 0x38(%rsi), %al
jne 0x3eb0
xorl %eax, %eax
jmp 0x3eb2
xorl %eax, %eax
retq
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/./edid-decode.h
// Function: add_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline void add_str(std::string &s, const std::string &add)
{
	if (s.empty())
		s = add;
	else if (!add.empty())
		s = s + ", " + add;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x585a
cmpq $0x0, 0x8(%r14)
je 0x58ca
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8cfe
leaq 0x1b2f4(%rip), %rsi     # 0x20b0e
movq %r15, %rdi
callq 0x3420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x30b0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5870
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x5877
movq %rbx, %rdi
movq %r14, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3140
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32d0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x58b3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x58ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x58d8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x58f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: containerid2s[abi:cxx11](unsigned char const*)
std::string containerid2s(const unsigned char *x)
{
	char buf[40];

	sprintf(buf, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
		x[0], x[1], x[2], x[3],
		x[4], x[5],
		x[6], x[7],
		x[8], x[9],
		x[10], x[11], x[12], x[13], x[14], x[15]);
	return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movzbl (%rsi), %edx
movzbl 0x1(%rsi), %ecx
movzbl 0x2(%rsi), %r8d
movzbl 0x3(%rsi), %r9d
movzbl 0x4(%rsi), %eax
movq %rax, 0x28(%rsp)
movzbl 0x5(%rsi), %eax
movq %rax, 0x20(%rsp)
movzbl 0x6(%rsi), %eax
movq %rax, 0x18(%rsp)
movzbl 0x7(%rsi), %eax
movq %rax, 0x10(%rsp)
movzbl 0x8(%rsi), %eax
movq %rax, 0x8(%rsp)
movzbl 0x9(%rsi), %ebp
movzbl 0xa(%rsi), %r10d
movzbl 0xb(%rsi), %r14d
movzbl 0xc(%rsi), %r11d
movzbl 0xd(%rsi), %r15d
movzbl 0xe(%rsi), %r12d
movzbl 0xf(%rsi), %r13d
leaq 0x1aaaf(%rip), %rsi     # 0x20421
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
pushq %r13
pushq %r12
pushq %r15
pushq %r11
pushq %r14
pushq %r10
pushq %rbp
pushq 0x40(%rsp)
pushq 0x50(%rsp)
pushq 0x60(%rsp)
pushq 0x70(%rsp)
pushq 0x80(%rsp)
callq 0x3070
addq $0x60, %rsp
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x3110
leaq (%rsp,%rax), %rdx
addq $0x30, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8f6e
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: oui_name(unsigned int, bool)
const char *oui_name(unsigned oui, bool reverse)
{
	if (reverse)
		oui = (oui >> 16) | (oui & 0xff00) | ((oui & 0xff) << 16);

	switch (oui) {
	case 0x00001a: return "AMD";
	case 0x000c03: return "HDMI";
	case 0x00044b: return "NVIDIA";
	case 0x000c6e: return "ASUS";
	case 0x0010fa: return "Apple";
	case 0x0014b9: return "MSTAR";
	case 0x00d046: return "Dolby";
	case 0x00e047: return "InFocus";
	case 0x3a0292: return "VESA";
	case 0x90848b: return "HDR10+";
	case 0xc45dd8: return "HDMI Forum";
	case 0xca125c: return "Microsoft";
	default: return NULL;
	}
}

// Assembly:
testl %esi, %esi
je 0x5a4a
movl %edi, %eax
shrl $0x10, %eax
movl %edi, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
orl %eax, %ecx
movzbl %dil, %edi
shll $0x10, %edi
orl %ecx, %edi
cmpl $0xd045, %edi           # imm = 0xD045
jg 0x5a83
cmpl $0xc6d, %edi            # imm = 0xC6D
jg 0x5aaf
cmpl $0x1a, %edi
je 0x5aef
cmpl $0x44b, %edi            # imm = 0x44B
je 0x5b0f
cmpl $0xc03, %edi            # imm = 0xC03
jne 0x5b2f
leaq 0x27f95(%rip), %rax     # 0x2da17
retq
cmpl $0x90848a, %edi         # imm = 0x90848A
jg 0x5acf
cmpl $0xd046, %edi           # imm = 0xD046
je 0x5af7
cmpl $0xe047, %edi           # imm = 0xE047
je 0x5b17
cmpl $0x3a0292, %edi         # imm = 0x3A0292
jne 0x5b2f
leaq 0x1a9e2(%rip), %rax     # 0x20490
retq
cmpl $0xc6e, %edi            # imm = 0xC6E
je 0x5aff
cmpl $0x10fa, %edi           # imm = 0x10FA
je 0x5b1f
cmpl $0x14b9, %edi           # imm = 0x14B9
jne 0x5b2f
leaq 0x1a9ae(%rip), %rax     # 0x2047c
retq
cmpl $0x90848b, %edi         # imm = 0x90848B
je 0x5b07
cmpl $0xc45dd8, %edi         # imm = 0xC45DD8
je 0x5b27
cmpl $0xca125c, %edi         # imm = 0xCA125C
jne 0x5b2f
leaq 0x1a9b9(%rip), %rax     # 0x204a7
retq
leaq 0x1a970(%rip), %rax     # 0x20466
retq
leaq 0x1a984(%rip), %rax     # 0x20482
retq
leaq 0x1a96b(%rip), %rax     # 0x20471
retq
leaq 0x1a987(%rip), %rax     # 0x20495
retq
leaq 0x1a954(%rip), %rax     # 0x2046a
retq
leaq 0x1a96a(%rip), %rax     # 0x20488
retq
leaq 0x1a950(%rip), %rax     # 0x20476
retq
leaq 0x1a96e(%rip), %rax     # 0x2049c
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: memchk(unsigned char const*, unsigned int, unsigned char)
bool memchk(const unsigned char *x, unsigned len, unsigned char v)
{
	for (unsigned i = 0; i < len; i++)
		if (x[i] != v)
			return false;
	return true;
}

// Assembly:
testl %esi, %esi
sete %al
je 0x5bba
cmpb %dl, (%rdi)
jne 0x5bba
movl %esi, %eax
movl $0x1, %r8d
movq %r8, %rcx
cmpl %ecx, %eax
je 0x5bb5
leaq 0x1(%rcx), %r8
cmpb %dl, (%rdi,%rcx)
je 0x5ba5
cmpl %esi, %ecx
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: hex_block(char const*, unsigned char const*, unsigned int, bool, unsigned int)
void hex_block(const char *prefix, const unsigned char *x,
	       unsigned length, bool show_ascii, unsigned step)
{
	unsigned i, j;

	if (!length)
		return;

	for (i = 0; i < length; i += step) {
		unsigned len = min(step, length - i);

		printf("%s", prefix);
		for (j = 0; j < len; j++)
			printf("%s%02x", j ? " " : "", x[i + j]);

		if (show_ascii) {
			for (j = len; j < step; j++)
				printf("   ");
			printf(" '");
			for (j = 0; j < len; j++)
				printf("%c", x[i + j] >= ' ' && x[i + j] <= '~' ? x[i + j] : '.');
			printf("'");
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0x18(%rsp)
movq %rdi, 0x28(%rsp)
testl %edx, %edx
je 0x5d18
movl %r8d, %r14d
movq %rsi, %r15
movl %r8d, %eax
movq %rax, 0x20(%rsp)
leaq 0x1f85b(%rip), %rbx     # 0x2544a
xorl %r13d, %r13d
movl %r8d, 0x14(%rsp)
movl %edx, 0x10(%rsp)
subl %r13d, %edx
cmpl %r14d, %edx
movl %edx, 0x1c(%rsp)
cmovbl %edx, %r14d
leaq 0x1b152(%rip), %rdi     # 0x20d62
movq 0x28(%rsp), %rsi
xorl %eax, %eax
callq 0x3030
movl %r14d, 0xc(%rsp)
testl %r14d, %r14d
leaq 0x1b04e(%rip), %rax     # 0x20c79
movq %r15, %rbp
leaq 0x1a88b(%rip), %r15     # 0x204c0
movq %r13, %r12
je 0x5c76
movq %r15, %r13
movl 0xc(%rsp), %esi
movq %rsi, 0x30(%rsp)
xorl %r14d, %r14d
testq %r14, %r14
movq %rbx, %rsi
cmoveq %rax, %rsi
movq %rax, %r15
leal (%r12,%r14), %eax
movzbl (%rbp,%rax), %edx
movq %r13, %rdi
xorl %eax, %eax
callq 0x3030
movq %r15, %rax
incq %r14
cmpq 0x30(%rsp), %r14
jb 0x5c49
cmpb $0x0, 0x18(%rsp)
movl 0x14(%rsp), %r14d
movq %rbp, %r15
movq %r12, %r13
je 0x5cfc
movq %rbx, %rbp
cmpl %r14d, 0x1c(%rsp)
leaq 0x1f7b1(%rip), %r12     # 0x25448
jae 0x5cae
movl 0xc(%rsp), %ebx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3030
incl %ebx
cmpl %r14d, %ebx
jb 0x5c9d
leaq 0x1a812(%rip), %rdi     # 0x204c7
xorl %eax, %eax
callq 0x3030
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x5cef
movl %eax, %ebx
xorl %r12d, %r12d
leal (%r12,%r13), %eax
movzbl (%r15,%rax), %eax
leal -0x20(%rax), %ecx
cmpb $0x5f, %cl
jb 0x5cdf
movl $0x2e, %eax
movzbl %al, %edi
callq 0x3310
incq %r12
cmpq %rbx, %r12
jb 0x5cc9
movl $0x27, %edi
callq 0x3310
movq %rbp, %rbx
movl $0xa, %edi
callq 0x3310
addq 0x20(%rsp), %r13
movl 0x10(%rsp), %edx
cmpl %edx, %r13d
jb 0x5bfb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: edid_state::parse_extension(unsigned char const*)
void edid_state::parse_extension(const unsigned char *x)
{
	block = block_name(x[0]);
	data_block.clear();

	printf("\n");
	if (block_nr && x[0] == 0)
		block = "Unknown EDID Extension Block 0x00";
	printf("Block %u, %s:\n", block_nr, block.c_str());

	switch (x[0]) {
	case 0x02:
		parse_cta_block(x);
		break;
	case 0x10:
		parse_vtb_ext_block(x);
		break;
	case 0x20:
		fail("Deprecated extension block for EDID 2.0, do not use.\n");
		break;
	case 0x40:
		parse_di_ext_block(x);
		break;
	case 0x50:
		parse_ls_ext_block(x);
		break;
	case 0x70:
		parse_displayid_block(x);
		break;
	case 0xf0:
		parse_block_map(x);
		if (block_nr != 1 && block_nr != 128)
			fail("Must be used in block 1 and 128.\n");
		break;
	default:
		hex_block("  ", x, EDID_PAGE_SIZE);
		fail("Unknown Extension Block.\n");
		break;
	}

	data_block.clear();
	do_checksum("", x, EDID_PAGE_SIZE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5d27
leaq 0x10(%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x617d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movq $0x0, 0x38(%r14)
movq 0x30(%r14), %rax
movb $0x0, (%rax)
movl $0xa, %edi
callq 0x3310
cmpl $0x0, 0x8(%r14)
je 0x61bd
cmpb $0x0, (%rbx)
jne 0x61bd
movq 0x18(%r14), %rdx
leaq 0x1a549(%rip), %rcx     # 0x206f6
movl $0x21, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x3390
movl 0x8(%r14), %esi
movq 0x10(%r14), %rdx
leaq 0x1a54c(%rip), %rdi     # 0x20718
xorl %eax, %eax
callq 0x3030
movzbl (%rbx), %eax
cmpl $0x3f, %eax
jle 0x61fe
cmpl $0x6f, %eax
jg 0x621a
cmpl $0x40, %eax
je 0x6288
cmpl $0x50, %eax
jne 0x6257
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d90a
jmp 0x62ad
cmpl $0x2, %eax
je 0x624a
cmpl $0x10, %eax
je 0x62a2
cmpl $0x20, %eax
jne 0x6257
leaq 0x1a50f(%rip), %rsi     # 0x20727
jmp 0x627d
cmpl $0x70, %eax
je 0x6295
cmpl $0xf0, %eax
jne 0x6257
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f6e
movl 0x8(%r14), %eax
cmpl $0x1, %eax
je 0x62ad
cmpl $0x80, %eax
je 0x62ad
leaq 0x1a515(%rip), %rsi     # 0x2075d
jmp 0x627d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14ed8
jmp 0x62ad
leaq 0x1f1eb(%rip), %rdi     # 0x25449
movq %rbx, %rsi
movl $0x80, %edx
movl $0x1, %ecx
movl $0x10, %r8d
callq 0x5bbb
leaq 0x1a502(%rip), %rsi     # 0x2077f
xorl %edi, %edi
xorl %eax, %eax
callq 0x37ec
jmp 0x62ad
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ef20
jmp 0x62ad
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b7e8
jmp 0x62ad
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1eff4
movq $0x0, 0x38(%r14)
movq 0x30(%r14), %rax
movb $0x0, (%rax)
leaq 0x1a9b6(%rip), %rdi     # 0x20c79
movl $0x80, %edx
movq %rbx, %rsi
callq 0x3b9c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: show_msgs(bool)
static void show_msgs(bool is_warn)
{
	printf("\n%s:\n\n", is_warn ? "Warnings" : "Failures");
	for (unsigned i = 0; i < state.num_blocks; i++) {
		if (s_msgs[i][is_warn].empty())
			continue;
		printf("Block %u, %s:\n%s",
		       i, block_name(edid[i * EDID_PAGE_SIZE]).c_str(),
		       s_msgs[i][is_warn].c_str());
	}
	if (s_msgs[EDID_MAX_BLOCKS][is_warn].empty())
		return;
	printf("EDID:\n%s",
	       s_msgs[EDID_MAX_BLOCKS][is_warn].c_str());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x1a42b(%rip), %rax     # 0x20d39
leaq 0x1a42d(%rip), %rsi     # 0x20d42
testl %edi, %edi
cmovneq %rax, %rsi
leaq 0x1a410(%rip), %rdi     # 0x20d32
xorl %eax, %eax
callq 0x3030
cmpl $0x0, 0x33db4(%rip)     # 0x3a6e4
movzbl %bl, %eax
movq %rax, (%rsp)
je 0x69ce
movq (%rsp), %rax
shll $0x5, %eax
leaq 0x34715(%rip), %rcx     # 0x3b060
leaq (%rax,%rcx), %rbp
addq $0x8, %rbp
leaq 0x38856(%rip), %r12     # 0x3f1b0
leaq 0x8(%rsp), %rbx
leaq 0x1a3e5(%rip), %r14     # 0x20d4b
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq $0x0, (%rbp)
je 0x69b8
movl %r13d, %eax
andl $-0x80, %eax
movzbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x5d27
movq 0x8(%rsp), %rdx
movq -0x8(%rbp), %rcx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x3030
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x69b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
incq %r15
movl 0x33d23(%rip), %eax     # 0x3a6e4
subq $-0x80, %r13
addq $0x40, %rbp
cmpq %rax, %r15
jb 0x696c
movq (%rsp), %rcx
shll $0x5, %ecx
leaq 0x34684(%rip), %rax     # 0x3b060
cmpq $0x0, 0x4008(%rcx,%rax)
je 0x6a01
addq %rcx, %rax
addq $0x4000, %rax           # imm = 0x4000
movq (%rax), %rsi
leaq 0x1a362(%rip), %rdi     # 0x20d5c
xorl %eax, %eax
callq 0x3030
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: show_gtf(gtf_parsed_data&)
static void show_gtf(gtf_parsed_data &data)
{
	timings t;

	t = state.calc_gtf_mode(data.w, data.h, data.freq, data.interlaced,
				data.ip_parm, data.overscan, data.secondary,
				data.C, data.M, data.K, data.J);
	calc_ratio(&t);
	state.print_timings("", &t, "GTF", "", true, false);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movl (%rdi), %edx
movl 0x4(%rdi), %ecx
movsd 0x8(%rdi), %xmm0
movzbl 0x31(%rdi), %r8d
movl 0x34(%rdi), %r9d
movzbl 0x30(%rdi), %eax
movzbl 0x32(%rdi), %r10d
movsd 0x10(%rdi), %xmm1
movsd 0x18(%rdi), %xmm2
movsd 0x20(%rdi), %xmm3
movsd 0x28(%rdi), %xmm4
leaq 0x32d64(%rip), %rsi     # 0x3a6e0
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
pushq %r10
pushq %rax
callq 0x1f0f8
addq $0x10, %rsp
movl (%rbx), %esi
movl 0x4(%rbx), %ecx
movl %esi, %edi
testl %ecx, %ecx
je 0x79ab
movl %esi, %eax
movl %ecx, %edx
movl %edx, %edi
xorl %edx, %edx
divl %edi
movl %edi, %eax
testl %edx, %edx
jne 0x799f
testl %edi, %edi
je 0x79c6
leaq 0x18(%rsp), %r8
movl %esi, %eax
xorl %edx, %edx
divl %edi
movl %eax, -0x4(%r8)
movl %ecx, %eax
xorl %edx, %edx
divl %edi
jmp 0x79d5
leaq 0x14(%rsp), %r8
movl $0x0, 0x4(%r8)
xorl %eax, %eax
movl %eax, (%r8)
subq $0x8, %rsp
leaq 0x32cfd(%rip), %rdi     # 0x3a6e0
leaq 0x1cfb7(%rip), %rcx     # 0x249a1
leaq 0x19288(%rip), %rsi     # 0x20c79
leaq 0x14(%rsp), %rdx
movq %rsi, %r8
movl $0x1, %r9d
pushq $0x0
callq 0x3ebe
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: or_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int&)
static void or_str(std::string &s, const std::string &flag, unsigned &num_flags)
{
	if (!num_flags)
		s = flag;
	else if (num_flags % 2 == 0)
		s = s + " | \\\n\t\t" + flag;
	else
		s = s + " | " + flag;
	num_flags++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdx), %eax
testl %eax, %eax
je 0x829f
leaq 0x10(%rsp), %r13
testb $0x1, %al
jne 0x82af
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x8cfe
leaq 0x189ec(%rip), %rsi     # 0x20c72
movq %r12, %rdi
callq 0x3420
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rsp, %rdi
callq 0x30b0
jmp 0x82e6
movq %r14, %rdi
movq %r15, %rsi
callq 0x3140
jmp 0x8368
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x8cfe
leaq 0x189ab(%rip), %rsi     # 0x20c7a
movq %r12, %rdi
callq 0x3420
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rsp, %rdi
callq 0x30b0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x830e
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x8316
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x8352
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8368
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
incl (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x837e
jmp 0x837e
jmp 0x837e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8397
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/rpavlik[P]edid-decode/edid-decode.cpp
// Function: extract_edid_hex(char const*, bool)
static bool extract_edid_hex(const char *s, bool require_two_digits = true)
{
	for (; *s; s++) {
		if (isspace(*s) || strchr(ignore_chars, *s))
			continue;

		if (*s == '0' && tolower(s[1]) == 'x') {
			s++;
			continue;
		}

		/* Read one or two hex digits from the log */
		if (!isxdigit(s[0])) {
			if (state.edid_size && state.edid_size % 128 == 0)
				break;
			return false;
		}
		if (require_two_digits && !isxdigit(s[1])) {
			odd_hex_digits = true;
			return false;
		}
		if (!edid_add_byte(s, isxdigit(s[1])))
			return false;
		if (isxdigit(s[1]))
			s++;
	}
	return state.edid_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb (%rdi), %r12b
testb %r12b, %r12b
je 0x8453
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18d1d(%rip), %r15     # 0x210dc
movsbl %r12b, %ebp
movl %ebp, %edi
callq 0x3040
testl %eax, %eax
jne 0x8443
movl $0x4, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x3280
testq %rax, %rax
jne 0x8443
cmpb $0x30, %r12b
jne 0x83f7
movsbl 0x1(%r14), %edi
callq 0x3350
cmpl $0x78, %eax
je 0x8440
movl %ebp, %edi
callq 0x3090
testl %eax, %eax
je 0x8466
testb %bl, %bl
je 0x8414
movsbl 0x1(%r14), %edi
callq 0x3090
testl %eax, %eax
je 0x847c
movsbl 0x1(%r14), %edi
callq 0x3090
xorl %esi, %esi
testl %eax, %eax
setne %sil
movq %r14, %rdi
callq 0x865c
testb %al, %al
je 0x8483
movsbl 0x1(%r14), %edi
callq 0x3090
testl %eax, %eax
je 0x8443
incq %r14
movb 0x1(%r14), %r12b
incq %r14
testb %r12b, %r12b
jne 0x83bf
cmpl $0x0, 0x32286(%rip)     # 0x3a6e0
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x32274(%rip), %eax     # 0x3a6e0
testl %eax, %eax
setne %cl
testb $0x7f, %al
sete %al
testb %al, %cl
jne 0x8453
jmp 0x8483
movb $0x1, 0x3ed2d(%rip)     # 0x471b0
xorl %eax, %eax
jmp 0x845d