LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::is_satisfied(MyyuraSat::Clause const&) const
LiftedBoolean Solver::is_satisfied(const Clause& c) const {
    LiftedBoolean result = LIFTED_BOOLEAN_FALSE;
    for (int i = 0; i < c.size(); i++) {
        if (value(c[i]) == LIFTED_BOOLEAN_TRUE) {
            return LIFTED_BOOLEAN_TRUE;
        } else if (value(c[i]) == LIFTED_BOOLEAN_UNDEF) {
            result = LIFTED_BOOLEAN_UNDEF;
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb 0x8fa6(%rip), %r12b     # 0xd175
cmpl $0x20, (%rsi)
jae 0x41dc
movl %r12d, %eax
jmp 0x4281
movq %rsi, %rbx
movq %rdi, %r14
addq $0x58, %r14
xorl %r15d, %r15d
movl 0x4(%rbx,%r15,4), %r13d
movl %r13d, %esi
sarl %esi
movq %r14, %rdi
callq 0x6c82
movb (%rax), %cl
andb $0x1, %r13b
xorb %cl, %r13b
movb 0x8f6a(%rip), %al       # 0xd174
xorl %esi, %esi
movl %eax, %edx
andb $0x2, %dl
sete %dil
cmpb %al, %r13b
je 0x421e
xorl %esi, %esi
jmp 0x4221
movb %dil, %sil
andb %cl, %dl
orb %dl, %sil
jne 0x4281
movl 0x4(%rbx,%r15,4), %r13d
movl %r13d, %esi
sarl %esi
movq %r14, %rdi
callq 0x6c82
movb (%rax), %cl
andb $0x1, %r13b
xorb %cl, %r13b
movzbl 0x8f2c(%rip), %eax      # 0xd176
xorl %esi, %esi
movl %eax, %edx
andb $0x2, %dl
sete %dil
cmpb %al, %r13b
je 0x425e
xorl %esi, %esi
jmp 0x4261
movb %dil, %sil
andb %cl, %dl
orb %dl, %sil
movzbl %r12b, %ecx
cmovel %ecx, %eax
incq %r15
movl (%rbx), %ecx
shrl $0x5, %ecx
movl %eax, %r12d
cmpq %rcx, %r15
jb 0x41e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::cancel_until(int)
void Solver::cancel_until(int level) {
    if (decision_level() > level) {
        for (int c = _trail.size() - 1; c >= _trail_lim[level]; c--) {
            Variable x = _trail[c].variable();
            _assigns[x] = LIFTED_BOOLEAN_UNDEF;
            _polarity[x] = false;
        }
        _queue_head = _trail_lim[level];
        _trail.shrink(_trail.size() - _trail_lim[level]);
        _trail_lim.shrink(_trail_lim.size() - level);
    }
}

// Assembly:
cmpl %esi, 0x40(%rdi)
jle 0x4352
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
movslq 0x30(%rbx), %r14
movslq %esi, %r13
movq 0x38(%rbx), %rax
movl (%rax,%r13,4), %ecx
cmpl %ecx, %r14d
jle 0x4320
movq %rdi, -0x30(%rbp)
leaq 0x58(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x170(%rbx), %r12
movq 0x28(%rbx), %rax
movq %r13, %r15
movl -0x4(%rax,%r14,4), %r13d
decq %r14
sarl %r13d
movq -0x38(%rbp), %rdi
movl %r13d, %esi
callq 0x6282
movb 0x8e7a(%rip), %cl       # 0xd176
movb %cl, (%rax)
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %r13
callq 0x6346
movb $0x0, (%rax)
movq 0x38(%rbx), %rax
movslq (%rax,%r15,4), %rcx
cmpq %rcx, %r14
jg 0x42d8
movq -0x30(%rbp), %rdi
leaq 0x38(%rbx), %r15
movl %ecx, 0xe8(%rbx)
movl 0x30(%rbx), %esi
subl (%rax,%r13,4), %esi
callq 0x5bc0
movl 0x40(%rbx), %esi
subl %r13d, %esi
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63a2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::pick_branch_literal()
Literal Solver::pick_branch_literal(void) {
    Variable v = VARIABLE_UNDEF;
    int max_activity = 0;

    for (Variable i = 0; i < n_variables(); i++) {
        if (value(i) != LIFTED_BOOLEAN_UNDEF) { continue; }

        int activity = 0;
        for (int j = 0; j < _clauses.size(); j++) {
            Clause& c = _ca[_clauses[j]];
            if (c.mark()) { continue; }
            
            for (int k = 0; k < c.size(); k++) {
                if (c[k].variable() == i) { 
                    activity++; 
                    break;
                }
            }
        }
        if (activity > max_activity) {
            v = i;
            max_activity = activity;
        }
    }

    if (v != VARIABLE_UNDEF) {
        _polarity[v] = !_polarity[v];
        return _polarity[v] ? Literal(v) : ~Literal(v);
    }

    return LITERAL_UNDEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0xf0(%rdi)
jle 0x47fb
leaq 0x58(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0xf8(%rbx), %r12
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
xorl %r13d, %r13d
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movl %r13d, %esi
callq 0x6c82
movb (%rax), %al
movb 0x8a26(%rip), %cl       # 0xd176
movl %ecx, %edx
andb $0x2, %dl
movl %edx, %esi
andb %al, %sil
xorl %edi, %edi
testb %dl, %dl
sete %dil
cmpb %cl, %al
movl $0x0, %eax
cmovnel %eax, %edi
orb %sil, %dil
je 0x47e9
movq %r15, -0x40(%rbp)
cmpl $0x0, 0x10(%rbx)
jle 0x47d1
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movl (%rax,%r15,4), %esi
movq %r12, %rdi
callq 0x6a4e
movl (%rax), %ecx
cmpq $0x20, %rcx
setb %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x47c3
shrl $0x5, %ecx
xorl %edx, %edx
movl 0x4(%rax,%rdx,4), %esi
sarl %esi
cmpl %r13d, %esi
je 0x47c0
incq %rdx
cmpq %rdx, %rcx
jne 0x47ab
jmp 0x47c3
incl %r14d
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x4781
jmp 0x47d4
xorl %r14d, %r14d
movl -0x2c(%rbp), %eax
cmpl %eax, %r14d
cmovgl %r14d, %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %r15
cmovgl %r13d, %r15d
incl %r13d
cmpl 0xf0(%rbx), %r13d
jl 0x473c
jmp 0x4801
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
cmpl $-0x2, %r15d
jne 0x480f
movl 0x895f(%rip), %eax      # 0xd16c
jmp 0x4858
addq $0x170, %rbx            # imm = 0x170
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6346
movb (%rax), %r14b
xorb $0x1, %r14b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6346
movb %r14b, (%rax)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6346
movq %rax, %rcx
movl %r15d, %edx
addl %r15d, %edx
leal 0x1(,%r15,2), %eax
cmpb $0x0, (%rcx)
cmovnel %edx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_simplify.cpp
// Function: MyyuraSat::Solver::detach_clause_occlit(unsigned int, bool)
void Solver::detach_clause_occlit(CRARef cr, bool strict) {
    const Clause& c = _ca[cr];

    // strict or lazy detaching
    if (strict) {
        for (int i = 0; i < c.size(); i++) {
            remove(_occur_lit[c[i]], cr);
            touch(c[i]);
        }
    } else {
        for (int i = 0; i < c.size(); i++) {
            _occur_lit[c[i]];
            touch(c[i]);
        }
    }

    _added.erase(cr);
    _strengthened.erase(cr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl %esi, -0x2c(%rbp)
movq %rdi, -0x40(%rbp)
addq $0xf8, %rdi
callq 0x6a4e
movq %rax, %r14
movl (%rax), %eax
testl %r15d, %r15d
je 0x4b4c
cmpl $0x20, %eax
jb 0x4bb8
movq -0x40(%rbp), %rax
leaq 0x1a0(%rax), %r15
leaq 0x200(%rax), %r12
leaq 0x218(%rax), %rbx
xorl %r13d, %r13d
movl 0x4(%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x7580
movl 0x8(%rax), %edx
movl $0x0, %ecx
testl %edx, %edx
jle 0x4ad8
movq (%rax), %rsi
movl -0x2c(%rbp), %edi
xorl %ecx, %ecx
cmpl %edi, (%rsi,%rcx,4)
je 0x4ad8
incq %rcx
cmpq %rcx, %rdx
jne 0x4ac9
movl %edx, %ecx
decl %edx
cmpl %edx, %ecx
jge 0x4aff
movq (%rax), %rdx
movl %ecx, %esi
leaq (%rdx,%rsi,4), %rdx
addq $0x4, %rdx
movl (%rdx), %esi
movl %esi, -0x4(%rdx)
movl 0x8(%rax), %esi
decl %esi
addq $0x4, %rdx
incl %ecx
cmpl %ecx, %esi
jg 0x4aeb
movq %rax, %rdi
callq 0x7f9a
movl 0x4(%r14,%r13,4), %esi
sarl %esi
movl %esi, -0x30(%rbp)
movq %r12, %rdi
callq 0x6346
cmpb $0x0, (%rax)
jne 0x4b38
movl -0x30(%rbp), %esi
movq %r12, %rdi
callq 0x6346
movb $0x1, (%rax)
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq 0x60f4
incq %r13
movl (%r14), %eax
shrl $0x5, %eax
cmpq %rax, %r13
jb 0x4aa8
jmp 0x4bb8
cmpl $0x20, %eax
jb 0x4bb8
movq -0x40(%rbp), %rax
leaq 0x1a0(%rax), %r15
leaq 0x200(%rax), %r12
leaq 0x218(%rax), %r13
xorl %ebx, %ebx
movl 0x4(%r14,%rbx,4), %esi
movq %r15, %rdi
callq 0x7580
movl 0x4(%r14,%rbx,4), %esi
sarl %esi
movl %esi, -0x34(%rbp)
movq %r12, %rdi
callq 0x6346
cmpb $0x0, (%rax)
jne 0x4baa
movl -0x34(%rbp), %esi
movq %r12, %rdi
callq 0x6346
movb $0x1, (%rax)
movq %r13, %rdi
leaq -0x34(%rbp), %rsi
callq 0x60f4
incq %rbx
movl (%r14), %eax
shrl $0x5, %eax
cmpq %rax, %rbx
jb 0x4b6c
movq -0x40(%rbp), %rbx
leaq 0x228(%rbx), %rdi
leaq -0x2c(%rbp), %r14
movq %r14, %rsi
callq 0x7ff8
addq $0x260, %rbx            # imm = 0x260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7ff8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_simplify.cpp
// Function: MyyuraSat::Solver::toplevel_simplify_satisfied_clause(MyyuraSat::Vector<unsigned int, int>&)
void Solver::toplevel_simplify_satisfied_clause(Vector<CRARef>& cs) {
    if (decision_level() != 0) {
        throw std::logic_error("Solver::toplevel_simplify_satisfied_clause : we are not in the toplevel!");
    }

    int i, j;
    for (i = j = 0; i < cs.size(); i++) {
        Clause& c = _ca[cs[i]];
        if (is_satisfied(c) == LIFTED_BOOLEAN_TRUE) {
            remove_clause(cs[i]);
        } else {
            // TODO: trim clause
        }
    }

    // cs.shrink(i - j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x40(%rdi)
jne 0x4c88
movq %rsi, %rbx
cmpl $0x0, 0x8(%rsi)
jle 0x4c79
movq %rdi, %r14
leaq 0xf8(%rdi), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x6a4e
movq %r14, %rdi
movq %rax, %rsi
callq 0x41ba
movb 0x8533(%rip), %cl       # 0xd174
movl %ecx, %edx
andb $0x2, %dl
movl %edx, %esi
andb %al, %sil
xorl %edi, %edi
testb %dl, %dl
sete %dil
cmpb %cl, %al
cmovnel %r12d, %edi
orb %sil, %dil
je 0x4c6d
movq (%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0x3324
incq %r13
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jl 0x4c21
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x455b(%rip), %rsi      # 0x91f7
movq %rax, %rdi
callq 0x21d0
movq 0x832d(%rip), %rsi      # 0xcfd8
movq 0x82de(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_simplify.cpp
// Function: MyyuraSat::Solver::subsume0(unsigned int)
void Solver::subsume0(CRARef cr) {
    // TODO : flag to turn off
    Clause& c = _ca[cr];

    int min_i = 0;
    for (int i = 0; i < c.size(); i++) {
        if (_occur_lit[c[i]].size() < _occur_lit[c[min_i]].size()) {
            min_i = i;
        }
    }

    Vector<CRARef>& crs = _occur_lit[c[min_i]];
    for (int i = 0; i < crs.size(); i++) {
        if (is_removed(crs[i])) { continue; }

        Clause& cp = _ca[crs[i]];
        if (cr != crs[i] && c.subsumes(cp) == LITERAL_UNDEF) {
            // _subsumption_removed++;
            remove_clause(crs[i]);
        }
    }
    
    check_garbage();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
addq $0xf8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x6a4e
movq %rax, %r12
xorl %ebx, %ebx
cmpl $0x20, (%rax)
jb 0x4d59
movl %r15d, -0x2c(%rbp)
movq %r14, -0x40(%rbp)
leaq 0x1a0(%r14), %r13
xorl %r14d, %r14d
movl 0x4(%r12,%r14,4), %esi
movq %r13, %rdi
callq 0x7580
movl 0x8(%rax), %r15d
movslq %ebx, %rax
movl 0x4(%r12,%rax,4), %esi
movq %r13, %rdi
callq 0x7580
movl %r14d, %ecx
cmpl 0x8(%rax), %r15d
jl 0x4d3d
movl %ebx, %ecx
incq %r14
movl (%r12), %eax
shrl $0x5, %eax
movl %ecx, %ebx
cmpq %rax, %r14
jb 0x4d11
movslq %ecx, %rbx
movq -0x40(%rbp), %r14
movl -0x2c(%rbp), %r15d
leaq 0x1a0(%r14), %rdi
movl 0x4(%r12,%rbx,4), %esi
callq 0x7580
cmpl $0x0, 0x8(%rax)
jle 0x4dd7
movq %rax, %r13
xorl %ebx, %ebx
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq -0x38(%rbp), %rdi
callq 0x6bc0
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x4dcb
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq -0x38(%rbp), %rdi
callq 0x6a4e
movq (%r13), %rcx
cmpl %r15d, (%rcx,%rbx,4)
je 0x4dcb
movq %r12, %rdi
movq %rax, %rsi
callq 0x64f2
cmpl 0x83b2(%rip), %eax      # 0xd16c
jne 0x4dcb
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq %r14, %rdi
callq 0x3324
incq %rbx
movslq 0x8(%r13), %rax
cmpq %rax, %rbx
jl 0x4d75
movl 0x100(%r14), %eax
movl 0x108(%r14), %ecx
cvtsi2sd %rcx, %xmm0
cvtsi2sd %rax, %xmm1
mulsd 0x2c0(%r14), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4e14
movq (%r14), %rax
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_debug.cpp
// Function: MyyuraSat::Solver::solve_test()
bool Solver::solve_test(void) {
    // std::cout << "ca size: " << _ca.size() << std::endl;
    std::cout << "Start search! ==================" << std::endl;
    LiftedBoolean status = search(100);
    std::cout << "Finished search! ===============" << std::endl;
    if (status == LIFTED_BOOLEAN_TRUE) {
        for (int i = 0; i < n_variables(); i++) {
            if (_assigns[i] == LIFTED_BOOLEAN_TRUE) {
                printf("%d ", i + 1);
            } else {
                printf("-%d ", i + 1);
            }
        }
        printf("SAT\n");
    } else if (status == LIFTED_BOOLEAN_FALSE) {
        printf("UNSAT\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7eda(%rip), %r14      # 0xcf98
leaq 0x41ba(%rip), %rsi      # 0x927f
movl $0x20, %edx
movq %r14, %rdi
callq 0x2150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x4868
movb %al, -0x29(%rbp)
leaq 0x4195(%rip), %rsi      # 0x92a0
movl $0x20, %edx
movq %r14, %rdi
callq 0x2150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movb 0x802f(%rip), %al       # 0xd174
movb -0x29(%rbp), %cl
movl %eax, %edx
andb $0x2, %dl
movl %edx, %esi
andb %cl, %sil
xorl %edi, %edi
testb %dl, %dl
sete %dil
xorl %edx, %edx
cmpb %al, %cl
cmovnel %edx, %edi
orb %sil, %dil
je 0x51e4
cmpl $0x0, 0xf0(%rbx)
jle 0x51d8
leaq 0x58(%rbx), %r14
movl $0x1, %r15d
leaq 0x4141(%rip), %r12      # 0x92c1
leaq 0x413b(%rip), %r13      # 0x92c2
leal -0x1(%r15), %esi
movq %r14, %rdi
callq 0x6282
movb 0x7fda(%rip), %dil      # 0xd174
movb (%rax), %dl
xorl %ecx, %ecx
movl %edi, %eax
andb $0x2, %al
sete %sil
cmpb %dil, %dl
je 0x51af
xorl %ecx, %ecx
jmp 0x51b2
movb %sil, %cl
andb %dl, %al
orb %al, %cl
movq %r12, %rdi
je 0x51be
movq %r13, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x2040
leal 0x1(%r15), %eax
cmpl 0xf0(%rbx), %r15d
movl %eax, %r15d
jl 0x5187
leaq 0x433e(%rip), %rdi      # 0x951d
callq 0x2200
leaq 0x7f8a(%rip), %rsi      # 0xd175
leaq -0x29(%rbp), %rdi
callq 0x5b96
leaq 0x4320(%rip), %rdi      # 0x951b
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_debug.cpp
// Function: MyyuraSat::Solver::garbage_collection_test()
void Solver::garbage_collection_test(void) {
    Vector<Literal> A = {Literal(1, 0), Literal(2, 0), Literal(3, 0)};
    Vector<Literal> B = {Literal(1, 0), Literal(2, 0)};
    Vector<Literal> C = {Literal(1, 0), Literal(2, 0), Literal(4, 0)};

    for (int i = 0; i <= 4; i++) {
        new_variable();
    }
    add_clause(A);
    add_clause(B);
    add_clause(C);

    print_clauses();
    remove_clause(_clauses[1]);
    print_clauses();
    garbage_collect();
    print_clauses();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
movl $0x3, %esi
callq 0x6170
movl $0x3, 0x8(%r14)
movq (%r14), %rax
movabsq $0x400000002, %r14      # imm = 0x400000002
movq %r14, (%rax)
movl $0x6, 0x8(%rax)
leaq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movl $0x2, %esi
callq 0x6170
movl $0x2, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %r14, (%rax)
leaq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movl $0x3, %esi
callq 0x6170
movl $0x3, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %r14, (%rax)
movl $0x8, 0x8(%rax)
movl $0x5, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2864
decl %r14d
jne 0x54ae
leaq 0x2b0(%rbx), %r14
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x6c20
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29d4
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x6c20
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29d4
leaq -0x20(%rbp), %rdi
movq %r14, %rsi
callq 0x6c20
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29d4
movq %rbx, %rdi
callq 0x6688
movq 0x8(%rbx), %rax
movl 0x4(%rax), %esi
movq %rbx, %rdi
callq 0x3324
movq %rbx, %rdi
callq 0x6688
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x6688
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x5556
xorl %ebx, %ebx
movl %ebx, -0x18(%rbp)
callq 0x2180
movq $0x0, -0x20(%rbp)
movl %ebx, -0x14(%rbp)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x5574
xorl %ebx, %ebx
movl %ebx, -0x28(%rbp)
callq 0x2180
movq $0x0, -0x30(%rbp)
movl %ebx, -0x24(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x5592
xorl %ebx, %ebx
movl %ebx, -0x38(%rbp)
callq 0x2180
movq $0x0, -0x40(%rbp)
movl %ebx, -0x34(%rbp)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x55cb
movq %rax, %rbx
jmp 0x55ec
jmp 0x55a7
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x55cb
xorl %r14d, %r14d
movl %r14d, -0x18(%rbp)
callq 0x2180
movq $0x0, -0x20(%rbp)
movl %r14d, -0x14(%rbp)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x55ec
xorl %r14d, %r14d
movl %r14d, -0x28(%rbp)
callq 0x2180
movq $0x0, -0x30(%rbp)
movl %r14d, -0x24(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x560d
xorl %r14d, %r14d
movl %r14d, -0x38(%rbp)
callq 0x2180
movq $0x0, -0x40(%rbp)
movl %r14d, -0x34(%rbp)
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/main.cpp
// Function: main
int main(int argc, char **argv) {
    FILE *fp = fopen(argv[1], "r");
    MyyuraSat::Solver s;
    // s.add_empty_clause();
    parse_dimacs(fp, s);
    s.check_garbage();
    // s.print_clauses();
    int start_time = clock();
    s.solve_test();
    int end_time = clock();
    std::cout << (double)(end_time - start_time) / CLOCKS_PER_SEC << std::endl;

    // s.clause_test();

    // s.garbage_collection_test();

    // s.subsumption_test();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x2d0, %rsp            # imm = 0x2D0
movq 0x8(%rsi), %rdi
leaq 0x387e(%rip), %rsi      # 0x92c6
callq 0x2170
movq %rax, %rbx
leaq -0x2d8(%rbp), %r14
movq %r14, %rdi
callq 0x398e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24dc
movl -0x1d8(%rbp), %eax
movl -0x1d0(%rbp), %ecx
cvtsi2sd %rcx, %xmm0
cvtsi2sd %rax, %xmm1
mulsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5a97
leaq -0x2d8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x20c0
leaq -0x2d8(%rbp), %rdi
callq 0x50a6
jmp 0x5aaa
movq %rax, %rbx
leaq -0x2d8(%rbp), %rdi
callq 0x3d84
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::ClauseAllocator::alloc(MyyuraSat::Vector<MyyuraSat::Literal, int> const&, bool)
CRARef alloc(const Vector<Literal>& ps, bool learnt = false) {
        if (sizeof(Literal) != sizeof(uint32_t) || sizeof(float) != sizeof(uint32_t)) {
            throw;
        }

        bool use_extra = learnt | _extra_clause_field;
        CRARef cid = _ra.alloc(clause_word32size(ps.size(), use_extra));
        new (lea(cid)) Clause(ps, use_extra, learnt);

        return cid;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movb 0x18(%rdi), %al
orb %bl, %al
movzbl %al, %r12d
movl 0x8(%rsi), %eax
leal (%rax,%r12), %esi
incl %esi
callq 0x67ee
movl %eax, %r13d
movq %r15, %rdi
movl %eax, %esi
callq 0x696c
movq %rax, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x688c
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../util/occurence_list.hpp
// Function: MyyuraSat::OccurenceList<MyyuraSat::Literal, MyyuraSat::Solver::_Watcher, MyyuraSat::Vector<MyyuraSat::Solver::_Watcher, int>, MyyuraSat::LiteralIndexDefault>::clean_all()
void clean_all(void) {
        for (int i = 0; i < _dirties.size(); i++) {
            // Dirties may contain duplicates so check here if a variable is already cleaned:
            if (_dirty[_dirties[i]]) { clean(_dirties[i]); }
        }

        _dirties.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
jle 0x5d04
leaq 0x18(%rbx), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x7360
cmpb $0x1, (%rax)
jne 0x5cf4
movq 0x30(%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x73bc
incq %r12
movslq 0x38(%rbx), %rax
addq $0x4, %r15
cmpq %rax, %r12
jl 0x5cd0
cmpq $0x0, 0x30(%rbx)
je 0x5d12
movl $0x0, 0x38(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::ClauseAllocator::reloc(unsigned int&, MyyuraSat::ClauseAllocator&)
void reloc(CRARef& cr, ClauseAllocator& to) {
        Clause& c = operator[](cr);

        if (c.reloced()) { 
            cr = c.relocation();
            return;
        }

        cr = to.alloc(c);
        c.relocate(cr);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rsi), %esi
callq 0x6a4e
movq %rax, %r15
testb $0x10, (%rax)
jne 0x5d52
movq %r14, %rdi
movq %r15, %rsi
callq 0x6aae
movl %eax, (%rbx)
orb $0x10, (%r15)
movl %eax, 0x4(%r15)
jmp 0x5d58
movl 0x4(%r15), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<MyyuraSat::Literal, int>::reserve(int)
void reserve(SizeType min_cap) {
        if (_capacity >= min_cap) return;
        SizeType add = std::max((min_cap - _capacity + 1) & ~1, ((_capacity >> 1) + 2) & ~1);
        // NOTE: grow by approximately 3/2
        const SizeType size_max = std::numeric_limits<SizeType>::max();
        if (((size_max <= std::numeric_limits<int>::max()) && (add > size_max - _capacity))
        ||  (((_data = (T*)std::realloc(_data, (_capacity += add) * sizeof(T))) == NULL))) { throw std::bad_alloc(); }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0xc(%rdi), %eax
cmpl %esi, %eax
jge 0x61be
subl %eax, %esi
incl %esi
andl $-0x2, %esi
movl %eax, %ecx
sarl %ecx
andl $-0x2, %ecx
addl $0x2, %ecx
cmpl %ecx, %esi
cmovgl %esi, %ecx
movl %eax, %edx
xorl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpl %edx, %ecx
jg 0x61c5
movq %rdi, %rbx
movq (%rdi), %rdi
addl %eax, %ecx
movl %ecx, 0xc(%rbx)
movslq %ecx, %rsi
shlq $0x2, %rsi
callq 0x2240
movq %rax, (%rbx)
testq %rax, %rax
je 0x61c5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x8, %edi
callq 0x20a0
movq 0x6daa(%rip), %rcx      # 0xcf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x6dbc(%rip), %rsi      # 0xcfa0
movq 0x6d85(%rip), %rdx      # 0xcf70
movq %rax, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::subsumes(MyyuraSat::Clause const&) const
inline Literal Clause::subsumes(const Clause& other) const {
    if ((_header.learnt || other._header.learnt) ||
        (!_header.has_extra || !other._header.has_extra)) {
        throw std::logic_error("Clause::subsumes(const Clause& other) - learnt clause error or no extra spaces");
    }

    if (other._header.size < _header.size ||
        (_data[_header.size].abst & ~other._data[other._header.size].abst) != 0) {
        return LITERAL_ERROR;
    }

    Literal result = LITERAL_UNDEF;

    for (int i = 0; i < _header.size; i++) {
        // search for _data[i].lit or ~_data[i].lit
        bool is_found = false;
        for (int j = 0; j < other._header.size; j++) {
            if (_data[i].lit == other._data[j].lit) {
                is_found = true;
                break;
            } else if (result == LITERAL_UNDEF && _data[i].lit == ~other._data[j].lit) {
                result = _data[i].lit;
                is_found = true;
                break;
            }
        }

        if (!is_found) { return LITERAL_ERROR; }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
testb $0x4, %al
jne 0x65e0
testb $0x8, %al
je 0x65e0
movl (%rsi), %ecx
movl %ecx, %edx
andl $0xc, %edx
cmpl $0x8, %edx
jne 0x65e0
movl %ecx, %r10d
shrl $0x5, %r10d
movl %eax, %r11d
shrl $0x5, %r11d
cmpl %r11d, %r10d
jb 0x6543
movl 0x4(%rsi,%r10,4), %edx
notl %edx
testl %edx, 0x4(%rdi,%r11,4)
je 0x6558
movl 0x6c27(%rip), %eax      # 0xd170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x6c0e(%rip), %edx      # 0xd16c
cmpl $0x20, %eax
jae 0x6567
movl %edx, %eax
jmp 0x6549
cmpl $0x20, %ecx
setae %r9b
movl 0x6bfb(%rip), %r8d      # 0xd170
movl %r10d, %r10d
movl %r11d, %r11d
xorl %ebx, %ebx
movl %edx, %eax
cmpl $0x20, %ecx
jb 0x6592
movl 0x4(%rdi,%rbx,4), %r15d
movl 0x4(%rsi), %r13d
cmpl %r13d, %r15d
jne 0x65a5
movl %r9d, %r14d
testb $0x1, %r14b
je 0x65d8
incq %rbx
cmpq %r11, %rbx
jne 0x657f
jmp 0x6549
movl $0x1, %r12d
movl %r9d, %r14d
cmpl %edx, %eax
jne 0x65bb
xorl %r15d, %r13d
cmpl $0x1, %r13d
je 0x65d3
cmpq %r10, %r12
setb %r14b
je 0x6595
movl 0x4(%rsi,%r12,4), %r13d
incq %r12
cmpl %r13d, %r15d
jne 0x65ae
jmp 0x6595
movl %r15d, %eax
jmp 0x6595
movl %r8d, %eax
jmp 0x6549
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x2de2(%rip), %rsi      # 0x93d6
movq %rax, %rdi
callq 0x21d0
movq 0x69d5(%rip), %rsi      # 0xcfd8
movq 0x6986(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::print_clauses() const
inline void Solver::print_clauses(void) const {
    std::cout << "print clauses begin: ==================================" << std::endl;
    for (int i = 0; i < _clauses.size(); i++) {
        const Clause& c = _ca[_clauses[i]];
        std::cout << i << " : ";
        for (int j = 0; j < c.size(); j++) {
            std::cout << c[j].to_int() << " ";
        }
        std::cout << std::endl;
    }
    std::cout << "print clauses end: ====================================" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x68f5(%rip), %rbx      # 0xcf98
leaq 0x2d98(%rip), %rsi      # 0x9442
movl $0x37, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
cmpl $0x0, 0x10(%r14)
jle 0x67a4
leaq 0xf8(%r14), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
leaq 0x2d7e(%rip), %r13      # 0x947c
movq %r14, -0x38(%rbp)
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq -0x30(%rbp), %rdi
callq 0x6bc0
movq %rax, %r15
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2260
movl $0x3, %edx
movq %rax, %rdi
leaq 0x2d4a(%rip), %rsi      # 0x947a
callq 0x2150
cmpl $0x20, (%r15)
jb 0x6769
xorl %r14d, %r14d
movl 0x4(%r15,%r14,4), %esi
movq %rbx, %rdi
callq 0x2260
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
incq %r14
movl (%r15), %eax
shrl $0x5, %eax
cmpq %rax, %r14
jb 0x673e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
incq %r12
movq -0x38(%rbp), %r14
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jl 0x6702
leaq 0x2cd3(%rip), %rsi      # 0x947e
movl $0x37, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/alloc.hpp
// Function: MyyuraSat::RegionAllocator<unsigned int>::alloc(int)
RARef alloc(int size) {
        if (size <= 0) {
            throw std::invalid_argument("RegionAllocator<T>::alloc(int size) : the argument size must be greater than 0");
        }

        reserve(_size + size);

        uint32_t prev_size = _size;
        _size += size;

        // Handle overflow
        if (_size < prev_size) { throw std::bad_alloc(); }

        return prev_size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x6819
movl %esi, %ebx
movq %rdi, %r14
movl 0x8(%rdi), %esi
addl %ebx, %esi
callq 0x68f0
movl 0x8(%r14), %eax
addl %eax, %ebx
movl %ebx, 0x8(%r14)
jb 0x684b
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x2a9b(%rip), %rsi      # 0x92c8
movq %rax, %rdi
callq 0x2280
movq 0x67a4(%rip), %rsi      # 0xcfe0
movq 0x6775(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x2250
movl $0x8, %edi
callq 0x20a0
movq 0x6724(%rip), %rcx      # 0xcf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x6736(%rip), %rsi      # 0xcfa0
movq 0x66ff(%rip), %rdx      # 0xcf70
movq %rax, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::Clause(MyyuraSat::Vector<MyyuraSat::Literal, int> const&, bool, bool)
Clause(const Vector<Literal>& ps, bool use_extra, bool learnt) {
        _header.mark = 0;
        _header.learnt = learnt;
        _header.has_extra = use_extra;
        _header.reloced = 0;
        _header.size = ps.size();

        for (int i = 0; i < ps.size(); i++) {
            _data[i].lit = ps[i];
        }

        if (_header.has_extra) {
            if (_header.learnt) {
                _data[_header.size].act = 0;
            } else {
                calc_abstraction();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
andl $-0x20, %eax
leal (%rax,%rdx,8), %eax
leal (%rax,%rcx,4), %eax
movl %eax, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, %r8d
shll $0x5, %r8d
leal (%r8,%rdx,8), %r8d
leal (%r8,%rcx,4), %r8d
movl %r8d, (%rdi)
cmpl $0x0, 0x8(%rsi)
jle 0x68d3
movq (%rsi), %r8
xorl %r9d, %r9d
movl (%r8,%r9,4), %r10d
movl %r10d, 0x4(%rdi,%r9,4)
incq %r9
movslq 0x8(%rsi), %r10
cmpq %r10, %r9
jl 0x68be
testb %dl, %dl
je 0x68e8
testb %cl, %cl
je 0x68ea
andl $0x7ffffff, %eax        # imm = 0x7FFFFFF
movl $0x0, 0x4(%rdi,%rax,4)
popq %rbp
retq
popq %rbp
jmp 0x69cc
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/alloc.hpp
// Function: MyyuraSat::RegionAllocator<unsigned int>::reserve(unsigned int)
void reserve(uint32_t min_cap) {
        if (_capacity >= min_cap) { return; }

        uint32_t prev_cap = _capacity;
        for (; _capacity < min_cap;) {
            /**
             * NOTE: Multiply by a factor (13/8) without causing overflow, then 
             * add 2 and make the result even by clearing the least significant 
             * bit. The resulting sequence of capacities is carefully chosen to 
             * hit a maximum capacity that is close to the '2^32-1' limit when
             * using 'uint32_t' as indices so that as much as possible of this 
             * space can be used.
             */
            uint32_t delta = ((_capacity >> 1) + (_capacity >> 3) + 2) & ~1;
            _capacity += delta;

            if (_capacity <= prev_cap) {
                throw std::bad_alloc();
            }
        }

        _memory = (T *)std::realloc(_memory, UNIT_SIZE * _capacity);
        if (_memory == NULL) { throw std::bad_alloc(); }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0xc(%rdi), %eax
cmpl %esi, %eax
jae 0x6965
movq %rdi, %rbx
movl 0xc(%rdi), %ecx
cmpl %esi, %ecx
jae 0x694f
movl %ecx, %edx
shrl %edx
movl %ecx, %edi
shrl $0x3, %edi
addl %edx, %edi
andl $-0x2, %edi
addl %edi, %ecx
addl $0x2, %ecx
movl %ecx, 0xc(%rbx)
cmpl %eax, %ecx
ja 0x6903
movl $0x8, %edi
callq 0x20a0
movq 0x664e(%rip), %rcx      # 0xcf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x6660(%rip), %rsi      # 0xcfa0
movq 0x6629(%rip), %rdx      # 0xcf70
movq %rax, %rdi
callq 0x2250
movq (%rbx), %rdi
movl %ecx, %esi
shlq $0x2, %rsi
callq 0x2240
movq %rax, (%rbx)
testq %rax, %rax
je 0x6921
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::calc_abstraction()
void calc_abstraction(void) {
        if (!_header.has_extra) {
            throw std::logic_error("Clause::calc_abstraction : has_extra is false");
        }

        uint32_t abstraction = 0;
        for (int i = 0; i < size(); i++) {
            abstraction |= _data[i].lit.abstraction();
        }
        _data[_header.size].abst = abstraction;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl (%rdi), %edx
testb $0x8, %dl
je 0x6a08
movl %edx, %eax
shrl $0x5, %eax
xorl %ecx, %ecx
cmpl $0x20, %edx
jb 0x69fd
xorl %edx, %edx
xorl %ecx, %ecx
movb 0x4(%rdi,%rdx,4), %sil
shrb %sil
btsl %esi, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x69ea
movl %eax, %eax
movl %ecx, 0x4(%rdi,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x292d(%rip), %rsi      # 0x9349
movq %rax, %rdi
callq 0x21d0
movq 0x65ad(%rip), %rsi      # 0xcfd8
movq 0x655e(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::ClauseAllocator::alloc(MyyuraSat::Clause const&)
CRARef alloc(const Clause& from) {
        bool use_extra = from.learnt() | _extra_clause_field;
        CRARef cid = _ra.alloc(clause_word32size(from.size(), use_extra));
        new (lea(cid)) Clause(from, use_extra);
        return cid;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
movzbl 0x18(%rdi), %ecx
movl %eax, %r15d
shrl $0x2, %r15d
andl $0x1, %r15d
orl %ecx, %r15d
shrl $0x5, %eax
leal (%rax,%r15), %esi
incl %esi
callq 0x67ee
movl %eax, %r12d
movq %r14, %rdi
movl %eax, %esi
callq 0x696c
movq %rax, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x6b08
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::Clause(MyyuraSat::Clause const&, bool)
Clause(const Clause& from, bool use_extra) {
        _header = from._header;
        _header.has_extra = use_extra;
        // NOTE: the copied clause may lose the extra field.

        for (int i = 0; i < from.size(); i++) {
            _data[i].lit = from[i];
        }

        if (_header.has_extra) {
            if (_header.learnt) {
                _data[_header.size].act = from._data[_header.size].act;
            } else {
                _data[_header.size].abst = from._data[_header.size].abst;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x9, %ecx
leal (%rcx,%rdx,8), %ecx
movl %ecx, (%rdi)
cmpl $0x20, (%rsi)
jb 0x6b38
xorl %ecx, %ecx
movl 0x4(%rsi,%rcx,4), %r8d
movl %r8d, 0x4(%rdi,%rcx,4)
incq %rcx
movl (%rsi), %r8d
shrl $0x5, %r8d
cmpq %r8, %rcx
jb 0x6b1f
testb %dl, %dl
je 0x6b5e
movl %eax, %ecx
shrl $0x5, %ecx
shll $0x2, %ecx
testb $0x4, %al
jne 0x6b52
movl 0x4(%rsi,%rcx), %eax
movl %eax, 0x4(%rdi,%rcx)
jmp 0x6b5e
movss 0x4(%rsi,%rcx), %xmm0
movss %xmm0, 0x4(%rdi,%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<MyyuraSat::Vector<unsigned int, int>, int>::clear(bool)
void clear(bool dealloc = false) {
        if (_data != NULL) {
            for (SizeType i = 0; i < _size; i++) { _data[i].~T(); }
            _size = 0;
            if (dealloc) {
                free(_data);
                _data = NULL;
                _capacity = 0;
            }
        }
    }

// Assembly:
cmpq $0x0, (%rdi)
je 0x6e05
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
cmpl $0x0, 0x8(%rdi)
jle 0x6dd4
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %r14
movq (%r14,%r12), %rdi
testq %rdi, %rdi
je 0x6dc4
movl %r15d, 0x8(%r14,%r12)
callq 0x2180
movq $0x0, (%r14,%r12)
movl %r15d, 0xc(%r14,%r12)
incq %r13
movslq 0x8(%rbx), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x6da1
movl $0x0, 0x8(%rbx)
cmpb $0x0, -0x2c(%rbp)
je 0x6df7
movq (%rbx), %rdi
callq 0x2180
movq $0x0, (%rbx)
movl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::shrink(int)
void shrink (int i) {
        if (i > size()) {
            throw std::out_of_range("Clause::shrink : out of size");
        }

        if (_header.has_extra) {
            _data[_header.size - i] = _data[_header.size];
        }

        _header.size -= i;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl (%rdi), %edx
movl %edx, %eax
shrl $0x5, %eax
movl %eax, %ecx
subl %esi, %ecx
jl 0x6f34
testb $0x8, %dl
je 0x6f1c
movslq %ecx, %rcx
movl 0x4(%rdi,%rax,4), %eax
movl %eax, 0x4(%rdi,%rcx,4)
movl (%rdi), %eax
shll $0x5, %esi
movl %eax, %ecx
subl %esi, %ecx
andl $-0x20, %ecx
andl $0x1f, %eax
orl %ecx, %eax
movl %eax, (%rdi)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x24dd(%rip), %rsi      # 0x9425
movq %rax, %rdi
callq 0x2050
movq 0x6071(%rip), %rsi      # 0xcfc8
movq 0x6052(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../util/occurence_list.hpp
// Function: MyyuraSat::OccurenceList<MyyuraSat::Literal, unsigned int, MyyuraSat::Vector<unsigned int, int>, MyyuraSat::LiteralIndexDefault>::clean(MyyuraSat::Literal const&)
void clean(const K& idx) {
        Vec& vec = _occs[idx];
        int i, j;
        for (i = j = 0; i < vec.size(); i++) {
            if (!_deleted(vec[i])) { vec[j++] = vec[i]; }
        }

        vec.shrink(i - j);
        _dirty[idx] = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x7580
movq %rax, %r15
cmpl $0x0, 0x8(%rax)
jle 0x754b
movq %r14, -0x30(%rbp)
leaq 0x40(%rbx), %rax
movq %rax, -0x38(%rbp)
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq $0x0, 0x50(%rbx)
je 0x757a
movq (%r15), %rsi
addq %r14, %rsi
movq -0x38(%rbp), %rdi
callq *0x58(%rbx)
testb %al, %al
jne 0x7532
movq (%r15), %rax
movl (%rax,%r14), %ecx
movslq %r13d, %rdx
incl %r13d
movl %ecx, (%rax,%rdx,4)
incq %r12
movslq 0x8(%r15), %rax
addq $0x4, %r14
cmpq %rax, %r12
jl 0x750a
subl %r13d, %r12d
movq -0x30(%rbp), %r14
jmp 0x754e
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x5e2e
addq $0x18, %rbx
movl (%r14), %esi
movq %rbx, %rdi
callq 0x7360
movb $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<MyyuraSat::Vector<MyyuraSat::Solver::_Watcher, int>, int>::grow_to(int)
void grow_to(SizeType size) {
        if (_size >= size) { return; }
        reserve(size);
        for (SizeType i = _size; i < size; i++) { new (&_data[i]) T(); }
        _size = size;
    }

// Assembly:
cmpl %esi, 0x8(%rdi)
jge 0x76ef
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x76f0
movslq 0x8(%r14), %rax
cmpl %ebx, %eax
jge 0x76e7
movslq %ebx, %rcx
subq %rax, %rcx
shlq $0x4, %rax
xorps %xmm0, %xmm0
movq (%r14), %rdx
movups %xmm0, (%rdx,%rax)
addq $0x10, %rax
decq %rcx
jne 0x76d7
movl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<bool, int>::grow_to(int, bool const&)
void grow_to(SizeType size, const T& pad) {
        if (_size >= size) { return; }
        reserve(size);
        for (SizeType i = _size; i < size; i++) { _data[i] = pad; }
        _size = size;
    }

// Assembly:
cmpl %esi, 0x8(%rdi)
jge 0x77bb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x77bc
movslq 0x8(%r15), %rax
cmpl %ebx, %eax
jge 0x77ad
movq (%r15), %rcx
movslq %ebx, %rdx
movb (%r14), %sil
movb %sil, (%rcx,%rax)
incq %rax
cmpq %rax, %rdx
jne 0x779e
movl %ebx, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/willprice[P]parallel-cpp-workshop/mapreduce.cpp
// Function: main
int main(int argc, char **argv) {
  auto a = std::vector<int>({1, 2, 3, 4, 5});
  auto b = std::vector<int>({6, 7, 8, 9, 10});
  auto result = mapReduce(std::multiplies<int>(),
                          std::plus<int>(), a, b);
  std::cout << result << std::endl;
  return 0;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movups 0xcec(%rip), %xmm0      # 0x3004
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movl $0x5, %edx
movq %rbx, %rcx
callq 0x2424
movups 0xcd3(%rip), %xmm0      # 0x3018
movaps %xmm0, (%rbx)
movl $0xa, 0x10(%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x5, %edx
callq 0x2424
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2469
movq 0x2c5a(%rip), %rdi      # 0x4fd8
movl %eax, %esi
callq 0x2180
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23c6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2100
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x23dd
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2100
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x2404
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2404
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2100
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x241b
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2100
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/adler32.c
// Function: adler32
unsigned int adler32(char *buf, unsigned int length)
{
	unsigned short a = 1;
	unsigned short b = 0;

	for(int i = 0; i < length; i++)
	{
	        a = (a + buf[i]) % MOD_ADLER;
	        b = (b + a) % MOD_ADLER;
	}

	return (b << 16) | a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
je 0x1240
movl %esi, %ecx
movl $0x1, %eax
xorl %edx, %edx
movl $0xffff, %esi           # imm = 0xFFFF
movl $0x80078071, %r8d       # imm = 0x80078071
xorl %r9d, %r9d
andl %esi, %eax
movsbl (%rdi,%rdx), %r10d
addl %eax, %r10d
movslq %r10d, %rax
imulq $-0x7ff87f8f, %rax, %r10 # imm = 0x80078071
shrq $0x20, %r10
addl %eax, %r10d
movl %r10d, %r11d
shrl $0x1f, %r11d
sarl $0xf, %r10d
addl %r11d, %r10d
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %eax
movl %eax, %r10d
andl %esi, %r10d
addl %r9d, %r10d
movl %r10d, %r9d
imulq %r8, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %r9d
incq %rdx
cmpq %rdx, %rcx
jne 0x11db
shll $0x10, %r9d
movzwl %ax, %eax
orl %r9d, %eax
jmp 0x1245
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/adler32.c
// Function: adler32_roll
unsigned int adler32_roll(unsigned int adler, unsigned char buf_in, unsigned char buf_out, unsigned int block_size)
{
	unsigned short a = adler & 0xFFFF;
	unsigned short b = adler >> 16;

	int a32 = (a + buf_in - buf_out);
	while (a32 < 0)
	{
		a32 += MOD_ADLER;
	}
	a = a32 % MOD_ADLER;

	int b32 = b + a - 1 - block_size * buf_out;
	while (b32 < 0)
	{
		b32 += MOD_ADLER;
	}
	b = b32 % MOD_ADLER;

	return (b << 16) | a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl %di, %eax
shrl $0x10, %edi
notl %ecx
imull %edx, %ecx
addl %ecx, %edi
leal (%rax,%rsi), %ecx
movl %ecx, %r9d
subl %edx, %r9d
xorl %r10d, %r10d
testl %r9d, %r9d
cmovlel %r10d, %r9d
addl %edx, %r9d
xorl %r11d, %r11d
cmpl %ecx, %r9d
setne %r11b
subl %r11d, %r9d
subl %ecx, %r9d
movl $0x80078071, %r8d       # imm = 0x80078071
imulq %r8, %r9
shrq $0x2f, %r9
addl %r11d, %r9d
imull $0xfff1, %r9d, %r9d     # imm = 0xFFF1
addl %edi, %esi
addl %eax, %esi
addl %r9d, %esi
addl %r9d, %ecx
movl %ecx, %r9d
subl %edx, %r9d
movq %r9, %rax
imulq %r8, %rax
shrq $0x2f, %rax
imull $0xfff1, %eax, %edx     # imm = 0xFFF1
subl %edx, %r9d
movl %edx, %eax
notl %eax
leal (%rsi,%rax), %r11d
testl %r11d, %r11d
cmovgl %r11d, %r10d
addl %r10d, %edx
incl %edx
xorl %r10d, %r10d
cmpl %esi, %edx
setne %r10b
addl %r10d, %esi
subl %esi, %edx
imulq %r8, %rdx
shrq $0x2f, %rdx
addl %r10d, %edx
imull $0xfff1, %edx, %edx     # imm = 0xFFF1
addl %edi, %edx
addl %ecx, %eax
addl %edx, %eax
imulq %rax, %r8
shrq $0x2f, %r8
imull $0xfff1, %r8d, %ecx     # imm = 0xFFF1
subl %ecx, %eax
shll $0x10, %eax
orl %r9d, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/adler32.c
// Function: main
int main(int argc, char** argv)
{
	if (argc < 2)
	{
		printf("Usage: adler32 file\r\n");
		return -1;
	}

	unsigned int length = 0;
	char *data = get_file(argv[1], &length);
	if (data == NULL)
	{
		printf("Unable to open %s\r\n", argv[1]);
	}

	
	unsigned int checksum = 0;
	checksum = adler32(data, length);
	printf("%08X\r\n", checksum);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edi
jg 0x13e4
leaq 0xc4d(%rip), %rdi       # 0x2022
callq 0x1040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x14a6
movq %rsi, %r14
leaq -0x14(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x8(%r14), %rdi
callq 0x130c
movq %rax, %rbx
testq %rax, %rax
jne 0x1414
movq 0x8(%r14), %rsi
leaq 0xbfa(%rip), %rdi       # 0x2007
xorl %eax, %eax
callq 0x1070
movl -0x14(%rbp), %eax
testq %rax, %rax
je 0x1491
movl $0x1, %ecx
xorl %edx, %edx
movl $0xffff, %edi           # imm = 0xFFFF
movl $0x80078071, %r8d       # imm = 0x80078071
xorl %esi, %esi
andl %edi, %ecx
movsbl (%rbx,%rdx), %r9d
addl %ecx, %r9d
movslq %r9d, %rcx
imulq $-0x7ff87f8f, %rcx, %r9 # imm = 0x80078071
shrq $0x20, %r9
addl %ecx, %r9d
movl %r9d, %r10d
shrl $0x1f, %r10d
sarl $0xf, %r9d
addl %r10d, %r9d
imull $0xfff1, %r9d, %r9d     # imm = 0xFFF1
subl %r9d, %ecx
movl %ecx, %r9d
andl %edi, %r9d
addl %r9d, %esi
movq %rsi, %r10
imulq %r8, %r10
shrq $0x2f, %r10
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %esi
incq %rdx
cmpq %rdx, %rax
jne 0x1430
shll $0x10, %esi
orl %r9d, %esi
jmp 0x1496
movl $0x1, %esi
leaq 0xb7e(%rip), %rdi       # 0x201b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1070
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq