LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: main
int main() {
  try {
    doMain();
  }
  catch(...) {
    std::cout << std::endl;
    std::cout << "caught error!" << std::endl;
    std::cout << "*** TEST FAILED ***" << std::endl;
  }

  return 0;
}

// Assembly:
pushq %rbx
callq 0x6fed0
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rdi
callq 0x20f0
movq 0x43fed(%rip), %rdi     # 0xb3fd8
callq 0x2110
movq 0x43fe1(%rip), %rdi     # 0xb3fd8
leaq 0x2f045(%rip), %rsi     # 0x9f043
movl $0xd, %edx
callq 0x2280
movq 0x43fc9(%rip), %rdi     # 0xb3fd8
callq 0x2110
movq 0x43fbd(%rip), %rdi     # 0xb3fd8
leaq 0x2f02f(%rip), %rsi     # 0x9f051
movl $0x13, %edx
callq 0x2280
movq 0x43fa5(%rip), %rdi     # 0xb3fd8
callq 0x2110
callq 0x2350
jmp 0x6ffd8
movq %rax, %rbx
callq 0x2350
movq %rbx, %rdi
callq 0x23c0
movq %rax, %rdi
callq 0x14d36
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::EPollSelector::wait(int)
WaitStatus EPollSelector::wait(int const timeout){
	if (epollFD_ < 0)
		return WaitStatus::ERROR;

	statusCount_ = epoll_wait(epollFD_, statusData_.data(), (int) statusData_.size(), timeout);

	if (statusCount_ < 0)
		return WaitStatus::ERROR;

	if (statusCount_ == 0)
		return WaitStatus::NONE;

	return WaitStatus::OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %edi
movl $0x2, %ebx
testl %edi, %edi
js 0x3470
movl %esi, %ecx
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
subq %rsi, %rax
shrq $0x2, %rax
imull $0xaaaaaaab, %eax, %edx # imm = 0xAAAAAAAB
callq 0x2110
movl %eax, 0x20(%r14)
testl %eax, %eax
js 0x3470
sete %al
movzbl %al, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::EPollSelector::getFDStatus(unsigned int) const
FDResult EPollSelector::getFDStatus(uint32_t const no) const{
	if (no < (uint32_t) statusCount_){
		const epoll_event &ev = statusData_[no];

		int const fd = ev.data.fd;

		if (ev.events & EPOLLERR)
			return { fd, FDStatus::ERROR };

		if ((ev.events & EPOLLIN) || (ev.events & EPOLLHUP))
			return { fd, FDStatus::READ };

		if (ev.events & EPOLLOUT)
			return { fd, FDStatus::WRITE };
	}

	return FDStatus::STOP;
}

// Assembly:
movabsq $0x400000000, %rcx      # imm = 0x400000000
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, 0x20(%rdi)
jbe 0x34db
movl %esi, %eax
movq 0x8(%rdi), %rsi
leaq (%rax,%rax,2), %rax
movl (%rsi,%rax,4), %edx
movl 0x4(%rsi,%rax,4), %eax
testb $0x8, %dl
jne 0x34b5
testb $0x11, %dl
je 0x34c1
movabsq $0x100000000, %rcx      # imm = 0x100000000
jmp 0x34db
movabsq $0x300000000, %rcx      # imm = 0x300000000
jmp 0x34db
andl $0x4, %edx
movabsq $0x200000000, %rsi      # imm = 0x200000000
cmovneq %rsi, %rcx
xorl %esi, %esi
cmpl $0x1, %edx
sbbl %esi, %esi
orl %esi, %eax
movl %eax, %eax
orq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rdi), %rax
movslq 0x10(%rdi), %rdx
movq %rdx, %rcx
addq %rax, %rcx
movzbl (%rcx), %esi
leal -0x9(%rsi), %r8d
cmpl $0x5, %r8d
jae 0x2791
incl %edx
movl %edx, 0x10(%rdi)
incq %rcx
jmp 0x277a
cmpl $0x20, %esi
je 0x2787
movslq %edx, %rcx
movzbl (%rax,%rcx), %ecx
cmpl $0x2b, %ecx
je 0x27a7
cmpl $0x2d, %ecx
jne 0x27ac
incl %edx
movl %edx, 0x10(%rdi)
movslq %edx, %rdx
movb (%rax,%rdx), %sil
leal -0x3a(%rsi), %r8d
cmpb $-0xa, %r8b
jb 0x27fb
addq %rdx, %rax
incq %rax
incl %edx
xorl %r8d, %r8d
leal (%r8,%r8,4), %r8d
addb $-0x30, %sil
movzbl %sil, %esi
leal (%rsi,%r8,2), %r8d
movl %edx, 0x10(%rdi)
movb (%rax), %sil
leal -0x30(%rsi), %r9d
incq %rax
incl %edx
cmpb $0xa, %r9b
jb 0x27c8
movl %r8d, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %r8d, %eax
popq %rbp
retq
movzbl %sil, %edi
callq 0x22fd
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdi, %rbx
movl 0xf0(%rdi), %r15d
leal 0x1(%r15), %eax
movl %eax, -0x30(%rbp)
movl %eax, 0xf0(%rdi)
leaq -0x34(%rbp), %rax
movl %r15d, (%rax)
leaq 0x88(%rdi), %r13
leal (%r15,%r15), %r12d
leaq -0x2c(%rbp), %rsi
movl %r12d, (%rsi)
movq %r13, %rdi
callq 0x5ebe
leal 0x1(,%r15,2), %r14d
leaq -0x2c(%rbp), %rax
movl %r14d, (%rax)
leaq -0x2c(%rbp), %rsi
movq %r13, %rdi
callq 0x5ebe
leaq 0x1a0(%rbx), %r13
leaq -0x2c(%rbp), %rax
movl %r12d, (%rax)
leaq -0x2c(%rbp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x5f12
movl %r14d, (%r12)
leaq -0x2c(%rbp), %rsi
movq %r13, %rdi
callq 0x5f12
leaq 0x200(%rbx), %r14
movq %r14, %rdi
movl -0x30(%rbp), %esi
callq 0x772e
movq %r14, %rdi
movl %r15d, %esi
callq 0x61bc
movb $0x1, (%rax)
leaq 0x218(%rbx), %rdi
leaq -0x34(%rbp), %r12
movq %r12, %rsi
callq 0x5f66
leaq 0x58(%rbx), %r14
movl (%r12), %r15d
movq %r12, %r13
movb 0x989c(%rip), %r12b     # 0xc176
leal 0x1(%r15), %esi
movq %r14, %rdi
callq 0x77ee
movq %r14, %rdi
movl %r15d, %esi
callq 0x60f8
movb %r12b, (%rax)
leaq 0x70(%rbx), %rdi
movl (%r13), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5fa0
leaq 0x170(%rbx), %r14
movl (%r13), %r15d
leal 0x1(%r15), %esi
movq %r14, %rdi
callq 0x772e
movq %r14, %rdi
movl %r15d, %esi
callq 0x61bc
xorl %r12d, %r12d
movb %r12b, (%rax)
leaq 0x298(%rbx), %r14
movl (%r13), %r15d
leal 0x1(%r15), %esi
movq %r14, %rdi
callq 0x792e
movq %r14, %rdi
movl %r15d, %esi
callq 0x6310
movb %r12b, (%rax)
addq $0x28, %rbx
movl (%r13), %esi
incl %esi
movq %rbx, %rdi
callq 0x5fe4
movl (%r13), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
leaq 0x58(%rdi), %r13
movl %esi, %r15d
sarl %r15d
movq %r13, %rdi
movl %r15d, %esi
callq 0x6abc
movb (%rax), %al
andb $0x1, %r12b
movb 0x9547(%rip), %cl       # 0xc176
movl %ecx, %edx
andb $0x2, %dl
movl %edx, %esi
andb %al, %sil
xorb %r12b, %al
xorl %edi, %edi
testb %dl, %dl
sete %dil
xorl %edx, %edx
cmpb %cl, %al
cmovnel %edx, %edi
orb %sil, %dil
je 0x2c9a
movq %r13, %rdi
movl %r15d, %esi
callq 0x60f8
movb %r12b, (%rax)
leaq 0x70(%rbx), %rdi
movl 0x40(%rbx), %r12d
movl %r15d, %esi
callq 0x5c3e
shlq $0x20, %r12
movl %r14d, %ecx
orq %r12, %rcx
movq %rcx, (%rax)
addq $0x28, %rbx
leaq -0x2c(%rbp), %rsi
movq %rbx, %rdi
callq 0x6154
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 0x5434(%rip), %rsi      # 0x80e2
movq %rax, %rdi
callq 0x21d0
movq 0x931b(%rip), %rsi      # 0xbfd8
movq 0x92cc(%rip), %rdx      # 0xbf90
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_O3/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 $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r12
leaq 0xf8(%rdi), %r15
movq %r15, %rdi
callq 0x687e
cmpl $0x20, (%rax)
jb 0x312a
addq $0x1a0, %r12            # imm = 0x1A0
xorl %r14d, %r14d
movq %r12, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movl 0x4(%rax,%r14,4), %esi
movq %r12, %rdi
callq 0x73aa
cmpl $0x0, 0x8(%rax)
jle 0x3111
movq %rax, %r13
xorl %r12d, %r12d
movq (%r13), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x69f0
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x3105
movq (%r13), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x687e
movq (%r13), %rcx
cmpl %ebx, (%rcx,%r14,4)
je 0x3105
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x636c
cmpl 0x9069(%rip), %eax      # 0xc16c
je 0x312e
incq %r12
movslq 0x8(%r13), %rax
cmpq %rax, %r12
jl 0x30bd
incq %r14
movq -0x30(%rbp), %rax
movl (%rax), %ecx
shrl $0x5, %ecx
cmpq %rcx, %r14
movq -0x38(%rbp), %r12
jb 0x30a4
xorl %eax, %eax
jmp 0x3130
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x687e
movq %rax, %r15
addq $0x88, %r14
movl 0x4(%rax), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x7298
movl 0x8(%r15), %ecx
leaq -0x28(%rbp), %r12
movl %ebx, (%r12)
movl %ecx, 0x4(%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0x6068
movl 0x8(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x7298
movl 0x4(%r15), %ecx
movl %ebx, (%r12)
movl %ecx, 0x4(%r12)
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x6068
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movl %edx, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdi, %rbx
addq $0xf8, %rdi
callq 0x687e
cmpl $0x20, (%rax)
jb 0x32c0
movq %rax, %r15
movq %rbx, %rax
leaq 0x1a0(%rbx), %rcx
movq %rcx, -0x58(%rbp)
leaq 0x200(%rbx), %r13
leaq 0x218(%rbx), %rcx
movq %rcx, -0x48(%rbp)
leaq 0x260(%rbx), %rcx
movq %rcx, -0x50(%rbp)
addq $0x228, %rax            # imm = 0x228
movq %rax, -0x40(%rbp)
xorl %r14d, %r14d
leaq -0x38(%rbp), %r12
movl 0x4(%r15,%r14,4), %esi
movq -0x58(%rbp), %rdi
callq 0x73aa
movq %rax, %rdi
movq %r12, %rbx
movq %r12, %rsi
callq 0x5ae8
movl 0x4(%r15,%r14,4), %r12d
sarl %r12d
movl %r12d, -0x30(%rbp)
movq %r13, %rdi
movl %r12d, %esi
callq 0x61bc
cmpb $0x0, (%rax)
jne 0x328b
movq %r13, %rdi
movl %r12d, %esi
callq 0x61bc
movb $0x1, (%rax)
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5f66
cmpl $-0x1, -0x34(%rbp)
je 0x3297
movq -0x50(%rbp), %rdi
jmp 0x329b
movq -0x40(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rbx, %r12
movq %rbx, %rsi
leaq -0x30(%rbp), %rdx
callq 0x7aca
incq %r14
movl (%r15), %eax
shrl $0x5, %eax
cmpq %rax, %r14
jb 0x3238
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
movq %rdi, %rbx
leaq 0xf8(%rdi), %r15
movq %r15, %rdi
callq 0x687e
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x3334
movl (%r12), %eax
andl $-0x4, %eax
incl %eax
movl %eax, (%r12)
movq %r15, %rdi
movl %r14d, %esi
callq 0x687e
movl (%rax), %eax
movl %eax, %ecx
shrl $0x5, %ecx
incl %ecx
btl $0x3, %eax
adcl %ecx, 0x108(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %ebx
movq %rdi, %r14
addq $0xf8, %rdi
callq 0x687e
movq %rax, %r15
addq $0x88, %r14
testl %r12d, %r12d
je 0x3392
movl 0x4(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x7298
movslq 0x8(%rax), %rcx
testq %rcx, %rcx
jle 0x33c9
movq (%rax), %rsi
xorl %edx, %edx
cmpl %ebx, (%rsi,%rdx,8)
je 0x33cb
incq %rdx
cmpq %rdx, %rcx
jne 0x3383
jmp 0x33ef
movl 0x4(%r15), %eax
xorl $0x1, %eax
leaq -0x28(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x60a4
movl 0x8(%r15), %eax
xorl $0x1, %eax
leaq -0x24(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x60a4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %edx, %edx
decl %ecx
cmpl %ecx, %edx
jge 0x33ef
movl %edx, %ecx
movq (%rax), %rdx
movq 0x8(%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
leaq 0x1(%rcx), %rdx
movl 0x8(%rax), %esi
decl %esi
movq %rdx, %rcx
cmpl %edx, %esi
jg 0x33d3
movq %rax, %rdi
callq 0x7a6c
movl 0x8(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x7298
movslq 0x8(%rax), %rcx
testq %rcx, %rcx
jle 0x3423
movq (%rax), %rsi
xorl %edx, %edx
cmpl %ebx, (%rsi,%rdx,8)
je 0x3425
incq %rdx
cmpq %rdx, %rcx
jne 0x3414
jmp 0x3449
xorl %edx, %edx
decl %ecx
cmpl %ecx, %edx
jge 0x3449
movl %edx, %ecx
movq (%rax), %rdx
movq 0x8(%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
leaq 0x1(%rcx), %rdx
movl 0x8(%rax), %esi
decl %esi
movq %rdx, %rcx
cmpl %edx, %esi
jg 0x342d
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a6c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movaps %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movq %r14, %rdi
callq 0x671e
movb $0x1, 0x18(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x345e
movb -0x18(%rbp), %al
movb %al, 0x110(%rbx)
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x38ed
callq 0x2180
movq -0x30(%rbp), %rax
movq %rax, 0xf8(%rbx)
movl -0x28(%rbp), %eax
movl %eax, 0x100(%rbx)
movl -0x24(%rbp), %eax
movl %eax, 0x104(%rbx)
movl -0x20(%rbp), %eax
movl %eax, 0x108(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x392d
callq 0x2180
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7ffc(%rip), %r12b     # 0xc175
cmpl $0x20, (%rsi)
jae 0x4186
movl %r12d, %eax
jmp 0x422b
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 0x6abc
movb (%rax), %cl
andb $0x1, %r13b
xorb %cl, %r13b
movb 0x7fc0(%rip), %al       # 0xc174
xorl %esi, %esi
movl %eax, %edx
andb $0x2, %dl
sete %dil
cmpb %al, %r13b
je 0x41c8
xorl %esi, %esi
jmp 0x41cb
movb %dil, %sil
andb %cl, %dl
orb %dl, %sil
jne 0x422b
movl 0x4(%rbx,%r15,4), %r13d
movl %r13d, %esi
sarl %esi
movq %r14, %rdi
callq 0x6abc
movb (%rax), %cl
andb $0x1, %r13b
xorb %cl, %r13b
movzbl 0x7f82(%rip), %eax      # 0xc176
xorl %esi, %esi
movl %eax, %edx
andb $0x2, %dl
sete %dil
cmpb %al, %r13b
je 0x4208
xorl %esi, %esi
jmp 0x420b
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 0x4193
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4304
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %eax
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
movl 0x30(%rdi), %esi
leaq 0x38(%rdi), %r15
movslq %eax, %r14
movq 0x38(%rdi), %rax
movl (%rax,%r14,4), %ecx
cmpl %ecx, %esi
jle 0x42d6
movq %r15, -0x30(%rbp)
movslq %esi, %r15
leaq 0x58(%rbx), %rax
movq %rax, -0x40(%rbp)
movq %rbx, -0x38(%rbp)
leaq 0x170(%rbx), %r13
movq (%r12), %rax
movl -0x4(%rax,%r15,4), %ebx
decq %r15
sarl %ebx
movq -0x40(%rbp), %rdi
movl %ebx, %esi
callq 0x60f8
movb 0x7eca(%rip), %cl       # 0xc176
movb %cl, (%rax)
movq %r13, %rdi
movl %ebx, %esi
callq 0x61bc
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq (%rax,%r14,4), %rcx
cmpq %rcx, %r15
jg 0x428d
movq -0x38(%rbp), %rbx
movl 0x30(%rbx), %esi
movq -0x30(%rbp), %r15
movl %ecx, 0xe8(%rbx)
subl (%rax,%r14,4), %esi
movq %r12, %rdi
callq 0x5a2c
movl 0x40(%rbx), %esi
subl %r14d, %esi
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6218
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpl $0x0, 0xf0(%rdi)
jle 0x47b5
movq %rdi, %r14
leaq 0x58(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0xf8(%rdi), %r12
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
xorl %r13d, %r13d
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movl %r13d, %esi
callq 0x6abc
movb (%rax), %al
movb 0x7a6c(%rip), %cl       # 0xc176
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 0x479f
movq %r15, -0x40(%rbp)
cmpl $0x0, 0x10(%r14)
jle 0x478a
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %esi
movq %r12, %rdi
callq 0x687e
movl (%rax), %ecx
cmpq $0x20, %rcx
setb %dl
testb $0x3, %cl
setne %sil
orb %dl, %sil
jne 0x477c
shrl $0x5, %ecx
xorl %edx, %edx
movl 0x4(%rax,%rdx,4), %esi
sarl %esi
cmpl %r13d, %esi
je 0x477a
incq %rdx
cmpq %rdx, %rcx
jne 0x4765
jmp 0x477c
incl %ebx
incq %r15
movslq 0x10(%r14), %rax
cmpq %rax, %r15
jl 0x473b
jmp 0x478c
xorl %ebx, %ebx
movl -0x2c(%rbp), %eax
cmpl %eax, %ebx
cmovgl %ebx, %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %r15
cmovgl %r13d, %r15d
incl %r13d
cmpl 0xf0(%r14), %r13d
jl 0x46f6
cmpl $-0x2, %r15d
jne 0x47bd
movl 0x79b1(%rip), %eax      # 0xc16c
jmp 0x47f6
addq $0x170, %r14            # imm = 0x170
movq %r14, %rdi
movl %r15d, %esi
callq 0x61bc
movb (%rax), %bl
xorb $0x1, %bl
movq %r14, %rdi
movl %r15d, %esi
callq 0x61bc
movb %bl, (%rax)
movq %r14, %rdi
movl %r15d, %esi
callq 0x61bc
movzbl (%rax), %eax
xorl $0x1, %eax
leal (%rax,%r15,2), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movl %edx, %ebx
movl %esi, %r15d
movl %esi, -0x3c(%rbp)
movq %rdi, -0x30(%rbp)
addq $0xf8, %rdi
callq 0x687e
movq %rax, %r14
movl (%rax), %eax
testl %ebx, %ebx
je 0x4ad0
cmpl $0x20, %eax
jb 0x4b42
movq -0x30(%rbp), %rax
leaq 0x1a0(%rax), %rcx
movq %rcx, -0x38(%rbp)
leaq 0x200(%rax), %r13
addq $0x218, %rax            # imm = 0x218
movq %rax, -0x50(%rbp)
xorl %r12d, %r12d
movl 0x4(%r14,%r12,4), %esi
movq -0x38(%rbp), %rdi
callq 0x73aa
movslq 0x8(%rax), %rcx
movl $0x0, %edx
testq %rcx, %rcx
jle 0x4a5f
movq (%rax), %rsi
xorl %edx, %edx
cmpl %r15d, (%rsi,%rdx,4)
je 0x4a5f
incq %rdx
cmpq %rdx, %rcx
jne 0x4a4f
jmp 0x4a81
decl %ecx
cmpl %ecx, %edx
jge 0x4a81
movq (%rax), %rcx
movl %edx, %edx
movl 0x4(%rcx,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
leaq 0x1(%rdx), %rsi
movl 0x8(%rax), %edi
decl %edi
movq %rsi, %rdx
cmpl %esi, %edi
jg 0x4a6a
movq %rax, %rdi
callq 0x7d8c
movl 0x4(%r14,%r12,4), %ebx
sarl %ebx
movl %ebx, -0x40(%rbp)
movq %r13, %rdi
movl %ebx, %esi
callq 0x61bc
cmpb $0x0, (%rax)
jne 0x4abc
movq %r13, %rdi
movl %ebx, %esi
callq 0x61bc
movb $0x1, (%rax)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5f66
incq %r12
movl (%r14), %eax
shrl $0x5, %eax
cmpq %rax, %r12
jb 0x4a2e
jmp 0x4b42
cmpl $0x20, %eax
jb 0x4b42
movq -0x30(%rbp), %rax
leaq 0x1a0(%rax), %r15
leaq 0x200(%rax), %r12
addq $0x218, %rax            # imm = 0x218
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
movl 0x4(%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x73aa
movl 0x4(%r14,%r13,4), %ebx
sarl %ebx
movl %ebx, -0x44(%rbp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x61bc
cmpb $0x0, (%rax)
jne 0x4b34
movq %r12, %rdi
movl %ebx, %esi
callq 0x61bc
movb $0x1, (%rax)
movq -0x38(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x5f66
incq %r13
movl (%r14), %eax
shrl $0x5, %eax
cmpq %rax, %r13
jb 0x4af4
movq -0x30(%rbp), %r14
leaq 0x228(%r14), %rdi
leaq -0x3c(%rbp), %rbx
movq %rbx, %rsi
callq 0x7dea
addq $0x260, %r14            # imm = 0x260
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7dea
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c12
movq %rsi, %rbx
cmpl $0x0, 0x8(%rsi)
jle 0x4c03
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 0x687e
movq %r14, %rdi
movq %rax, %rsi
callq 0x4164
movb 0x75a9(%rip), %cl       # 0xc174
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 0x4bf7
movq (%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0x32d0
incq %r13
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jl 0x4bab
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 0x35d1(%rip), %rsi      # 0x81f7
movq %rax, %rdi
callq 0x21d0
movq 0x73a3(%rip), %rsi      # 0xbfd8
movq 0x7354(%rip), %rdx      # 0xbf90
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_O3/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 0x687e
movq %rax, %r12
xorl %ebx, %ebx
cmpl $0x20, (%rax)
jb 0x4ce3
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 0x73aa
movl 0x8(%rax), %r15d
movslq %ebx, %rax
movl 0x4(%r12,%rax,4), %esi
movq %r13, %rdi
callq 0x73aa
movl %r14d, %ecx
cmpl 0x8(%rax), %r15d
jl 0x4cc7
movl %ebx, %ecx
incq %r14
movl (%r12), %eax
shrl $0x5, %eax
movl %ecx, %ebx
cmpq %rax, %r14
jb 0x4c9b
movslq %ecx, %rbx
movq -0x40(%rbp), %r14
movl -0x2c(%rbp), %r15d
leaq 0x1a0(%r14), %rdi
movl 0x4(%r12,%rbx,4), %esi
callq 0x73aa
cmpl $0x0, 0x8(%rax)
jle 0x4d61
movq %rax, %r13
xorl %ebx, %ebx
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq -0x38(%rbp), %rdi
callq 0x69f0
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x4d55
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq -0x38(%rbp), %rdi
callq 0x687e
movq (%r13), %rcx
cmpl %r15d, (%rcx,%rbx,4)
je 0x4d55
movq %r12, %rdi
movq %rax, %rsi
callq 0x636c
cmpl 0x7428(%rip), %eax      # 0xc16c
jne 0x4d55
movq (%r13), %rax
movl (%rax,%rbx,4), %esi
movq %r14, %rdi
callq 0x32d0
incq %rbx
movslq 0x8(%r13), %rax
cmpq %rax, %rbx
jl 0x4cff
movl 0x100(%r14), %eax
movl 0x108(%r14), %ecx
cvtsi2sd %rcx, %xmm0
cvtsi2sd %rax, %xmm1
mulsd 0x2c0(%r14), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4d9e
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_O3/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 0x6f64(%rip), %r14      # 0xbf98
leaq 0x3244(%rip), %rsi      # 0x827f
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 0x4806
movl %eax, %r15d
movb %al, -0x29(%rbp)
leaq 0x321c(%rip), %rsi      # 0x82a0
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 0x70b6(%rip), %al       # 0xc174
movl %eax, %ecx
andb $0x2, %cl
movl %ecx, %edx
andb %r15b, %dl
xorl %esi, %esi
testb %cl, %cl
sete %sil
xorl %ecx, %ecx
cmpb %al, %r15b
cmovnel %ecx, %esi
orb %dl, %sil
je 0x5153
cmpl $0x0, 0xf0(%rbx)
jle 0x5147
leaq 0x58(%rbx), %r14
leaq 0x31d0(%rip), %r12      # 0x82c1
leaq 0x31ca(%rip), %r13      # 0x82c2
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x60f8
movb 0x7067(%rip), %dil      # 0xc174
movb (%rax), %dl
xorl %ecx, %ecx
movl %edi, %eax
andb $0x2, %al
sete %sil
cmpb %dil, %dl
je 0x5122
xorl %ecx, %ecx
jmp 0x5125
movb %sil, %cl
andb %dl, %al
orb %al, %cl
movq %r12, %rdi
je 0x5131
movq %r13, %rdi
incl %r15d
movl %r15d, %esi
xorl %eax, %eax
callq 0x2040
cmpl 0xf0(%rbx), %r15d
jl 0x50fb
leaq 0x33cf(%rip), %rdi      # 0x851d
callq 0x2200
leaq 0x701b(%rip), %rsi      # 0xc175
leaq -0x29(%rbp), %rdi
callq 0x5a02
leaq 0x33b1(%rip), %rdi      # 0x851b
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5fe4
movl $0x3, 0x8(%rbx)
movq (%rbx), %rax
movabsq $0x400000002, %rbx      # imm = 0x400000002
movq %rbx, (%rax)
movl $0x6, 0x8(%rax)
leaq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movl $0x2, %esi
callq 0x5fe4
movl $0x2, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rbx, (%rax)
movb $0x1, 0x110(%r14)
addq $0xf8, %r14
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5a8c
movl %eax, %ebx
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5a8c
movl %eax, %r15d
movq %r14, %rdi
movl %ebx, %esi
callq 0x687e
movq %rax, %rbx
movq %r14, %rdi
movl %r15d, %esi
callq 0x687e
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x636c
movq 0x6d64(%rip), %rdi      # 0xbf98
movl %eax, %esi
callq 0x2260
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x636c
movq 0x6d21(%rip), %rdi      # 0xbf98
movl %eax, %esi
callq 0x2260
movq %rax, %rbx
movq (%rax), %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
movl 0x6ebe(%rip), %esi      # 0xc16c
movq 0x6ce3(%rip), %rdi      # 0xbf98
callq 0x2260
movq %rax, %rbx
movq (%rax), %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
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x52f9
movl $0x0, -0x28(%rbp)
callq 0x2180
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x530e
movl $0x0, -0x38(%rbp)
callq 0x2180
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5328
jmp 0x5328
jmp 0x5328
movq %rax, %rbx
jmp 0x5340
jmp 0x5328
jmp 0x5328
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x5340
movl $0x0, -0x28(%rbp)
callq 0x2180
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x5355
movl $0x0, -0x38(%rbp)
callq 0x2180
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5fe4
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 0x5fe4
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 0x5fe4
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 0x2804
decl %r14d
jne 0x53f4
leaq 0x2b0(%rbx), %r14
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x6a50
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2978
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x6a50
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2978
leaq -0x20(%rbp), %rdi
movq %r14, %rsi
callq 0x6a50
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2978
movq %rbx, %rdi
callq 0x64b6
movq 0x8(%rbx), %rax
movl 0x4(%rax), %esi
movq %rbx, %rdi
callq 0x32d0
movq %rbx, %rdi
callq 0x64b6
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq %rbx, %rdi
callq 0x64b6
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x5493
movl $0x0, -0x18(%rbp)
callq 0x2180
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x54a8
movl $0x0, -0x28(%rbp)
callq 0x2180
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x54bd
movl $0x0, -0x38(%rbp)
callq 0x2180
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x54ea
movq %rax, %rbx
jmp 0x54ff
jmp 0x54d2
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x54ea
movl $0x0, -0x18(%rbp)
callq 0x2180
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x54ff
movl $0x0, -0x28(%rbp)
callq 0x2180
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x5514
movl $0x0, -0x38(%rbp)
callq 0x2180
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a14(%rip), %rsi      # 0x82c6
callq 0x2170
movq %rax, %rbx
leaq -0x2d8(%rbp), %r14
movq %r14, %rdi
callq 0x3936
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 0x5901
leaq -0x2d8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x20c0
leaq -0x2d8(%rbp), %rdi
callq 0x501c
jmp 0x5914
movq %rax, %rbx
leaq -0x2d8(%rbp), %rdi
callq 0x3d2e
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x661c
movl %eax, %r13d
movq %r15, %rdi
movl %eax, %esi
callq 0x679a
movq %rax, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x66ba
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_O3/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 0x5b74
leaq 0x18(%rbx), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x718a
cmpb $0x1, (%rax)
jne 0x5b64
movq 0x30(%rbx), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x71e6
incq %r12
movslq 0x38(%rbx), %rax
addq $0x4, %r15
cmpq %rax, %r12
jl 0x5b40
cmpq $0x0, 0x30(%rbx)
je 0x5b82
movl $0x0, 0x38(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x687e
movq %rax, %r15
testb $0x10, (%rax)
jne 0x5bc2
movq %r14, %rdi
movq %r15, %rsi
callq 0x68de
movl %eax, (%rbx)
orb $0x10, (%r15)
movl %eax, 0x4(%r15)
jmp 0x5bc8
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_O3/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 0x6032
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 0x6039
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 0x6039
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x8, %edi
callq 0x20a0
movq 0x5f36(%rip), %rcx      # 0xbf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x5f48(%rip), %rsi      # 0xbfa0
movq 0x5f11(%rip), %rdx      # 0xbf70
movq %rax, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %eax
testb $0x4, %al
jne 0x640f
testb $0x8, %al
je 0x640f
movl (%rsi), %r9d
movl %r9d, %ecx
andl $0xc, %ecx
cmpl $0x8, %ecx
jne 0x640f
movl %r9d, %ecx
shrl $0x5, %ecx
movl %eax, %edx
shrl $0x5, %edx
cmpl %edx, %ecx
jb 0x63b1
movl 0x4(%rsi,%rcx,4), %r8d
notl %r8d
testl %r8d, 0x4(%rdi,%rdx,4)
je 0x63bc
movl 0x5db9(%rip), %eax      # 0xc170
popq %rbx
popq %r14
popq %rbp
retq
movl 0x5da9(%rip), %r8d      # 0xc16c
cmpl $0x20, %eax
jae 0x63cd
movl %r8d, %eax
jmp 0x63b7
cmpl $0x20, %r9d
jb 0x63b1
xorl %r9d, %r9d
movl %r8d, %eax
movl 0x4(%rdi,%r9,4), %r10d
xorl %r11d, %r11d
movl 0x4(%rsi,%r11,4), %ebx
cmpl %ebx, %r10d
je 0x6405
cmpl %r8d, %eax
jne 0x63f8
xorl %r10d, %ebx
cmpl $0x1, %ebx
je 0x6402
incq %r11
cmpq %r11, %rcx
jne 0x63e1
jmp 0x63b1
movl %r10d, %eax
incq %r9
cmpq %rdx, %r9
jne 0x63d9
jmp 0x63b7
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x1fb3(%rip), %rsi      # 0x83d6
movq %rax, %rdi
callq 0x21d0
movq 0x5ba6(%rip), %rsi      # 0xbfd8
movq 0x5b57(%rip), %rdx      # 0xbf90
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270