LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rcx), %eax
jae 0x69b6
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x6cf0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x695d
movl 0x14(%rsp), %esi
leaq 0x30(%rsp), %rdi
movl $0x3, %edx
callq 0x6d10
jmp 0x69c5
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x697b
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6990
movl 0x14(%rsp), %esi
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0x6d10
jmp 0x69c5
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x69b4
movl 0x14(%rsp), %esi
leaq 0x30(%rsp), %rdi
movl $0x2, %edx
callq 0x6d10
jmp 0x69c5
jmp 0x69b6
leaq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0x6d30
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::EPollSelector::mutateFD_(int, net::selector::FDEvent, int)
bool EPollSelector::mutateFD_(int const fd, FDEvent const event, int const op){
	epoll_event ev;
	ev.events = epollConvert(event);
	ev.data.fd = fd;

	int const result = epoll_ctl(epollFD_, op, fd, &ev);

	return result >= 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %edi
callq 0x6aa0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rsp)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x1c(%rsp)
movl (%rax), %edi
movl 0x24(%rsp), %esi
movl 0x2c(%rsp), %edx
leaq 0x18(%rsp), %rcx
callq 0x2220
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
setge %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::(anonymous namespace)::epollConvert(net::selector::FDEvent)
auto epollConvert(const FDEvent event) -> decltype(epoll_event::events){
	switch(event){
		default:
		case FDEvent::READ	: return EPOLLIN;
		case FDEvent::WRITE	: return EPOLLOUT;
	}
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, -0xc(%rsp)
testl %eax, %eax
je 0x6abf
jmp 0x6ab2
movl -0xc(%rsp), %eax
subl $0x1, %eax
je 0x6ac9
jmp 0x6abd
jmp 0x6abf
movl $0x1, -0x4(%rsp)
jmp 0x6ad1
movl $0x4, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: Myyura[P]MyyuraSat/./source/../include/util/dimacs.hpp
// Function: (anonymous namespace)::UnitParser::read_line()
bool read_line(void) {
        if (fgets(_current_line, _size, _in) == NULL) {
            return false;
        }

        _pos = 0;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rdi
movl 0x14(%rax), %esi
movq (%rax), %rdx
callq 0x21d0
cmpq $0x0, %rax
jne 0x280f
movb $0x0, -0x1(%rbp)
jmp 0x281e
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Myyura[P]MyyuraSat/./source/../include/util/dimacs.hpp
// Function: (anonymous namespace)::UnitParser::match(char const*)
bool match(const char *s) {
        for (; *s != '\0'; s++, _pos++) {
            if (*s != _current_line[_pos]) {
                return false;
            }
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x292e
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq 0x8(%rdx), %rcx
movslq 0x10(%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2911
movb $0x0, -0x1(%rbp)
jmp 0x2932
jmp 0x2913
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x28e4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x2830
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x298c
movq -0x18(%rbp), %rax
movb $0x1, -0xd(%rbp)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x29b0
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x29ae
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x29b0
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x29da
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x2a0c
movq -0x18(%rbp), %rcx
movq 0x135c3(%rip), %rax     # 0x15fa8
movq (%rax), %rdi
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %edx
leaq 0xc68d(%rip), %rsi      # 0xf088
movb $0x0, %al
callq 0x2190
movl $0x3, %edi
callq 0x2160
jmp 0x2a0e
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x19(%rbp)
jl 0x2a41
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2a4a
jmp 0x2a75
movq -0x18(%rbp), %rdx
imull $0xa, -0xc(%rbp), %eax
movq 0x8(%rdx), %rcx
movslq 0x10(%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x2a0e
testb $0x1, -0xd(%rbp)
je 0x2a85
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2a8b
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movb %dl, %al
movb %sil, %cl
movb %cl, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0xf0(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xf0(%rax)
movl %ecx, -0x18(%rbp)
addq $0x88, %rax
movq %rax, -0x70(%rbp)
movl -0x18(%rbp), %esi
leaq -0x1c(%rbp), %rdi
xorl %edx, %edx
callq 0x7430
movq -0x70(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x86a0
movq -0x40(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x68(%rbp)
movl -0x18(%rbp), %esi
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
callq 0x7430
movq -0x68(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x86a0
movq -0x40(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x60(%rbp)
movl -0x18(%rbp), %esi
leaq -0x24(%rbp), %rdi
xorl %edx, %edx
callq 0x7430
movq -0x60(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x8710
movq -0x40(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x58(%rbp)
movl -0x18(%rbp), %esi
leaq -0x28(%rbp), %rdi
movl $0x1, %edx
callq 0x7430
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8710
movq -0x40(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
movl -0x18(%rbp), %esi
movl $0x1, %edx
callq 0x8780
movq -0x40(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
leaq -0x18(%rbp), %rsi
callq 0x87d0
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
movl -0x18(%rbp), %esi
movb 0x1359e(%rip), %al      # 0x16156
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %edx
callq 0x8830
movq -0x40(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x50(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x34(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x88b0
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x34(%rbp), %rdx
callq 0x8870
movq -0x40(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movl -0x18(%rbp), %esi
xorl %edx, %edx
callq 0x8780
movq -0x40(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
movl -0x18(%rbp), %esi
xorl %edx, %edx
callq 0x88d0
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
callq 0x8920
movl -0x18(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x7740
movb %al, -0x15(%rbp)
leaq -0x15(%rbp), %rdi
leaq 0x131b0(%rip), %rsi     # 0x16156
callq 0x7840
testb $0x1, %al
jne 0x2fb1
jmp 0x3004
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0xc178(%rip), %rsi      # 0xf144
callq 0x21a0
jmp 0x2fd3
movq -0x48(%rbp), %rdi
movq 0x12ffa(%rip), %rsi     # 0x15fd8
movq 0x12fab(%rip), %rdx     # 0x15f90
callq 0x2210
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x20c0
jmp 0x309e
leaq -0x4(%rbp), %rdi
callq 0x8b20
xorb $-0x1, %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x2d(%rbp), %rdi
callq 0x8b40
movq -0x40(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x60(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x7db0
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x8b70
movq -0x40(%rbp), %rdi
movb -0x2d(%rbp), %cl
movb %cl, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0x7670
movl -0x54(%rbp), %esi
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0x88b0
movq -0x40(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x50(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x7db0
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x7f40
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
addq $0x28, %rdi
leaq -0x4(%rbp), %rsi
callq 0x8c10
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2230
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0xf8, %rdi
movl -0x14(%rbp), %esi
callq 0x7aa0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x36b8
movq -0x50(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x8ee0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x7d40
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7d70
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0x36a8
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x7d90
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x7f00
testb $0x1, %al
jne 0x361a
jmp 0x361c
jmp 0x369a
movq -0x50(%rbp), %rax
addq $0xf8, %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x7d90
movq -0x78(%rbp), %rdi
movl (%rax), %esi
callq 0x7aa0
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x7d90
movl -0x6c(%rbp), %ecx
movq %rax, %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x65(%rbp)
je 0x3689
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9220
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rdi
leaq 0x12acb(%rip), %rsi     # 0x1614c
callq 0x7820
movb %al, -0x65(%rbp)
movb -0x65(%rbp), %al
testb $0x1, %al
jne 0x3692
jmp 0x3698
movb $0x1, -0x1(%rbp)
jmp 0x36bc
jmp 0x369a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x35e1
jmp 0x36aa
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3594
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0xf8, %rdi
movl -0xc(%rbp), %esi
callq 0x7aa0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x18(%rbp)
addq $0x88, %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x75b0
movq -0x78(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x7ba0
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x89f0
movl -0x6c(%rbp), %esi
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x8a70
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8a10
movq -0x60(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x89f0
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x75b0
movq -0x58(%rbp), %rdi
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x7ba0
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movl -0x4c(%rbp), %esi
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %edx
leaq -0x3c(%rbp), %rdi
callq 0x8a70
movq -0x48(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x8a10
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0xf8, %rdi
movl -0xc(%rbp), %esi
callq 0x7aa0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x38d8
movq -0x48(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8ee0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x7d40
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x7a40
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8ee0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x9170
cmpl $-0x1, -0x10(%rbp)
jne 0x38ad
movq -0x48(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
leaq -0xc(%rbp), %rsi
callq 0x91b0
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
jmp 0x38c8
movq -0x48(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
leaq -0xc(%rbp), %rsi
callq 0x91b0
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
jmp 0x38ca
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3824
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xf8, %rdi
movl -0xc(%rbp), %esi
callq 0x7aa0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x3940
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x7ad0
movq -0x20(%rbp), %rdi
addq $0xf8, %rdi
movl -0xc(%rbp), %esi
callq 0x79e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xa0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0xf8, %rdi
movl -0xc(%rbp), %esi
callq 0x7aa0
movq %rax, -0x18(%rbp)
testb $0x1, -0xd(%rbp)
je 0x3a5e
movq -0x58(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x75b0
movq -0x88(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x7ba0
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x89f0
movl -0x7c(%rbp), %esi
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x8a70
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x48a0
movq -0x58(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x89f0
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x75b0
movq -0x70(%rbp), %rdi
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x7ba0
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movl -0x64(%rbp), %esi
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %edx
leaq -0x3c(%rbp), %rdi
callq 0x8a70
movq -0x60(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x48a0
jmp 0x3ad7
movq -0x58(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movl %eax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x75b0
movq -0x98(%rbp), %rdi
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x8a90
movq -0x58(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x89f0
movl %eax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x75b0
movq -0x90(%rbp), %rdi
movl %eax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x8a90
addq $0xa0, %rsp
popq %rbp
retq
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0xf8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x8090
movq -0x58(%rbp), %rdi
movl %eax, -0x4c(%rbp)
callq 0x80b0
movl -0x4c(%rbp), %esi
subl %eax, %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x80d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3ae0
jmp 0x4091
movq -0x48(%rbp), %rsi
addq $0xf8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8100
jmp 0x40a7
leaq -0x28(%rbp), %rdi
callq 0x8130
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8130
movq -0x30(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7bd0
movl -0x1c(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jge 0x48ef
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7c70
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xd8a0
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x48f8
jmp 0x4905
jmp 0x48fa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x48b7
jmp 0x4907
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7bd0
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4956
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x7c70
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7c70
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4907
movq -0x8(%rbp), %rdi
callq 0xd8c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x117c7(%rip), %al      # 0x16155
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x4a42
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x89f0
movq -0x38(%rbp), %rdi
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0x7740
movb %al, -0x21(%rbp)
leaq -0x21(%rbp), %rdi
leaq 0x11777(%rip), %rsi     # 0x16154
callq 0x77c0
testb $0x1, %al
jne 0x49e8
jmp 0x49f3
movb 0x11766(%rip), %al      # 0x16154
movb %al, -0x1(%rbp)
jmp 0x4a48
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x89f0
movq -0x38(%rbp), %rdi
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %esi
callq 0x7740
movb %al, -0x29(%rbp)
leaq -0x29(%rbp), %rdi
leaq 0x1173a(%rip), %rsi     # 0x16156
callq 0x77c0
testb $0x1, %al
jne 0x4a27
jmp 0x4a30
movb 0x11729(%rip), %al      # 0x16156
movb %al, -0x19(%rbp)
jmp 0x4a32
jmp 0x4a34
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4998
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7670
cmpl -0xc(%rbp), %eax
jle 0x4b83
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x7720
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0x8cb0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jl 0x4b0c
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %esi
callq 0x77a0
movq %rax, %rdi
callq 0x7db0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x58, %rdi
movl -0x14(%rbp), %esi
callq 0x8b70
movq -0x20(%rbp), %rdi
movb 0x11669(%rip), %cl      # 0x16156
movb %cl, (%rax)
addq $0x170, %rdi            # imm = 0x170
movl -0x14(%rbp), %esi
callq 0x8cd0
movb $0x0, (%rax)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4a98
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0x8cb0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, 0xe8(%rdi)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x7720
movq -0x20(%rbp), %rdi
movl %eax, -0x3c(%rbp)
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0x8cb0
movl -0x3c(%rbp), %esi
movq -0x38(%rbp), %rdi
subl (%rax), %esi
callq 0x7890
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
callq 0x8e20
movq -0x30(%rbp), %rdi
movl %eax, %esi
subl -0xc(%rbp), %esi
callq 0x8d70
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0xf8, %rdi
movl -0xc(%rbp), %esi
callq 0x7aa0
movq %rax, -0x18(%rbp)
testb $0x1, -0xd(%rbp)
je 0x55b5
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x55b3
movq -0x38(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x89f0
movq -0x48(%rbp), %rdi
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x7d40
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x5660
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x89f0
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x9170
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x553e
jmp 0x5627
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5625
movq -0x38(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x89f0
movq -0x58(%rbp), %rdi
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x7d40
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x89f0
movq -0x38(%rbp), %rdi
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x9170
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x55bc
jmp 0x5627
movq -0x38(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
leaq -0xc(%rbp), %rsi
callq 0x91f0
movq -0x38(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
leaq -0xc(%rbp), %rsi
callq 0x91f0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x7670
cmpl $0x0, %eax
je 0x5795
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x9afc(%rip), %rsi      # 0xf259
callq 0x21a0
jmp 0x5764
movq -0x48(%rbp), %rdi
movq 0x10869(%rip), %rsi     # 0x15fd8
movq 0x1081a(%rip), %rdx     # 0x15f90
callq 0x2210
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20c0
jmp 0x583b
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7d70
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5835
movq -0x40(%rbp), %rax
addq $0xf8, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x7d90
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x7aa0
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x4970
movb %al, -0x31(%rbp)
leaq -0x31(%rbp), %rdi
leaq 0x10955(%rip), %rsi     # 0x16154
callq 0x77c0
testb $0x1, %al
jne 0x580a
jmp 0x5823
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x7d90
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x38e0
jmp 0x5825
jmp 0x5825
jmp 0x5827
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x57a3
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1005d(%rip), %rdi     # 0x15f98
leaq 0x939f(%rip), %rsi      # 0xf2e1
callq 0x20f0
movq %rax, %rdi
movq 0x1000f(%rip), %rsi     # 0x15f60
callq 0x2120
movq -0x18(%rbp), %rdi
movl $0x64, %esi
callq 0x5270
movb %al, -0x9(%rbp)
movq 0x1002a(%rip), %rdi     # 0x15f98
leaq 0x938d(%rip), %rsi      # 0xf302
callq 0x20f0
movq %rax, %rdi
movq 0xffdc(%rip), %rsi      # 0x15f60
callq 0x2120
leaq -0x9(%rbp), %rdi
leaq 0x101c0(%rip), %rsi     # 0x16154
callq 0x77c0
testb $0x1, %al
jne 0x5fa2
jmp 0x602d
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x7530
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x601d
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
movl -0x10(%rbp), %esi
callq 0x8b70
movq %rax, %rdi
leaq 0x10179(%rip), %rsi     # 0x16154
callq 0x77c0
testb $0x1, %al
jne 0x5fe6
jmp 0x5ffc
movl -0x10(%rbp), %esi
addl $0x1, %esi
leaq 0x9331(%rip), %rdi      # 0xf324
movb $0x0, %al
callq 0x2030
jmp 0x6010
movl -0x10(%rbp), %esi
addl $0x1, %esi
leaq 0x931a(%rip), %rdi      # 0xf323
movb $0x0, %al
callq 0x2030
jmp 0x6012
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5fa9
leaq 0x9306(%rip), %rdi      # 0xf32a
movb $0x0, %al
callq 0x2030
jmp 0x6053
leaq -0x9(%rbp), %rdi
leaq 0x1011d(%rip), %rsi     # 0x16155
callq 0x77c0
testb $0x1, %al
jne 0x6043
jmp 0x6051
leaq 0x92de(%rip), %rdi      # 0xf328
movb $0x0, %al
callq 0x2030
jmp 0x6053
ud2
nopw %cs:(%rax,%rax)
// File: 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
subq $0x310, %rsp            # imm = 0x310
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x87a7(%rip), %rsi      # 0xf32f
callq 0x2140
movq %rax, -0x18(%rbp)
leaq -0x2e0(%rbp), %rdi
movq %rdi, -0x300(%rbp)
callq 0x40e0
movq -0x300(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x2460
jmp 0x6bb6
leaq -0x2e0(%rbp), %rdi
callq 0x9470
jmp 0x6bc4
callq 0x20b0
movl %eax, -0x2f0(%rbp)
leaq -0x2e0(%rbp), %rdi
callq 0x5f20
jmp 0x6bdd
callq 0x20b0
movl %eax, -0x2f4(%rbp)
movl -0x2f4(%rbp), %eax
movl -0x2f0(%rbp), %ecx
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x8406(%rip), %xmm1     # 0xf008
divsd %xmm1, %xmm0
movq 0xf38b(%rip), %rdi      # 0x15f98
callq 0x2250
movq %rax, -0x308(%rbp)
jmp 0x6c1b
movq -0x308(%rbp), %rdi
movq 0xf337(%rip), %rsi      # 0x15f60
callq 0x2120
jmp 0x6c30
movl $0x0, -0x4(%rbp)
leaq -0x2e0(%rbp), %rdi
callq 0x4710
movl -0x4(%rbp), %eax
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2e8(%rbp)
movl %eax, -0x2ec(%rbp)
leaq -0x2e0(%rbp), %rdi
callq 0x4710
movq -0x2e8(%rbp), %rdi
callq 0x2230
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0xaed8
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0xaea7
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0x10(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x8670
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xae79
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, -0x9(%rbp)
je 0xaed6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2150
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0xc(%rax)
jmp 0xaed8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x18(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7720
movq -0x20(%rbp), %rdi
movl %eax, %esi
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x9850
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x9770
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x9880
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movb -0x12(%rbp), %cl
movb -0x11(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x98b0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x30, %rdi
callq 0x7720
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7b81
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
movl -0xc(%rbp), %esi
callq 0x77a0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
callq 0xc1a0
testb $0x1, (%rax)
je 0x7b74
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
callq 0x77a0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xc250
jmp 0x7b76
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7b0b
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x74b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x7aa0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7e00
testb $0x1, %al
jne 0x7c26
jmp 0x7c39
movq -0x20(%rbp), %rdi
callq 0x9d60
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x7c5d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9d80
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x9e20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x7740
movb %al, -0x11(%rbp)
leaq -0x11(%rbp), %rdi
leaq 0xe2f4(%rip), %rsi      # 0x16154
callq 0x77c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x7e73
jmp 0x7ee6
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x7db0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x7dd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x21(%rbp)
je 0x7ee6
movq -0x30(%rbp), %rax
addq $0xf8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x89f0
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7db0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x7dd0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x9f70
cmpq -0x10(%rbp), %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x8944
jmp 0x89e7
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
subl 0xc(%rax), %ecx
addl $0x1, %ecx
andl $-0x2, %ecx
movl %ecx, -0x14(%rbp)
movl 0xc(%rax), %eax
sarl %eax
addl $0x2, %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc160
movq -0x28(%rbp), %rdx
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x7fffffff, -0x1c(%rbp) # imm = 0x7FFFFFFF
movl -0x10(%rbp), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jg 0x89ba
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
movl -0x10(%rbp), %eax
addl 0xc(%rcx), %eax
movl %eax, 0xc(%rcx)
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x2200
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x89e7
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x9710
movq -0x30(%rbp), %rdi
movq 0xd5c5(%rip), %rsi      # 0x15fa0
movq 0xd586(%rip), %rdx      # 0x15f68
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xc9bd(%rip), %rdi      # 0x15f98
leaq 0x5ec9(%rip), %rsi      # 0xf4ab
callq 0x20f0
movq %rax, %rdi
movq 0xc96f(%rip), %rsi      # 0x15f60
callq 0x2120
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x8, %rdi
callq 0x7d70
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x96e7
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0xf8, %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
movl -0xc(%rbp), %esi
callq 0xb430
movq -0x38(%rbp), %rdi
movl (%rax), %esi
callq 0xa030
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %esi
movq 0xc945(%rip), %rdi      # 0x15f98
callq 0x2220
movq %rax, %rdi
leaq 0x5e81(%rip), %rsi      # 0xf4e3
callq 0x20f0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x96c6
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x89f0
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x95b0
movl %eax, %esi
movq 0xc8f1(%rip), %rdi      # 0x15f98
callq 0x2220
movq %rax, %rdi
leaq 0x5e2f(%rip), %rsi      # 0xf4e5
callq 0x20f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x966e
movq 0xc8cb(%rip), %rdi      # 0x15f98
movq 0xc88c(%rip), %rsi      # 0x15f60
callq 0x2120
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x95fd
movq 0xc8aa(%rip), %rdi      # 0x15f98
leaq 0x5df2(%rip), %rsi      # 0xf4e7
callq 0x20f0
movq %rax, %rdi
movq 0xc85c(%rip), %rsi      # 0x15f60
callq 0x2120
addq $0x40, %rsp
popq %rbp
retq
nop