LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/../include/util/dimacs.hpp
// Function: (anonymous namespace)::UnitParser::parse_integer()
int parse_integer(void) {
        int value = 0;
        bool neg = false;
        skip_whitespace();

        if (_current_line[_pos] == '-') {
            neg = true;
            _pos++;
        } else if (_current_line[_pos] == '+') {
            _pos++;
        }

        if (_current_line[_pos] < '0' || _current_line[_pos] > '9') {
            fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", _current_line[_pos]);
            std::exit(3);
        }

        for (; _current_line[_pos] >= '0' && _current_line[_pos] <= '9'; _pos++) {
            value = value * 10 + (_current_line[_pos] - '0');
        }

        return neg ? -value : value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x25f2
movq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rax
movzbl (%rsi,%rax), %ecx
cmpl $0x2d, %ecx
je 0x264a
cmpl $0x2b, %ecx
jne 0x264f
incl %eax
movl %eax, 0x10(%rbx)
cltq
movb (%rsi,%rax), %dl
leal -0x3a(%rdx), %edi
cmpb $-0xa, %dil
jb 0x2697
leaq (%rax,%rsi), %rdi
incq %rdi
incl %eax
xorl %esi, %esi
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x2686
imull $0xa, %esi, %r8d
movzbl %dl, %esi
addl %r8d, %esi
movl %eax, 0x10(%rbx)
movb (%rdi), %dl
incq %rdi
incl %eax
jmp 0x2668
movl %esi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movsbl %dl, %edx
movq 0xa907(%rip), %rax      # 0xcfa8
movq (%rax), %rdi
leaq 0x595f(%rip), %rsi      # 0x800a
xorl %eax, %eax
callq 0x21a0
pushq $0x3
popq %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::new_variable(MyyuraSat::LiftedBoolean, bool)
Variable Solver::new_variable(LiftedBoolean upol, bool dvar) {
    Variable v = _next_variable++;
    
    _watches.init(Literal(v, false));
    _watches.init(Literal(v, true));
    _occur_lit.init(Literal(v, false));
    _occur_lit.init(Literal(v, true));
    _touched.insert(v, true);
    _touched_list.push(v);
    _assigns.insert(v, LIFTED_BOOLEAN_UNDEF);
    _variable_info.insert(v, _VariableInfo(CRAREF_UNDEF, 0));
    _polarity.insert(v, false);
    _seen.insert(v, 0);
    _trail.reserve(v + 1);

    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xf0(%rdi), %r15d
leal 0x1(%r15), %eax
movl %eax, 0xf0(%rdi)
leaq -0x30(%rbp), %rax
movl %r15d, (%rax)
leaq 0x88(%rdi), %r12
leal (%r15,%r15), %r14d
leaq -0x2c(%rbp), %rsi
movl %r14d, (%rsi)
movq %r12, %rdi
callq 0x502c
leal 0x1(,%r15,2), %r13d
leaq -0x2c(%rbp), %rax
movl %r13d, (%rax)
leaq -0x2c(%rbp), %rsi
movq %r12, %rdi
callq 0x502c
leaq 0x1a0(%rbx), %r12
leaq -0x2c(%rbp), %rax
movl %r14d, (%rax)
leaq -0x2c(%rbp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x5068
movl %r13d, (%r14)
leaq -0x2c(%rbp), %rsi
movq %r12, %rdi
callq 0x5068
leaq 0x200(%rbx), %rdi
pushq $0x1
popq %rdx
movl %r15d, %esi
callq 0x50a4
leaq 0x218(%rbx), %rdi
leaq -0x30(%rbp), %r14
movq %r14, %rsi
callq 0x50d4
leaq 0x58(%rbx), %rdi
movl (%r14), %esi
movzbl 0xa9ef(%rip), %edx      # 0xd166
callq 0x510e
leaq 0x70(%rbx), %rdi
movl (%r14), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x513e
leaq 0x170(%rbx), %rdi
movl (%r14), %esi
xorl %edx, %edx
callq 0x50a4
leaq 0x298(%rbx), %rdi
movl (%r14), %esi
xorl %edx, %edx
callq 0x5170
addq $0x28, %rbx
movl (%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x51a0
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::unchecked_enqueue(MyyuraSat::Literal, unsigned int)
void Solver::unchecked_enqueue(Literal p, CRARef from) {
    // for (Variable i = 0; i < n_variables(); i++) {
    //     printf("decision level:%d | %d:%d\n", decision_level(), i, value(i).to_int());
    // }
    // printf("enqueue %d %d:%d %d\n", p.to_int(), p.variable(), value(p).to_int(), value(p.variable()).to_int()); 
    if (value(p) != LIFTED_BOOLEAN_UNDEF) {
        throw std::logic_error("Solver::unchecked_enqueue : p has already get an assignment!");
    }

    _assigns[p.variable()] = LiftedBoolean(!p.sign());
    _variable_info[p.variable()] = _VariableInfo(from, decision_level());
    _trail.push_lazy(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, -0x28(%rbp)
callq 0x4a5c
leaq -0x21(%rbp), %rdi
movb %al, (%rdi)
leaq 0xa793(%rip), %rsi      # 0xd166
callq 0x4aa8
testb %al, %al
jne 0x2a2f
movl %r15d, %r12d
andb $0x1, %r12b
leaq 0x58(%rbx), %rdi
sarl %r15d
movl %r15d, %esi
callq 0x52b2
movb %r12b, (%rax)
leaq 0x70(%rbx), %rdi
movl 0x40(%rbx), %r12d
movl %r15d, %esi
callq 0x4d94
shlq $0x20, %r12
movl %r14d, %ecx
orq %r12, %rcx
movq %rcx, (%rax)
addq $0x28, %rbx
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x530c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x5685(%rip), %rsi      # 0x80c6
movq %rax, %rdi
callq 0x21b0
movq 0xa588(%rip), %rsi      # 0xcfd8
movq 0xa539(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_simplify.cpp
// Function: MyyuraSat::Solver::is_subsumed(unsigned int)
bool Solver::is_subsumed(CRARef cr) {
    Clause& c = _ca[cr];

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

            Clause& cp = _ca[crs[j]];
            if (cr != crs[i] && cp.subsumes(c) == LITERAL_UNDEF) {
                return true;
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
addq $0xf8, %rdi
movq %rdi, -0x50(%rbp)
movl %esi, %r15d
callq 0x5a5e
leaq 0x1a0(%r14), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x30(%rbp)
addq $0x4, %rax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
movq -0x30(%rbp), %rax
movl (%rax), %eax
shrl $0x5, %eax
movq %rax, -0x48(%rbp)
cmpq %rax, %r12
jae 0x2da9
movq -0x38(%rbp), %rax
leaq (%rax,%r12,4), %rsi
movq -0x40(%rbp), %rdi
callq 0x4ce4
movq %rax, %r13
xorl %ebx, %ebx
movslq 0x8(%r13), %rax
cmpq %rax, %rbx
jge 0x2da4
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq %r14, %rdi
callq 0x4d76
testb %al, %al
jne 0x2d9f
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq -0x50(%rbp), %rdi
callq 0x5a5e
movq (%r13), %rcx
cmpl %r15d, (%rcx,%r12,4)
je 0x2d9f
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x55be
cmpl 0xa3bf(%rip), %eax      # 0xd15c
je 0x2da9
incq %rbx
jmp 0x2d55
incq %r12
jmp 0x2d2d
cmpq -0x48(%rbp), %r12
setb %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::attach_clause_watcher(unsigned int)
void Solver::attach_clause_watcher(CRARef cr) {
    const Clause& c = _ca[cr];

    _watches[~c[0]].push(_Watcher(cr, c[1]));
    _watches[~c[1]].push(_Watcher(cr, c[0]));

    // for (int i = 0; i < c.size(); i++) {
    //     _watches[~c[i]].push(_Watcher(cr));
    // }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0xf8, %rdi
callq 0x5a5e
movq %rax, %r15
addq $0x88, %r14
movl 0x4(%rax), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x671e
movl 0x8(%r15), %ecx
leaq -0x28(%rbp), %r12
movl %ebx, (%r12)
movl %ecx, 0x4(%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0x5222
movl 0x8(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x671e
movl 0x4(%r15), %ecx
movl %ebx, (%r12)
movl %ecx, 0x4(%r12)
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x5222
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_simplify.cpp
// Function: MyyuraSat::Solver::attach_clause_occlit(unsigned int, unsigned int)
void Solver::attach_clause_occlit(CRARef cr, CRARef overwrite) {
    Clause& c = _ca[cr];
    // Clause c should not be a learnt clause!

    for (int i = 0; i < c.size(); i++) {
        _occur_lit[c[i]].push(cr);
        touch(c[i]);
        if (overwrite == CRAREF_UNDEF) {
            _added.insert(cr);
        } else {
            _strengthened.insert(cr);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x2c(%rbp), %rax
movl %esi, (%rax)
addq $0xf8, %rdi
callq 0x5a5e
movq %rax, %r13
leaq 0x1a0(%rbx), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
addq $0x4, %r13
leaq 0x260(%rbx), %r14
movq %rbx, %r12
leaq 0x228(%rbx), %rax
cmpl $-0x1, %r15d
cmoveq %rax, %r14
xorl %ebx, %ebx
movq -0x40(%rbp), %rax
movl (%rax), %eax
shrl $0x5, %eax
cmpq %rax, %rbx
jae 0x2eec
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x4ce4
movq %rax, %rdi
leaq -0x2c(%rbp), %r15
movq %r15, %rsi
callq 0x4ba2
movq %r12, %rdi
movq %r13, %rsi
callq 0x55a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x7024
incq %rbx
addq $0x4, %r13
jmp 0x2ea4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::remove_clause(unsigned int)
void Solver::remove_clause(CRARef cr) {
    Clause& c = _ca[cr];
    detach_clause_watcher(cr);

    c.mark(1);
    _ca.free(cr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xf8(%rdi), %r15
movq %r15, %rdi
callq 0x5a5e
movq %rax, %r12
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2f4a
movl (%r12), %eax
andl $-0x4, %eax
incl %eax
movl %eax, (%r12)
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4b7c
nop
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::detach_clause_watcher(unsigned int, bool)
void Solver::detach_clause_watcher(CRARef cr, bool strict) {
    const Clause& c = _ca[cr];

    // strict or lazy detaching
    if (strict) {
        remove(_watches[~c[0]], _Watcher(cr, c[1]));
        remove(_watches[~c[1]], _Watcher(cr, c[0]));
    } else {
        _watches.smudge(~c[0]);
        _watches.smudge(~c[1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
addq $0xf8, %rdi
callq 0x5a5e
movq %rax, %r14
addq $0x88, %rbx
testl %r12d, %r12d
je 0x2fd2
movl 0x4(%r14), %esi
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x671e
movl 0x8(%r14), %ecx
leaq -0x28(%rbp), %r12
movl %r15d, (%r12)
movl %ecx, 0x4(%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0x3725
movl 0x8(%r14), %esi
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x671e
movl 0x4(%r14), %ecx
movl %r15d, (%r12)
movl %ecx, 0x4(%r12)
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x3725
jmp 0x3001
movl 0x4(%r14), %eax
xorl $0x1, %eax
leaq -0x28(%rbp), %r15
movl %eax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x525e
movl 0x8(%r14), %eax
xorl $0x1, %eax
movl %eax, (%r15)
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x525e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::garbage_collect()
void Solver::garbage_collect(void) {
    /**
     * Initialize the next region to a size corresponding to the estimated 
     * utilization degree. This is not precise but should avoid some unnecessary 
     * reallocations for the new region:
     */
    ClauseAllocator to(_ca.size() - _ca.wasted());

    reloc_all(to);
    to.move_to(_ca);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x100(%rdi), %esi
subl 0x108(%rdi), %esi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x4e5c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x300e
addq $0xf8, %rbx
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x4e76
movq -0x30(%rbp), %rdi
callq 0x2160
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/algorithm.hpp
// Function: void MyyuraSat::remove<MyyuraSat::Vector<MyyuraSat::Solver::_Watcher, int>, MyyuraSat::Solver::_Watcher>(MyyuraSat::Vector<MyyuraSat::Solver::_Watcher, int>&, MyyuraSat::Solver::_Watcher const&)
static inline void remove(V& ts, const T& t) {
    int i = 0;
    for (; i < (int)ts.size() && ts[i] != t; i++) {}
    for (; i < (int)ts.size() - 1; i++) { ts[i] = ts[i + 1]; }
    ts.pop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %ecx
movq (%rdi), %rdx
movl (%rsi), %r8d
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
cmpq %rsi, %rax
je 0x3765
cmpl %r8d, (%rdx,%rsi,8)
je 0x374e
incq %rsi
jmp 0x373e
movq %rsi, %rax
jmp 0x3765
movq (%rdi), %rcx
movq 0x8(%rcx,%rax,8), %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
movl 0x8(%rdi), %ecx
decl %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0x3753
popq %rbp
jmp 0x6fc8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %r15
movb 0x99d5(%rip), %bl       # 0xd165
xorl %r12d, %r12d
leaq -0x2a(%rbp), %r13
movl (%r14), %eax
shrl $0x5, %eax
cmpq %rax, %r12
jae 0x37ff
movl 0x4(%r14,%r12,4), %esi
movq %r15, %rdi
callq 0x4a5c
movb %al, -0x2a(%rbp)
movq %r13, %rdi
leaq 0x99a8(%rip), %rsi      # 0xd164
callq 0x4a7e
testb %al, %al
jne 0x37f9
movl 0x4(%r14,%r12,4), %esi
movq %r15, %rdi
callq 0x4a5c
movb %al, -0x29(%rbp)
leaq -0x29(%rbp), %rdi
leaq 0x9986(%rip), %rsi      # 0xd166
callq 0x4a7e
movzbl %bl, %ecx
movzbl 0x9977(%rip), %ebx      # 0xd166
testb %al, %al
cmovel %ecx, %ebx
incq %r12
jmp 0x3797
movb 0x9965(%rip), %bl       # 0xd164
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38c9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x28(%rdi), %rax
movq %rax, -0x30(%rbp)
movslq 0x30(%rdi), %r14
leaq 0x38(%rdi), %rax
movq %rax, -0x38(%rbp)
movslq %esi, %r15
leaq 0x58(%rdi), %r12
movq %rdi, -0x40(%rbp)
leaq 0x170(%rdi), %r13
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r15,4), %rcx
cmpq %rcx, %r14
jle 0x3892
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl -0x4(%rax,%r14,4), %ebx
decq %r14
sarl %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0x52b2
movb 0x98e5(%rip), %cl       # 0xd166
movb %cl, (%rax)
movq %r13, %rdi
movl %ebx, %esi
callq 0x5372
movb $0x0, (%rax)
jmp 0x3850
movq -0x40(%rbp), %rbx
movl %ecx, 0xe8(%rbx)
movl 0x30(%rbx), %esi
subl (%rax,%r15,4), %esi
movq -0x30(%rbp), %rdi
callq 0x4ab6
movl 0x40(%rbx), %esi
subl %r15d, %esi
movq -0x38(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x53cc
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
leaq 0xf8(%rdi), %r15
pushq $-0x2
popq %r13
movq $0x0, -0x38(%rbp)
leaq 0x95aa(%rip), %rbx      # 0xd166
xorl %r12d, %r12d
cmpl 0xf0(%r14), %r12d
jge 0x3c56
movq %r14, %rdi
movl %r12d, %esi
callq 0x556e
movb %al, -0x29(%rbp)
leaq -0x29(%rbp), %rdi
movq %rbx, %rsi
callq 0x4aa8
testb %al, %al
jne 0x3c4e
movq %r13, -0x40(%rbp)
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jge 0x3c32
movq 0x8(%r14), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x5a5e
movl (%rax), %ecx
testb $0x3, %cl
jne 0x3c2d
shrl $0x5, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x3c2d
movl 0x4(%rax,%rdx,4), %esi
sarl %esi
incq %rdx
cmpl %r12d, %esi
jne 0x3c18
incl %ebx
incq %r13
jmp 0x3bf3
movq -0x38(%rbp), %rax
cmpl %eax, %ebx
cmovgl %ebx, %eax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %r13
cmovgl %r12d, %r13d
leaq 0x9518(%rip), %rbx      # 0xd166
incl %r12d
jmp 0x3bbf
cmpl $-0x2, %r13d
jne 0x3c64
movl 0x94fa(%rip), %eax      # 0xd15c
jmp 0x3c9d
addq $0x170, %r14            # imm = 0x170
movq %r14, %rdi
movl %r13d, %esi
callq 0x5372
movb (%rax), %bl
xorb $0x1, %bl
movq %r14, %rdi
movl %r13d, %esi
callq 0x5372
movb %bl, (%rax)
movq %r14, %rdi
movl %r13d, %esi
callq 0x5372
movzbl (%rax), %eax
xorl $0x1, %eax
leal (%rax,%r13,2), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13d
movl %esi, %r12d
movq %rdi, %rbx
movl %esi, -0x34(%rbp)
addq $0xf8, %rdi
callq 0x5a5e
movq %rax, %r14
leaq 0x1a0(%rbx), %r15
testl %r13d, %r13d
je 0x3ed4
xorl %r13d, %r13d
movl (%r14), %eax
shrl $0x5, %eax
cmpq %rax, %r13
jae 0x3f0b
movl 0x4(%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x682a
movl 0x8(%rax), %esi
movq (%rax), %rcx
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x3ea9
cmpl %r12d, (%rcx,%rdi,4)
je 0x3e97
incq %rdi
jmp 0x3e87
movq %rdi, %rdx
jmp 0x3ea9
movl 0x4(%rcx,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
movl 0x8(%rax), %esi
decl %esi
movslq %esi, %rsi
cmpq %rsi, %rdx
jl 0x3e9c
movq %rax, %rdi
callq 0x73fa
movl 0x4(%r14,%r13,4), %eax
movl %eax, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq 0x55a0
incq %r13
jmp 0x3e59
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r12
movl (%r14), %eax
shrl $0x5, %eax
cmpq %rax, %r13
jae 0x3f0b
movl 0x4(%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x682a
movl 0x4(%r14,%r13,4), %eax
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x55a0
incq %r13
jmp 0x3edb
leaq 0x228(%rbx), %rdi
leaq -0x34(%rbp), %r14
movq %r14, %rsi
callq 0x7456
addq $0x260, %rbx            # imm = 0x260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7456
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3fc4
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf8(%rdi), %r15
xorl %r12d, %r12d
leaq -0x29(%rbp), %r13
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x3fb5
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x5a5e
movq %r14, %rdi
movq %rax, %rsi
callq 0x3776
movb %al, -0x29(%rbp)
movq %r13, %rdi
leaq 0x91cc(%rip), %rsi      # 0xd164
callq 0x4a7e
testb %al, %al
je 0x3fb0
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x2efc
incq %r12
jmp 0x3f68
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x4205(%rip), %rsi      # 0x81db
movq %rax, %rdi
callq 0x21b0
movq 0x8ff3(%rip), %rsi      # 0xcfd8
movq 0x8fa4(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rdi, %rbx
addq $0xf8, %rdi
movq %rdi, -0x50(%rbp)
movl %esi, -0x2c(%rbp)
callq 0x5a5e
movq %rax, %r14
movq %rbx, -0x58(%rbp)
leaq 0x1a0(%rbx), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
addq $0x4, %r14
xorl %ebx, %ebx
movq %r14, -0x38(%rbp)
xorl %ecx, %ecx
movq -0x40(%rbp), %r15
movq -0x48(%rbp), %rax
movl (%rax), %eax
shrl $0x5, %eax
movslq %ecx, %r12
cmpq %rax, %rbx
jae 0x409c
movl %ecx, -0x30(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ce4
movl 0x8(%rax), %r13d
movq -0x38(%rbp), %rax
leaq (%rax,%r12,4), %rsi
movq %r15, %rdi
callq 0x4ce4
movl %ebx, %ecx
cmpl 0x8(%rax), %r13d
jl 0x4093
movl -0x30(%rbp), %ecx
incq %rbx
addq $0x4, %r14
jmp 0x4055
movq -0x38(%rbp), %rax
leaq (%rax,%r12,4), %rsi
movq -0x40(%rbp), %rdi
callq 0x4ce4
movq %rax, %r13
xorl %r14d, %r14d
movq -0x58(%rbp), %rbx
movl -0x2c(%rbp), %r15d
movq -0x50(%rbp), %r12
movslq 0x8(%r13), %rax
cmpq %rax, %r14
jge 0x411f
movq (%r13), %rax
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
callq 0x4d76
testb %al, %al
jne 0x411a
movq (%r13), %rax
movl (%rax,%r14,4), %esi
movq %r12, %rdi
callq 0x5a5e
movq (%r13), %rcx
cmpl %r15d, (%rcx,%r14,4)
je 0x411a
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x55be
cmpl 0x9054(%rip), %eax      # 0xd15c
jne 0x411a
movq (%r13), %rax
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
callq 0x2efc
incq %r14
jmp 0x40bf
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5688
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8c26(%rip), %r14      # 0xcf98
leaq 0x3eea(%rip), %rsi      # 0x8263
movq %r14, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x3cac
leaq -0x29(%rbp), %r15
movb %al, (%r15)
leaq 0x3ee5(%rip), %rsi      # 0x8284
movq %r14, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0x8dae(%rip), %rsi      # 0xd164
movq %r15, %rdi
callq 0x4a7e
testb %al, %al
je 0x441e
leaq 0x58(%rbx), %r14
leaq 0x3ed9(%rip), %r13      # 0x82a6
leaq 0x3ed1(%rip), %r15      # 0x82a5
xorl %r12d, %r12d
cmpl 0xf0(%rbx), %r12d
jge 0x4412
movq %r14, %rdi
movl %r12d, %esi
callq 0x52b2
movq %rax, %rdi
leaq 0x8d6f(%rip), %rsi      # 0xd164
callq 0x4a7e
incl %r12d
testb %al, %al
movq %r15, %rdi
cmovneq %r13, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x2030
jmp 0x43d7
leaq 0x40e8(%rip), %rdi      # 0x8501
callq 0x21e0
leaq 0x8d40(%rip), %rsi      # 0xd165
leaq -0x29(%rbp), %rdi
callq 0x4a7e
leaq 0x40ca(%rip), %rdi      # 0x84ff
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/./solver_debug.cpp
// Function: MyyuraSat::Solver::clause_test()
void Solver::clause_test(void) {
    // subsume
    // Vector<Literal> A = {Literal(1, 0), Literal(2, 0), Literal(3, 0)};
    // Vector<Literal> B = {Literal(1, 1), Literal(2, 0)};

    Vector<Literal> A = {Literal(1, 0), Literal(2, 0), Literal(3, 0)};
    Vector<Literal> B = {Literal(1, 0), Literal(2, 0)};

    _ca.extra_clause_field(true);

    CRARef cr1 = _ca.alloc(A, false);
    CRARef cr2 = _ca.alloc(B, false);
    Clause& C1 = _ca[cr1];
    Clause& C2 = _ca[cr2];
    std::cout << C1.subsumes(C2).to_int() << std::endl;
    std::cout << C2.subsumes(C1).to_int() << std::endl;
    std::cout << LITERAL_UNDEF.to_int() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movabsq $0x400000002, %r14      # imm = 0x400000002
leaq -0x28(%rbp), %rsi
movq %r14, (%rsi)
movl $0x6, 0x8(%rsi)
leaq -0x38(%rbp), %rdi
pushq $0x3
popq %rdx
callq 0x56ec
leaq -0x40(%rbp), %rsi
movq %r14, (%rsi)
leaq -0x28(%rbp), %rdi
pushq $0x2
popq %rdx
callq 0x56ec
movb $0x1, 0x110(%rbx)
addq $0xf8, %rbx
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4b20
movl %eax, %r14d
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4b20
movl %eax, %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5a5e
movq %rax, %r14
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5a5e
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x55be
movq 0x8ab9(%rip), %rdi      # 0xcf98
movl %eax, %esi
callq 0x2240
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55be
movq 0x8a98(%rip), %rdi      # 0xcf98
movl %eax, %esi
callq 0x2240
movq %rax, %rdi
callq 0x2090
movl 0x8c47(%rip), %esi      # 0xd15c
movq 0x8a7c(%rip), %rdi      # 0xcf98
callq 0x2240
movq %rax, %rdi
callq 0x2090
leaq -0x28(%rbp), %rdi
callq 0x4a4c
leaq -0x38(%rbp), %rdi
callq 0x4a4c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4555
jmp 0x4555
jmp 0x4555
movq %rax, %rbx
jmp 0x4561
jmp 0x4555
jmp 0x4555
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x4a4c
leaq -0x38(%rbp), %rdi
callq 0x4a4c
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x40, %rsp
movq %rdi, %rbx
movabsq $0x400000002, %r14      # imm = 0x400000002
leaq -0x30(%rbp), %rsi
movq %r14, (%rsi)
movl $0x6, 0x8(%rsi)
leaq -0x40(%rbp), %rdi
pushq $0x3
popq %rdx
callq 0x56ec
leaq -0x20(%rbp), %rsi
movq %r14, (%rsi)
leaq -0x30(%rbp), %rdi
pushq $0x2
popq %rdx
callq 0x56ec
leaq -0x4c(%rbp), %rsi
movq %r14, (%rsi)
movl $0x8, 0x8(%rsi)
leaq -0x20(%rbp), %rdi
pushq $0x3
popq %rdx
callq 0x56ec
pushq $0x5
popq %r14
subl $0x1, %r14d
jb 0x45e7
movq %rbx, %rdi
xorl %edx, %edx
callq 0x26ba
jmp 0x45d5
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4a20
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4a20
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x4a20
movq %rbx, %rdi
callq 0x5732
movq 0x8(%rbx), %rax
movl 0x4(%rax), %esi
movq %rbx, %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x5732
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x5732
leaq -0x20(%rbp), %rdi
callq 0x4a4c
leaq -0x30(%rbp), %rdi
callq 0x4a4c
leaq -0x40(%rbp), %rdi
callq 0x4a4c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x4676
movq %rax, %rbx
jmp 0x467f
jmp 0x466a
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x4a4c
leaq -0x30(%rbp), %rdi
callq 0x4a4c
leaq -0x40(%rbp), %rdi
callq 0x4a4c
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39e6(%rip), %rsi      # 0x82aa
callq 0x2150
movq %rax, %rbx
leaq -0x2d8(%rbp), %r14
movq %r14, %rdi
callq 0x3386
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23dc
leaq -0x2d8(%rbp), %rdi
callq 0x5688
callq 0x20c0
leaq -0x2d8(%rbp), %rdi
callq 0x435a
jmp 0x4905
movq %rax, %rbx
leaq -0x2d8(%rbp), %rdi
callq 0x3600
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5efd
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x5edc
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x501c
incq %r12
addq $0x10, %r15
jmp 0x5ebf
andl $0x0, 0x8(%rbx)
testb %r14b, %r14b
je 0x5ef5
movq (%rbx), %rdi
callq 0x2160
andq $0x0, (%rbx)
andl $0x0, 0xc(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5818
movl %eax, %r13d
movq %r15, %rdi
movl %eax, %esi
callq 0x598a
movq %rax, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x58b2
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_O2/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
leaq 0x18(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x38(%rbx), %rcx
movq 0x30(%rbx), %rax
cmpq %rcx, %r12
jge 0x4c2a
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x662a
cmpb $0x1, (%rax)
jne 0x4c21
movq 0x30(%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x6684
incq %r12
addq $0x4, %r15
jmp 0x4bf4
testq %rax, %rax
je 0x4c33
andl $0x0, 0x38(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5a5e
movq %rax, %r15
testb $0x10, (%rax)
jne 0x4c72
movq %r14, %rdi
movq %r15, %rsi
callq 0x5abc
movl %eax, (%rbx)
orb $0x10, (%r15)
movl %eax, 0x4(%r15)
jmp 0x4c78
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_O2/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::is_locked(MyyuraSat::Clause const&) const
inline bool Solver::is_locked(const Clause& c) const {
    // Working together with Watcher
    return value(c[0]) == LIFTED_BOOLEAN_TRUE
        && reason(c[0].variable()) != CRAREF_UNDEF
        && _ca.lea(reason(c[0].variable())) == &c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %esi
callq 0x4a5c
leaq -0x19(%rbp), %rdi
movb %al, (%rdi)
leaq 0x843d(%rip), %rsi      # 0xd164
callq 0x4a7e
testb %al, %al
je 0x4d68
movl 0x4(%rbx), %esi
sarl %esi
movq %r14, %rdi
callq 0x4cf0
cmpl $-0x1, %eax
je 0x4d68
leaq 0xf8(%r14), %r15
movl 0x4(%rbx), %esi
sarl %esi
movq %r14, %rdi
callq 0x4cf0
movq %r15, %rdi
movl %eax, %esi
callq 0x5b6c
cmpq %rbx, %rax
sete %al
jmp 0x4d6a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x51ee
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 0x51f5
movq %rdi, %rbx
movq (%rdi), %rdi
addl %eax, %ecx
movl %ecx, 0xc(%rbx)
movslq %ecx, %rsi
shlq $0x2, %rsi
callq 0x2220
movq %rax, (%rbx)
testq %rax, %rax
je 0x51f5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20a0
movq 0x7d7c(%rip), %rcx      # 0xcf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x7d8e(%rip), %rsi      # 0xcfa0
movq 0x7d57(%rip), %rdx      # 0xcf70
movq %rax, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movl (%rdi), %ecx
testb $0x4, %cl
jne 0x5644
testb $0x8, %cl
je 0x5644
movl (%rsi), %edx
movl %edx, %eax
andl $0xc, %eax
cmpl $0x8, %eax
jne 0x5644
shrl $0x5, %edx
shrl $0x5, %ecx
cmpl %ecx, %edx
jb 0x55f3
movl 0x4(%rsi,%rdx,4), %eax
notl %eax
testl %eax, 0x4(%rdi,%rcx,4)
je 0x55fe
movl 0x7b67(%rip), %eax      # 0xd160
popq %rbx
popq %r14
popq %rbp
retq
movl 0x7b57(%rip), %r8d      # 0xd15c
xorl %r9d, %r9d
movl %r8d, %eax
cmpq %rcx, %r9
je 0x55f9
xorl %r10d, %r10d
cmpq %r10, %rdx
je 0x55f3
movl 0x4(%rdi,%r9,4), %r11d
movl 0x4(%rsi,%r10,4), %ebx
cmpl %ebx, %r11d
je 0x5639
incq %r10
cmpl %r8d, %eax
jne 0x5613
xorl %r11d, %ebx
cmpl $0x1, %ebx
jne 0x5613
jmp 0x563c
movl %eax, %r11d
incq %r9
movl %r11d, %eax
jmp 0x560b
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x2d64(%rip), %rsi      # 0x83ba
movq %rax, %rdi
callq 0x21b0
movq 0x7973(%rip), %rsi      # 0xcfd8
movq 0x7924(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq 0x784b(%rip), %r14      # 0xcf98
leaq 0x2cd2(%rip), %rsi      # 0x8426
movq %r14, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x2090
leaq 0xf8(%rbx), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
leaq 0x2ce7(%rip), %r13      # 0x8460
movq %rbx, -0x38(%rbp)
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x57ef
movq 0x8(%rbx), %rax
movl (%rax,%r12,4), %esi
movq -0x30(%rbp), %rdi
callq 0x5bca
movq %rax, %r15
movq %r14, %rdi
movl %r12d, %esi
callq 0x2240
movq %rax, %rdi
leaq 0x2caf(%rip), %rsi      # 0x845e
callq 0x2110
xorl %ebx, %ebx
movl (%r15), %eax
shrl $0x5, %eax
cmpq %rax, %rbx
jae 0x57de
movl 0x4(%r15,%rbx,4), %esi
movq %r14, %rdi
callq 0x2240
movq %rax, %rdi
movq %r13, %rsi
callq 0x2110
incq %rbx
jmp 0x57b6
movq %r14, %rdi
callq 0x2090
incq %r12
movq -0x38(%rbp), %rbx
jmp 0x577d
movq 0x77a2(%rip), %rdi      # 0xcf98
leaq 0x2c65(%rip), %rsi      # 0x8462
callq 0x2110
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5843
movl %esi, %ebx
movq %rdi, %r14
movl 0x8(%rdi), %esi
addl %ebx, %esi
callq 0x5910
movl 0x8(%r14), %eax
addl %eax, %ebx
movl %ebx, 0x8(%r14)
jb 0x5873
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x2a57(%rip), %rsi      # 0x82ac
movq %rax, %rdi
callq 0x2260
movq 0x777c(%rip), %rsi      # 0xcfe0
movq 0x774d(%rip), %rdx      # 0xcfb8
movq %rbx, %rdi
callq 0x2230
pushq $0x8
popq %rdi
callq 0x20a0
movq 0x76fe(%rip), %rcx      # 0xcf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x7710(%rip), %rsi      # 0xcfa0
movq 0x76d9(%rip), %rdx      # 0xcf70
movq %rax, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq (%rsi), %r8
xorl %r9d, %r9d
movslq 0x8(%rsi), %r10
cmpq %r10, %r9
jge 0x58f5
movl (%r8,%r9,4), %r10d
movl %r10d, 0x4(%rdi,%r9,4)
incq %r9
jmp 0x58de
testb %dl, %dl
je 0x5907
testb %cl, %cl
je 0x5909
andl $0x7ffffff, %eax        # imm = 0x7FFFFFF
andl $0x0, 0x4(%rdi,%rax,4)
popq %rbp
retq
popq %rbp
jmp 0x59e8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5982
movq %rdi, %rbx
movl %eax, %ecx
cmpl %esi, %ecx
jae 0x596c
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 0x5922
pushq $0x8
popq %rdi
callq 0x20a0
movq 0x7631(%rip), %rcx      # 0xcf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x7643(%rip), %rsi      # 0xcfa0
movq 0x760c(%rip), %rdx      # 0xcf70
movq %rax, %rdi
callq 0x2230
movq (%rbx), %rdi
movl %ecx, %esi
shlq $0x2, %rsi
callq 0x2220
movq %rax, (%rbx)
testq %rax, %rax
je 0x5940
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %eax
testb $0x8, %al
je 0x5a1a
shrl $0x5, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rcx, %rax
je 0x5a11
movb 0x4(%rdi,%rcx,4), %sil
shrb %sil
btsl %esi, %edx
incq %rcx
jmp 0x59fc
movl %edx, 0x4(%rdi,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x2901(%rip), %rsi      # 0x832d
movq %rax, %rdi
callq 0x21b0
movq 0x759d(%rip), %rsi      # 0xcfd8
movq 0x754e(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2250
nop