LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/include/stringimploder.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> StringImploder::operator()<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, char)
std::string operator() (const CONTAINER &container, char const delimiter){
		std::stringstream ss;

		bool first = true;

		for(const auto &s : container){
			if (first){
				first = false;
			}else{
				ss.put(delimiter);
			}

			ss << s;
		}

		return ss.str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10b0
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x16d4
movb $0x1, %al
leaq 0x18(%rsp), %r14
movsbl %bpl, %ebp
testb $0x1, %al
jne 0x16ba
movq %r14, %rdi
movl %ebp, %esi
callq 0x1030
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x1120
addq $0x20, %r15
xorl %eax, %eax
cmpq %r12, %r15
jne 0x16ac
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1140
movq 0x28e8(%rip), %rsi      # 0x3fd0
leaq 0x8(%rsp), %rdi
callq 0x10d0
leaq 0x88(%rsp), %rdi
callq 0x1060
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1714
movq %rax, %rbx
movq 0x28b2(%rip), %rsi      # 0x3fd0
leaq 0x8(%rsp), %rdi
callq 0x10d0
leaq 0x88(%rsp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O3/RasmusFonseca[P]PDBCluster/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
ostream& operator<<(ostream& os, const Matrix& m){
	for (unsigned int i=0; i<m.rows(); ++i) {
		for (unsigned int j=0; j<m.cols(); ++j){
            os << m.get(i,j);
			if(j == (m.cols()-1))
                os << endl;
			else
                os << '\t';
		}
	}
	return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
testl %eax, %eax
je 0x284c
movq %rsi, %r14
movl 0xc(%rsi), %ecx
xorl %ebp, %ebp
leaq 0xf(%rsp), %r15
testl %ecx, %ecx
movl $0x0, %ecx
je 0x2846
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x25c6
movq %rbx, %rdi
callq 0x22c0
movl 0xc(%r14), %eax
decl %eax
cmpl %eax, %r12d
jne 0x2821
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
jmp 0x2836
movb $0x9, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
incl %r12d
movl 0xc(%r14), %ecx
cmpl %ecx, %r12d
jb 0x27d8
movl 0x8(%r14), %eax
incl %ebp
cmpl %eax, %ebp
jb 0x27cc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/RasmusFonseca[P]PDBCluster/main.cpp
// Function: medoidCosts_distSum(std::vector<int, std::allocator<int>>&, Matrix&)
double medoidCosts_distSum(vector<int> &medoids, Matrix &dMat){
	double ret = 0;
	for(unsigned int i=0;i<dMat.cols();i++){
		double min = 1000000000.0;

		for(unsigned int j=0;j<medoids.size();j++){
			int m = medoids[j];
			double d = dMat.get(m,i);
			if( d<min ) min = d;
		}
		ret+=min;
	}
	return ret/dMat.cols();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x25c2
testl %eax, %eax
je 0x33ac
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
movsd 0x2d68(%rip), %xmm0     # 0x60a8
cmpq %rax, 0x8(%r14)
je 0x338a
movl $0x1, %ebp
xorl %ecx, %ecx
movsd 0x2d53(%rip), %xmm1     # 0x60a8
movsd %xmm1, 0x10(%rsp)
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x25c6
minsd 0x10(%rsp), %xmm0
movl %ebp, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
movapd %xmm0, %xmm1
cmpq %rcx, %rdx
ja 0x3355
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %r15d
movq %rbx, %rdi
callq 0x25c2
cmpl %eax, %r15d
jb 0x3335
jmp 0x33b6
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x25c2
movl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/RasmusFonseca[P]PDBCluster/main.cpp
// Function: medoidCosts_maxDistSum(std::vector<int, std::allocator<int>>&, Matrix&)
double medoidCosts_maxDistSum(vector<int> &medoids, Matrix &dMat){
	double maxDists[medoids.size()];
	for(unsigned int i=0;i<medoids.size(); i++) maxDists[i] = 0;

	for(unsigned int i=0;i<dMat.cols();i++){
		double min = 1000000000.0;
		int minMedoid = -1;

		for(unsigned int j=0;j<medoids.size();j++){
			int m = medoids[j];
			double d = dMat.get(m,i);
			if( d<min ) {
				min = d;
				minMedoid = j;
			}
		}
		if(min>maxDists[minMedoid]) maxDists[minMedoid] = min;
	}
	double ret = 0;
	for(unsigned int j=0;j<medoids.size();j++)
		ret+=maxDists[j];
	return ret/medoids.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rcx
movq (%rdi), %rdx
movq %rcx, %rax
subq %rdx, %rax
leaq 0xf(,%rax,2), %rsi
andq $-0x10, %rsi
movq %rsp, %r14
subq %rsi, %r14
movq %r14, %rsp
cmpq %rdx, %rcx
je 0x3433
sarq $0x2, %rax
xorl %ecx, %ecx
movq $0x0, (%r14,%rcx,8)
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x3421
movq %r12, %rdi
callq 0x25c2
testl %eax, %eax
je 0x34f1
xorl %ebx, %ebx
movq %r14, -0x38(%rbp)
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x34c2
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %rbx, -0x30(%rbp)
movq %r12, %rbx
movl $0x1, %r12d
xorl %ecx, %ecx
movsd 0x2c39(%rip), %xmm0     # 0x60a8
movsd %xmm0, -0x40(%rbp)
leal -0x1(%r12), %r14d
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
movq -0x30(%rbp), %rdx
callq 0x25c6
movsd -0x40(%rbp), %xmm1
ucomisd %xmm0, %xmm1
cmoval %r14d, %r13d
minsd %xmm1, %xmm0
movl %r12d, %ecx
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x346f
movslq %r13d, %rax
movq -0x38(%rbp), %r14
movq %rbx, %r12
movq -0x30(%rbp), %rbx
jmp 0x34d1
movq $-0x1, %rax
movsd 0x2bd7(%rip), %xmm0     # 0x60a8
ucomisd (%r14,%rax,8), %xmm0
jbe 0x34df
movsd %xmm0, (%r14,%rax,8)
incl %ebx
movq %r12, %rdi
callq 0x25c2
cmpl %eax, %ebx
jb 0x3449
movq 0x8(%r15), %rcx
movq (%r15), %rdx
movq %rcx, %rax
subq %rdx, %rax
sarq $0x2, %rax
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
je 0x351d
xorl %ecx, %ecx
addsd (%r14,%rcx,8), %xmm0
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x350d
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/RasmusFonseca[P]PDBCluster/main.cpp
// Function: medoidCosts(std::vector<int, std::allocator<int>>&, Matrix&, int)
double medoidCosts(vector<int> &medoids, Matrix &dMat, int clusteringType){
	if(clusteringType==0) return medoidCosts_distSum(medoids, dMat);
	if(clusteringType==1) return medoidCosts_maxDistSum(medoids, dMat);
	if(clusteringType==2) return medoidCosts_maxDist(medoids, dMat);
	cerr<<"Unknown clustering type: "<<clusteringType<<endl;
	exit(-1);
}

// Assembly:
pushq %rbx
cmpl $0x2, %edx
je 0x36ac
movl %edx, %ebx
cmpl $0x1, %edx
je 0x36a6
testl %ebx, %ebx
jne 0x36b2
popq %rbx
jmp 0x3308
popq %rbx
jmp 0x33dd
popq %rbx
jmp 0x3538
movq 0x5937(%rip), %rdi      # 0x8ff0
leaq 0x2a0d(%rip), %rsi      # 0x60cd
callq 0x21d0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2310
movq %rax, %rdi
callq 0x20f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/ekg[P]tsvtools/tsvbootstrap.cpp
// Function: randomsubset(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, unsigned int)
vector<vector<double>* > randomsubset(vector<vector<double> >& lines, unsigned int samplesize) {
    map<int, bool> hits;
    vector<vector<double>* > results;
    if (lines.size() < samplesize) {
        samplesize = lines.size();
    }
    while (results.size() < samplesize) {
        int pos = genrand_int32() % lines.size();
        map<int, bool>::iterator seen = hits.find(pos);
        if (seen == hits.end()) {
            hits[pos] = true;
            results.push_back(&lines.at(pos));
        }
    }
    return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movl $0x0, (%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rbp)
movq %rbp, 0x10(%rbp)
movq %rbp, 0x18(%rbp)
movq %rax, 0x20(%rbp)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x8(%rsi), %r15
subq (%rsi), %r15
sarq $0x3, %r15
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %r15
movl %edx, %eax
cmpq %rax, %r15
cmovael %edx, %r15d
testl %r15d, %r15d
je 0x2c80
movq %rsi, %r14
leaq 0x10(%rsp), %r13
callq 0x2623
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x3, %rcx
imulq %r12, %rcx
xorl %edx, %edx
divq %rcx
movl %edx, 0xc(%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2c26
movq %rbp, %r8
movq %r8, %rax
movq %rdi, %rcx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl %edx, %esi
setl %dil
movq %rcx, %r8
cmovlq %rax, %r8
movq 0x10(%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x2bf4
cmpq %rbp, %r8
je 0x2c26
cmpl %edx, %esi
cmovlq %rax, %rcx
cmpl %edx, 0x20(%rcx)
jle 0x2c6c
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3426
movb $0x1, (%rax)
movslq 0xc(%rsp), %rsi
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x2c9c
leaq (%rsi,%rsi,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3cea
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jb 0x2bca
leaq 0x18(%rsp), %rdi
callq 0x364e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2570(%rip), %rdi      # 0x5213
xorl %eax, %eax
callq 0x2260
jmp 0x2cae
jmp 0x2cae
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2cc5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21e0
leaq 0x18(%rsp), %rdi
callq 0x364e
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27e4
movq (%r14), %rdi
xorl %esi, %esi
callq 0x2150
testl %eax, %eax
js 0x2803
leaq 0x18(%r14), %rsi
leaq 0x8(%r14), %rdx
movq (%r14), %rcx
xorl %ebx, %ebx
xorl %r8d, %r8d
callq 0x280c
testl %eax, %eax
js 0x27da
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 0x1881(%rip), %rdi      # 0x4046
leaq 0x18a4(%rip), %rsi      # 0x4070
movl $0x34, %edx
xorl %eax, %eax
callq 0x2050
jmp 0x27dc
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %ebx
movq 0x37f3(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x180d(%rip), %rsi      # 0x4004
movq %r15, %rdx
xorl %eax, %eax
callq 0x2080
jmp 0x27dc
movl %eax, %ebx
callq 0x22e0
jmp 0x27dc
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x4(%rsp), %r15
movl %ebp, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x2190
movq $0x0, 0x18(%r12)
movl %ebp, 0x20(%r12)
leaq 0x60(%rsp), %r13
cmpb $0x0, 0x28(%rbx)
jne 0x2a46
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x2160
testl %eax, %eax
js 0x2a89
movl $0xb, %ecx
movq %r13, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x28fc
movl %eax, %ebp
testl %eax, %eax
js 0x2a78
movl %ebp, %eax
addq %rax, 0x20(%rsp)
subl %ebp, 0x28(%rsp)
jg 0x2a54
movq %r13, %rdi
callq 0x2240
cmpl $0x0, 0x4(%rsp)
je 0x2a31
jmp 0x2a8f
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_O3/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 0x2e16
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %eax
movq (%rsi), %xmm3
movq (%rdx), %xmm1
movl 0x8(%rsi), %edi
movl 0xc(%rsi), %r10d
movl 0x8(%rdx), %r11d
movl 0xc(%rdx), %ebx
shlq $0x4, %rax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movl $0x1a0, %r8d            # imm = 0x1A0
movl $0x399bb, %r9d          # imm = 0x399BB
addl %r10d, %ebx
addl %edi, %r11d
paddd %xmm1, %xmm3
movq 0x10(%rsi,%rcx), %xmm2
paddd %xmm2, %xmm3
movq 0x10(%rdx,%rcx), %xmm1
paddd %xmm1, %xmm3
movl 0x18(%rsi,%rcx), %edi
movl 0x1c(%rsi,%rcx), %r10d
addl %edi, %r11d
movl 0x18(%rdx,%rcx), %ebp
movd %xmm3, %r12d
movl %r12d, %r13d
pshufd $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
movd %xmm3, %r15d
imull %r15d, %r12d
addl %r12d, %r12d
leal (%r12,%r8), %r14d
xorps %xmm3, %xmm3
cvtsi2ss %r14d, %xmm3
movl 0x1c(%rdx,%rcx), %r14d
addl %ebp, %r11d
addl %r10d, %ebx
addl %r14d, %ebx
shll $0x6, %r11d
imull %r13d, %r13d
shll $0x7, %ebx
subl %r12d, %ebx
addl %r9d, %ebx
xorps %xmm4, %xmm4
cvtsi2ss %ebx, %xmm4
imull %r15d, %r15d
addl %r13d, %r15d
mulss %xmm3, %xmm4
leal (%r15,%r8), %ebx
xorps %xmm3, %xmm3
cvtsi2ss %ebx, %xmm3
subl %r15d, %r11d
addl %r9d, %r11d
xorps %xmm5, %xmm5
cvtsi2ss %r11d, %xmm5
mulss %xmm3, %xmm5
divss %xmm5, %xmm4
addss %xmm4, %xmm0
addq $0x10, %rcx
movl %r14d, %ebx
movl %ebp, %r11d
movdqa %xmm2, %xmm3
cmpq %rcx, %rax
jne 0x2d4b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7cd(%rip), %rsi       # 0x30b9
callq 0x1110
movq %rax, %r14
testq %rax, %rax
je 0x296f
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1180
cmpl $0x70, %eax
je 0x28fb
movl %eax, %r15d
cmpl $0x63, %eax
jne 0x291a
movq %r14, %rdi
callq 0x28c6
jmp 0x2926
movl %r15d, %edi
callq 0x1050
testl %eax, %eax
je 0x292e
cmpl $-0x1, %r15d
jne 0x28fb
jmp 0x2967
movb $0x1, %al
cmpl $0x2d, %r15d
je 0x2963
leal -0x30(%r15), %eax
cmpl $0x9, %eax
ja 0x2961
movq %r14, %rdi
movl %r15d, %esi
callq 0x287c
movl %eax, %esi
negl %esi
testb $0x1, %bpl
cmovel %eax, %esi
movq %rbx, %rdi
callq 0x15ec
xorl %eax, %eax
jmp 0x2963
movl %ebp, %eax
movl %eax, %ebp
jmp 0x2926
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_O3/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 0x6df(%rip), %rdi       # 0x307a
callq 0x1160
leaq 0x714(%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 0x28db
testb %al, %al
je 0x2a5c
cmpl $0x3, %ebp
jl 0x2a27
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 0x2a0c
movl $0x7e2, %edi            # imm = 0x7E2
callq 0x10d0
leaq 0x8(%rsp), %rdi
callq 0x1d36
cmpl $0xa, %eax
jne 0x2a6a
leaq 0x622(%rip), %rdi       # 0x3069
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1040
leaq 0x8(%rsp), %rdi
callq 0x1722
jmp 0x2a78
movl $0x1, %ebx
leaq 0x693(%rip), %rdi       # 0x30fb
jmp 0x2a73
xorl %ebx, %ebx
leaq 0x6a2(%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 0x2a96
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17cc
movq %rbx, %rdi
callq 0x11b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c57e(%rip), %rdi     # 0x2010e
xorl %ebp, %ebp
movl %ebx, %edx
xorl %eax, %eax
callq 0x3030
testq %r14, %r14
je 0x3bb2
xorl %eax, %eax
xorl %ebp, %ebp
addb (%r15,%rax), %bpl
incq %rax
movl %eax, %ecx
cmpq %rcx, %r14
ja 0x3ba4
negb %bpl
cmpb %bpl, %bl
jne 0x3bce
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3310
movzbl %bpl, %ebp
leaq 0x1c54a(%rip), %rdi     # 0x20123
movl %ebp, %esi
xorl %eax, %eax
callq 0x3030
leaq 0x1c54f(%rip), %rsi     # 0x20138
xorl %edi, %edi
movl %ebx, %edx
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x37cc
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %ecx, %ecx
je 0x3c1e
movl %esi, %eax
movl %ecx, %edx
movl %edx, %r8d
xorl %edx, %edx
divl %r8d
movl %r8d, %eax
testl %edx, %edx
jne 0x3c0d
jmp 0x3c25
movl %esi, %r8d
testl %esi, %esi
je 0x3c3f
movl %esi, %eax
xorl %edx, %edx
divl %r8d
movl %eax, 0x8(%rdi)
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
movl $0xc, %ecx
movl %eax, (%rdi,%rcx)
retq
movl $0x0, 0xc(%rdi)
xorl %eax, %eax
movl $0x8, %ecx
jmp 0x3c3b
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cb8
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r14d, %edx
cmpl $0x63, %edx
jbe 0x3cb1
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x3cb6
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x3cb8
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x3c80
addl $-0x3, %eax
jmp 0x3cb8
addl $-0x2, %eax
jmp 0x3cb8
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 0x8a6d
movq (%r15), %rdi
movq 0x8(%r15), %r14
cmpq %r12, %rdi
je 0x3cf9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x1c465(%rip), %rsi     # 0x20165
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 0x8d58
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movdqu 0x3c(%rdi), %xmm0
movdqu 0x3c(%rsi), %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
pxor %xmm1, %xmm1
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %eax
xorl $0xf, %eax
jne 0x3e7b
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x3e7b
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x3e7b
movb 0x18(%rdi), %al
cmpb 0x18(%rsi), %al
jne 0x3e7b
movl 0x10(%rdi), %eax
cmpl 0x10(%rsi), %eax
jne 0x3e7b
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 0x3e77
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 0x3e77
xorl %r14d, %ecx
xorl %r11d, %eax
orl %ecx, %eax
xorl %r10d, %edx
orl %eax, %edx
jne 0x3e7e
cmpl %r12d, %ebp
jne 0x3e7e
cmpl %r15d, %r9d
jne 0x3e7e
cmpl %ebx, -0x8(%rsp)
jne 0x3e7e
movb 0x28(%rsi), %al
cmpb %al, 0x28(%rdi)
jne 0x3e7e
movb 0x38(%rdi), %al
cmpb 0x38(%rsi), %al
jne 0x3e7e
xorl %eax, %eax
jmp 0x3e80
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_O3/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 0x586d
cmpq $0x0, 0x8(%r14)
je 0x58dd
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8ada
leaq 0x1b2f1(%rip), %rsi     # 0x20b1e
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 0x5883
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x588a
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 0x58c6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x58dd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x58eb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5905
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1aaac(%rip), %rsi     # 0x20431
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 0x8d58
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_O3/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 0x5a5d
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 0x5a96
cmpl $0xc6d, %edi            # imm = 0xC6D
jg 0x5ac2
cmpl $0x1a, %edi
je 0x5b02
cmpl $0x44b, %edi            # imm = 0x44B
je 0x5b22
cmpl $0xc03, %edi            # imm = 0xC03
jne 0x5b42
leaq 0x27faa(%rip), %rax     # 0x2da3f
retq
cmpl $0x90848a, %edi         # imm = 0x90848A
jg 0x5ae2
cmpl $0xd046, %edi           # imm = 0xD046
je 0x5b0a
cmpl $0xe047, %edi           # imm = 0xE047
je 0x5b2a
cmpl $0x3a0292, %edi         # imm = 0x3A0292
jne 0x5b42
leaq 0x1a9df(%rip), %rax     # 0x204a0
retq
cmpl $0xc6e, %edi            # imm = 0xC6E
je 0x5b12
cmpl $0x10fa, %edi           # imm = 0x10FA
je 0x5b32
cmpl $0x14b9, %edi           # imm = 0x14B9
jne 0x5b42
leaq 0x1a9ab(%rip), %rax     # 0x2048c
retq
cmpl $0x90848b, %edi         # imm = 0x90848B
je 0x5b1a
cmpl $0xc45dd8, %edi         # imm = 0xC45DD8
je 0x5b3a
cmpl $0xca125c, %edi         # imm = 0xCA125C
jne 0x5b42
leaq 0x1a9b6(%rip), %rax     # 0x204b7
retq
leaq 0x1a96d(%rip), %rax     # 0x20476
retq
leaq 0x1a981(%rip), %rax     # 0x20492
retq
leaq 0x1a968(%rip), %rax     # 0x20481
retq
leaq 0x1a984(%rip), %rax     # 0x204a5
retq
leaq 0x1a951(%rip), %rax     # 0x2047a
retq
leaq 0x1a967(%rip), %rax     # 0x20498
retq
leaq 0x1a94d(%rip), %rax     # 0x20486
retq
leaq 0x1a96b(%rip), %rax     # 0x204ac
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0x5bcc
cmpb %dl, (%rdi)
jne 0x5bcf
movl %esi, %eax
movl $0x1, %esi
movq %rsi, %rcx
cmpq %rsi, %rax
je 0x5bc5
leaq 0x1(%rcx), %rsi
cmpb %dl, (%rdi,%rcx)
je 0x5bb4
cmpq %rax, %rcx
setae %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d2f
movl %r8d, %r14d
movq %rsi, %r15
movl %r8d, %eax
movq %rax, 0x20(%rsp)
leaq 0x1f894(%rip), %rbx     # 0x2549a
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 0x1b14b(%rip), %rdi     # 0x20d72
movq 0x28(%rsp), %rsi
xorl %eax, %eax
callq 0x3030
movl %r14d, 0xc(%rsp)
testl %r14d, %r14d
leaq 0x1b047(%rip), %rax     # 0x20c89
movq %r15, %rbp
leaq 0x1a884(%rip), %r15     # 0x204d0
movq %r13, %r12
je 0x5c8d
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 0x5c60
cmpb $0x0, 0x18(%rsp)
movl 0x14(%rsp), %r14d
movq %rbp, %r15
movq %r12, %r13
je 0x5d13
movq %rbx, %rbp
cmpl %r14d, 0x1c(%rsp)
leaq 0x1f7ea(%rip), %r12     # 0x25498
jae 0x5cc5
movl 0xc(%rsp), %ebx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3030
incl %ebx
cmpl %r14d, %ebx
jb 0x5cb4
leaq 0x1a80b(%rip), %rdi     # 0x204d7
xorl %eax, %eax
callq 0x3030
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x5d06
movl %eax, %ebx
xorl %r12d, %r12d
leal (%r12,%r13), %eax
movzbl (%r15,%rax), %eax
leal -0x20(%rax), %ecx
cmpb $0x5f, %cl
jb 0x5cf6
movl $0x2e, %eax
movzbl %al, %edi
callq 0x3310
incq %r12
cmpq %rbx, %r12
jb 0x5ce0
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 0x5c12
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d3e
leaq 0x10(%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x61a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movq $0x0, 0x38(%r14)
movq 0x30(%r14), %rax
movb $0x0, (%rax)
movl $0xa, %edi
callq 0x3310
movl 0x8(%r14), %esi
testl %esi, %esi
je 0x61ee
cmpb $0x0, (%rbx)
jne 0x61f0
movq 0x18(%r14), %rdx
leaq 0x1a52e(%rip), %rcx     # 0x20706
movl $0x21, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x3390
movl 0x8(%r14), %esi
jmp 0x61f0
xorl %esi, %esi
movq (%r15), %rdx
leaq 0x1a52e(%rip), %rdi     # 0x20728
xorl %eax, %eax
callq 0x3030
movzbl (%rbx), %eax
cmpl $0x3f, %eax
jle 0x622c
cmpl $0x6f, %eax
jg 0x6248
cmpl $0x40, %eax
je 0x62b6
cmpl $0x50, %eax
jne 0x6285
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d574
jmp 0x62db
cmpl $0x2, %eax
je 0x6278
cmpl $0x10, %eax
je 0x62d0
cmpl $0x20, %eax
jne 0x6285
leaq 0x1a4f1(%rip), %rsi     # 0x20737
jmp 0x62ab
cmpl $0x70, %eax
je 0x62c3
cmpl $0xf0, %eax
jne 0x6285
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f84
movl 0x8(%r14), %eax
cmpl $0x1, %eax
je 0x62db
cmpl $0x80, %eax
je 0x62db
leaq 0x1a4f7(%rip), %rsi     # 0x2076d
jmp 0x62ab
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14d46
jmp 0x62db
leaq 0x1f20d(%rip), %rdi     # 0x25499
movq %rbx, %rsi
movl $0x80, %edx
movl $0x1, %ecx
movl $0x10, %r8d
callq 0x5bd2
leaq 0x1a4e4(%rip), %rsi     # 0x2078f
xorl %edi, %edi
xorl %eax, %eax
callq 0x37cc
jmp 0x62db
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1eb8c
jmp 0x62db
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b6e0
jmp 0x62db
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ec60
movq $0x0, 0x38(%r14)
movq 0x30(%r14), %rax
movb $0x0, (%rax)
leaq 0x1a998(%rip), %rdi     # 0x20c89
movl $0x80, %edx
movq %rbx, %rsi
callq 0x3b70
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a452(%rip), %rax     # 0x20d49
leaq 0x1a454(%rip), %rsi     # 0x20d52
testl %edi, %edi
cmovneq %rax, %rsi
leaq 0x1a437(%rip), %rdi     # 0x20d42
xorl %eax, %eax
callq 0x3030
movl 0x33dcc(%rip), %eax     # 0x3a6e4
movl %ebx, %ecx
movq %rcx, (%rsp)
testl %eax, %eax
je 0x69b9
movq (%rsp), %rcx
shll $0x5, %ecx
leaq 0x3472c(%rip), %rdx     # 0x3b060
leaq (%rcx,%rdx), %rbp
addq $0x8, %rbp
leaq 0x3886d(%rip), %r12     # 0x3f1b0
leaq 0x8(%rsp), %rbx
leaq 0x1a40c(%rip), %r14     # 0x20d5b
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq $0x0, (%rbp)
je 0x69a7
movl %r13d, %eax
andl $-0x80, %eax
movzbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x5d3e
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 0x69a1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movl 0x33d3d(%rip), %eax     # 0x3a6e4
incq %r15
movl %eax, %ecx
subq $-0x80, %r13
addq $0x40, %rbp
cmpq %rcx, %r15
jb 0x6955
movq (%rsp), %rcx
shll $0x5, %ecx
leaq 0x34699(%rip), %rax     # 0x3b060
cmpq $0x0, 0x4008(%rcx,%rax)
je 0x69ec
addq %rcx, %rax
addq $0x4000, %rax           # imm = 0x4000
movq (%rax), %rsi
leaq 0x1a387(%rip), %rdi     # 0x20d6c
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_O3/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 0x32f1f(%rip), %rsi     # 0x3a6e0
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
pushq %r10
pushq %rax
callq 0x1ed64
addq $0x10, %rsp
movl (%rbx), %esi
movl 0x4(%rbx), %ecx
testl %ecx, %ecx
je 0x77f0
movl %esi, %eax
movl %ecx, %edx
movl %edx, %edi
xorl %edx, %edx
divl %edi
movl %edi, %eax
testl %edx, %edx
jne 0x77e2
jmp 0x77f6
movl %esi, %edi
testl %esi, %esi
je 0x7842
leaq 0x18(%rsp), %r8
movl %esi, %eax
xorl %edx, %edx
divl %edi
movl %eax, -0x4(%r8)
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movl %eax, (%r8)
subq $0x8, %rsp
leaq 0x32ec7(%rip), %rdi     # 0x3a6e0
leaq 0x1d1d1(%rip), %rcx     # 0x249f1
leaq 0x19462(%rip), %rsi     # 0x20c89
leaq 0x14(%rsp), %rdx
movq %rsi, %r8
movl $0x1, %r9d
pushq $0x0
callq 0x3e8c
addq $0x70, %rsp
popq %rbx
retq
leaq 0x14(%rsp), %r8
movl $0x0, 0x4(%r8)
xorl %eax, %eax
jmp 0x780b
// File: /workspace/github_cpp_makefile_star2_O3/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 0x80d5
leaq 0x10(%rsp), %r13
testb $0x1, %al
jne 0x80e5
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x8ada
leaq 0x18bc6(%rip), %rsi     # 0x20c82
movq %r12, %rdi
callq 0x3420
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rsp, %rdi
callq 0x30b0
jmp 0x811c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3140
jmp 0x819e
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x8ada
leaq 0x18b85(%rip), %rsi     # 0x20c8a
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 0x8144
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x814c
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 0x8188
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x819e
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 0x81b4
jmp 0x81b4
jmp 0x81b4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x81cd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8288
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18ef7(%rip), %r15     # 0x210ec
movsbl %r12b, %ebp
movl %ebp, %edi
callq 0x3040
testl %eax, %eax
jne 0x8278
movl $0x4, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x3280
testq %rax, %rax
jne 0x8278
cmpb $0x30, %r12b
jne 0x822d
movsbl 0x1(%r14), %edi
callq 0x3350
cmpl $0x78, %eax
je 0x8275
movl %ebp, %edi
callq 0x3090
testl %eax, %eax
je 0x829b
movsbl 0x1(%r14), %ebp
testb %bl, %bl
je 0x824c
movl %ebp, %edi
callq 0x3090
testl %eax, %eax
je 0x82b1
movl %ebp, %edi
callq 0x3090
xorl %esi, %esi
testl %eax, %eax
setne %sil
movq %r14, %rdi
callq 0x8456
testb %al, %al
je 0x82b8
movsbl 0x1(%r14), %edi
callq 0x3090
testl %eax, %eax
je 0x8278
incq %r14
movb 0x1(%r14), %r12b
incq %r14
testb %r12b, %r12b
jne 0x81f5
cmpl $0x0, 0x32451(%rip)     # 0x3a6e0
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x3243f(%rip), %eax     # 0x3a6e0
testl %eax, %eax
setne %cl
testb $0x7f, %al
sete %al
testb %al, %cl
jne 0x8288
jmp 0x82b8
movb $0x1, 0x3eef8(%rip)     # 0x471b0
xorl %eax, %eax
jmp 0x8292
// File: /workspace/github_cpp_makefile_star2_O3/rpavlik[P]edid-decode/edid-decode.cpp
// Function: extract_edid_xrandr(char const*)
static bool extract_edid_xrandr(const char *start)
{
	static const char indentation1[] = "                ";
	static const char indentation2[] = "\t\t";
	/* Used to detect that we've gone past the EDID property */
	static const char half_indentation1[] = "        ";
	static const char half_indentation2[] = "\t";
	const char *indentation;
	const char *s;

	for (;;) {
		unsigned j;

		/* Get the next start of the line of EDID hex, assuming spaces for indentation */
		s = strstr(start, indentation = indentation1);
		/* Did we skip the start of another property? */
		if (s && s > strstr(start, half_indentation1))
			break;

		/* If we failed, retry assuming tabs for indentation */
		if (!s) {
			s = strstr(start, indentation = indentation2);
			/* Did we skip the start of another property? */
			if (s && s > strstr(start, half_indentation2))
				break;
		}

		if (!s)
			break;

		start = s + strlen(indentation);

		for (j = 0; j < 16; j++, start += 2) {
			/* Read a %02x from the log */
			if (!isxdigit(start[0]) || !isxdigit(start[1])) {
				if (j)
					break;
				return false;
			}
			if (!edid_add_byte(start))
				return false;
		}
	}
	return state.edid_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x17e0f(%rip), %rbx     # 0x200e0
leaq 0x17e19(%rip), %r14     # 0x200f1
leaq 0x17e15(%rip), %r15     # 0x200f4
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3080
testq %rax, %rax
je 0x830b
movq %rax, %rbp
movq %r12, %rdi
movq %r15, %rsi
callq 0x3080
cmpq %rax, %rbp
ja 0x83a6
movq %rbx, %rdi
jmp 0x8337
movq %r12, %rdi
movq %r14, %rsi
callq 0x3080
testq %rax, %rax
je 0x83a6
movq %rax, %rbp
movq %r12, %rdi
movl $0x9, %esi
callq 0x30e0
cmpq %rax, %rbp
ja 0x83a6
movq %r14, %rdi
callq 0x3110
movq %rax, %r13
addq %rbp, %r13
xorl %ebp, %ebp
movq %r13, %r12
addq %rbp, %r12
movsbl (%r13,%rbp), %edi
callq 0x3090
testl %eax, %eax
je 0x838d
movsbl 0x1(%r13,%rbp), %edi
callq 0x3090
testl %eax, %eax
je 0x838d
movq %r12, %rdi
movl $0x1, %esi
callq 0x8456
testb %al, %al
je 0x8395
addq $0x2, %rbp
cmpl $0x20, %ebp
jne 0x8344
addq %rbp, %r13
movq %r13, %r12
jmp 0x82df
testl %ebp, %ebp
jne 0x82df
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x32333(%rip)     # 0x3a6e0
setne %al
jmp 0x8397