LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::__add2(bal::Anf*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
literalid_t __add2(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y,
                       const literalid_t r_prev, const literalid_t x_prev, const literalid_t y_prev) {
        _assert_level_0(formula != nullptr);
        formula->append_equation();
        formula->append_equation_term(x);
        formula->append_equation_term(y);
        formula->append_equation_term(x_prev);
        formula->append_equation_term(y_prev);
        formula->append_equation_term(x_prev, y_prev);
        formula->append_equation_term(x_prev, r_prev);
        formula->append_equation_term(y_prev, r_prev);
        return formula->complete_equation(r, literal_t__is_unassigned(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
testq %rdi, %rdi
je 0xe755
movl %r9d, %r12d
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
movl 0x10(%rbp), %r13d
callq 0xcaa4
movq %r14, %rdi
movl %r15d, %esi
callq 0xce90
movq %r14, %rdi
movl %ebx, %esi
callq 0xce90
movq %r14, %rdi
movl %r12d, %esi
callq 0xce90
movq %r14, %rdi
movl %r13d, %esi
callq 0xce90
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0xceb0
movq %r14, %rdi
movl %r12d, %esi
movl -0x2c(%rbp), %ebx
movl %ebx, %edx
callq 0xceb0
movq %r14, %rdi
movl %r13d, %esi
movl %ebx, %edx
callq 0xceb0
xorl %edx, %edx
movl -0x30(%rbp), %esi
cmpl $-0x1, %esi
sete %dl
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xced2
leaq 0x2e1ad(%rip), %rdi     # 0x3c909
leaq 0x23220(%rip), %rsi     # 0x31983
leaq 0x23540(%rip), %rcx     # 0x31caa
pushq $0x4e
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.cpp
// Function: bal::__statistics_reset()
void __statistics_reset() {
        __find_clause_found = 0;
        __find_clause_unfound = 0;
        __compare_clauses_ = 0;
        __append_clause_ = 0;
        __time_start_ = std::chrono::system_clock::now();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andl $0x0, 0x42b5d(%rip)     # 0x512dc
andl $0x0, 0x42b5a(%rip)     # 0x512e0
andl $0x0, 0x42b57(%rip)     # 0x512e4
andl $0x0, 0x42b54(%rip)     # 0x512e8
callq 0xc040
movq %rax, 0x42b50(%rip)     # 0x512f0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.cpp
// Function: bal::__print_clause(unsigned int const*)
bool __print_clause(const uint32_t* const p_clause) {
        std::cout << (_clause_is_included(p_clause) ? "i" : "e") << ": ";
        print_clause(std::cout, p_clause, "; ");
        std::cout << std::endl;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, (%rdi)
leaq 0x234eb(%rip), %rax     # 0x31d70
leaq 0x29222(%rip), %rsi     # 0x37aae
cmovnsq %rax, %rsi
movq 0x42719(%rip), %r14     # 0x50fb0
movq %r14, %rdi
callq 0xc290
leaq 0x29a63(%rip), %rsi     # 0x38309
movq %rax, %rdi
callq 0xc290
leaq 0x234bd(%rip), %rdx     # 0x31d72
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe9ac
movq %r14, %rdi
callq 0xc120
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.cpp
// Function: bal::__print_conflict(unsigned int const*, unsigned int const*)
void __print_conflict(const literalid_t variables[], const uint32_t* const p_clause) {
        std::cout << "CONFLICT" << std::endl;
        std::cout << "Clause(s):" << std::endl;
        __print_clause(p_clause);
        std::cout << "Variable(s):" << std::endl;
        for (auto i = 0; i < _clause_size(p_clause); i++) {
            const literalid_t literal_id = _clause_literal(p_clause, i);
            const variableid_t variable_id = literal_t__variable_id(literal_id);
            const literalid_t value_id = literal_t::resolve(variables, literal_id);
            std::cout << literal_t(variable_t__literal_id(variable_id)) << " = " << literal_t(value_id) << std::endl;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x426c6(%rip), %r15     # 0x50fb0
leaq 0x23484(%rip), %rsi     # 0x31d75
movq %r15, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
leaq 0x23476(%rip), %rsi     # 0x31d7e
movq %r15, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq %rbx, %rdi
callq 0xe870
leaq 0x23462(%rip), %rsi     # 0x31d89
movq %r15, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
xorl %r15d, %r15d
movl (%rbx), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
cmpq %rax, %r15
jae 0xe99d
movl 0x4(%rbx,%r15,4), %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0xeae2
movl %eax, %r13d
orl $0x1, %r12d
movl %r12d, -0x30(%rbp)
movq 0x42648(%rip), %rdi     # 0x50fb0
leaq -0x30(%rbp), %rsi
callq 0xeb12
movq %rax, %rdi
leaq 0x2341b(%rip), %rsi     # 0x31d96
callq 0xc290
movl %r13d, -0x2c(%rbp)
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0xeb12
movq %rax, %rdi
callq 0xc120
incq %r15
jmp 0xe93a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.hpp
// Function: bal::print_clause(std::ostream&, unsigned int const*, char const*)
inline void print_clause(std::ostream& stream, const uint32_t* const p_clause, const char* final_token = nullptr) {
        uint16_t clauses_bitmap = _clause_flags(p_clause);
        const clause_size_t clause_size = _clause_size(p_clause);
        
        if (clause_size <= 4 && clauses_bitmap != 0) {
            uint16_t clause_bitmap = 0;
            while (clauses_bitmap > 0) {
                if (clauses_bitmap & 1) {
                    for (auto i = 0; i < clause_size; i++) {
                        literal_t literal(literal_t__negated_onlyif(_clause_literal(p_clause, i), (clause_bitmap & (1 << i)) == 0));
                        stream << ((i > 0) ? " " : "") << literal;
                    };
                    
                    if (final_token != nullptr) {
                        stream << final_token;
                    };
                };
                clause_bitmap++;
                clauses_bitmap >>= 1;
            };
        } else {
            for (auto i = 0; i < clause_size; i++) {
                stream << ((i > 0) ? " " : "") << literal_t(*(p_clause + i + 1));
            };
            
            if (final_token != nullptr) {
                stream << final_token;
            };
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r14
movl (%rsi), %r12d
movl %r12d, %ebx
andl $0x7fff, %ebx           # imm = 0x7FFF
cmpl $0x5, %ebx
setb %al
cmpl $0x10000, %r12d         # imm = 0x10000
setae %cl
testb %al, %cl
je 0xea7f
shrl $0x10, %r12d
movl %ebx, %ebx
xorl %r13d, %r13d
testl %r12d, %r12d
je 0xead3
testb $0x1, %r12b
je 0xea74
movq %r12, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movzwl %r13w, %r13d
notl %r13d
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0xea59
xorl %eax, %eax
btl %r12d, %r13d
setb %al
xorl 0x4(%r15,%r12,4), %eax
movl %eax, -0x38(%rbp)
testq %r12, %r12
leaq 0x29966(%rip), %rsi     # 0x3839b
leaq 0x2f4a8(%rip), %rax     # 0x3dee4
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0xc290
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0xeb12
incq %r12
jmp 0xea15
cmpq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %r13
je 0xea74
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0xc290
incl %r13d
shrl %r12d
jmp 0xe9f4
xorl %r13d, %r13d
leaq -0x34(%rbp), %r12
cmpq %r13, %rbx
je 0xeac0
testq %r13, %r13
leaq 0x29906(%rip), %rsi     # 0x3839b
leaq 0x2f448(%rip), %rax     # 0x3dee4
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0xc290
movl 0x4(%r15,%r13,4), %ecx
movl %ecx, -0x34(%rbp)
movq %rax, %rdi
movq %r12, %rsi
callq 0xeb12
incq %r13
jmp 0xea86
cmpq $0x0, -0x30(%rbp)
je 0xead3
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0xc290
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/variables.hpp
// Function: bal::literal_t::resolve(unsigned int const*, unsigned int)
inline static literalid_t resolve(const literalid_t* const table, literalid_t value) {
            // TODO: check assignment of self-negated
            literalid_t result = value;
            
            while (literal_t__is_variable(value)) {
                result = table[literal_t__variable_id(result)];
                result = (result == LITERALID_UNASSIGNED) ? LITERALID_UNASSIGNED : literal_t__substitute_literal(value, result);
                if (result == value) {
                    break;
                } else {
                    value = result;
                };
            };
            
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x2(%rsi), %eax
cmpl $-0x4, %eax
ja 0xeb0e
movl %esi, %eax
shrl %eax
movl -0x4(%rdi,%rax,4), %ecx
movl %esi, %eax
andl $0x1, %eax
xorl %ecx, %eax
xorl $0x1, %eax
cmpl $-0x1, %ecx
cmovnel %eax, %ecx
cmpl %esi, %ecx
movl %ecx, %esi
jne 0xeae6
jmp 0xeb10
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/variables.hpp
// Function: bal::operator<<(std::ostream&, bal::literal_t const&)
std::ostream& operator << (std::ostream& stream, const literal_t& value) {
            if (literal_t__is_variable(value.id_)) {
                if (literal_t__is_negation(value.id_)) {
                    stream << "-";
                };
                stream << std::dec << (literal_t__variable_id(value.id_) + 1);
            } else if (literal_t__is_unassigned(value.id_)) {
                stream << "*";
            } else {
                stream << (literal_t__is_constant_1(value.id_) ? "0b1" : "0b0");
            };
            return stream;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
cmpl $0x2, %esi
jae 0xeb3d
cmpl $0x1, %esi
leaq 0x2326c(%rip), %rax     # 0x31d9c
leaq 0x23269(%rip), %rsi     # 0x31da0
cmoveq %rax, %rsi
jmp 0xeb49
cmpl $-0x1, %esi
jne 0xeb53
leaq 0x23251(%rip), %rsi     # 0x31d9a
movq %rbx, %rdi
callq 0xc290
jmp 0xeb8a
testb $0x1, %sil
jne 0xeb6b
leaq 0x24416(%rip), %rsi     # 0x32f76
movq %rbx, %rdi
callq 0xc290
movl (%r14), %esi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
shrl %esi
movq %rbx, %rdi
callq 0xc190
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::eor(bal::Cnf*, unsigned int, unsigned int const*, unsigned long)
void eor(Cnf* const formula, const literalid_t r, const literalid_t args[], const std::size_t args_size) {
        // more than one variable, generate 2^(N-1) clauses
        _assert_level_0(formula != nullptr);
        _assert_level_1(args_size > 1 && args_size < MAX_XOR_SIZE); // args_size + 1 for result
        literalid_t clause_args[args_size + 1];
        
        for (uint32_t i = 0; i < (1 << args_size); i++) {
            // i bits can be used to determine the negation and the result
            literalid_t constant = 0b0;
            for (auto j = 0; j < args_size; j++) {
                clause_args[j] = literal_t__negated_onlyif(args[j], i & (0x1 << j));
                literal_t__negate_onlyif(constant, i & (0x1 << j));
            };
            clause_args[args_size] = literal_t__negated_onlyif(r, literal_t__is_constant_0(constant));
            formula->append_clause(clause_args, args_size + 1);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
testq %rdi, %rdi
je 0xec4e
movq %rcx, %rbx
leaq -0x2(%rcx), %rax
cmpq $0x1e, %rax
jae 0xec67
movq %rdx, %r14
leal 0x1(%rbx), %eax
movq %rsp, %r13
leaq 0x13(,%rbx,4), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
addq $0x78, -0x38(%rbp)
xorl %r12d, %r12d
movzwl %ax, %r15d
movl %r12d, %eax
movl %ebx, %ecx
shrl %cl, %eax
testl %eax, %eax
jne 0xec3f
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %rbx
je 0xec1c
xorl %edx, %edx
btl %eax, %r12d
setb %dl
movl (%r14,%rax,4), %esi
xorl %edx, %esi
movl %esi, (%r13,%rax,4)
xorl %edx, %ecx
incq %rax
jmp 0xebfc
xorl %eax, %eax
testl %ecx, %ecx
sete %al
xorl -0x2c(%rbp), %eax
movl %eax, (%r13,%rbx,4)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0xf230
incl %r12d
jmp 0xebed
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2dcb4(%rip), %rdi     # 0x3c909
leaq 0x23148(%rip), %rsi     # 0x31da4
leaq 0x23164(%rip), %rcx     # 0x31dc7
pushq $0x10
jmp 0xec7e
leaq 0x231ae(%rip), %rdi     # 0x31e1c
leaq 0x2312f(%rip), %rsi     # 0x31da4
leaq 0x2314b(%rip), %rcx     # 0x31dc7
pushq $0x11
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::con2(bal::Cnf*, unsigned int, unsigned int, unsigned int)
void con2(Cnf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_1(formula != nullptr);
        _assert_level_1(literal_t__is_variable(r));
        _assert_level_1(literal_t__is_variable(x));
        _assert_level_1(literal_t__is_variable(y));
        formula->append_clause_l(literal_t__negated(x), literal_t__negated(y), r);
        formula->append_clause_l(x, literal_t__negated(r));
        formula->append_clause_l(y, literal_t__negated(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xed03
movl %esi, %r14d
leal -0x2(%r14), %eax
cmpl $-0x3, %eax
jae 0xed1c
movl %edx, %r12d
leal -0x2(%r12), %eax
cmpl $-0x3, %eax
jae 0xed35
movl %ecx, %ebx
leal -0x2(%rbx), %eax
cmpl $-0x3, %eax
jae 0xed4e
movq %rdi, %r15
addq $0x78, %r15
movl %r12d, %esi
xorl $0x1, %esi
movl %ebx, %edx
xorl $0x1, %edx
movq %r15, %rdi
movl %r14d, %ecx
callq 0xf2fa
xorl $0x1, %r14d
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0xf320
movq %r15, %rdi
movl %ebx, %esi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf320
leaq 0x2dbff(%rip), %rdi     # 0x3c909
leaq 0x23093(%rip), %rsi     # 0x31da4
leaq 0x2312e(%rip), %rcx     # 0x31e46
pushq $0x21
jmp 0xed65
leaq 0x23177(%rip), %rdi     # 0x31e9a
leaq 0x2307a(%rip), %rsi     # 0x31da4
leaq 0x23115(%rip), %rcx     # 0x31e46
pushq $0x22
jmp 0xed65
leaq 0x2319e(%rip), %rdi     # 0x31eda
leaq 0x23061(%rip), %rsi     # 0x31da4
leaq 0x230fc(%rip), %rcx     # 0x31e46
pushq $0x23
jmp 0xed65
leaq 0x231c5(%rip), %rdi     # 0x31f1a
leaq 0x23048(%rip), %rsi     # 0x31da4
leaq 0x230e3(%rip), %rcx     # 0x31e46
pushq $0x24
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::dis2(bal::Cnf*, unsigned int, unsigned int, unsigned int)
void dis2(Cnf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_1(formula != nullptr);
        _assert_level_1(literal_t__is_variable(r));
        _assert_level_1(literal_t__is_variable(x));
        _assert_level_1(literal_t__is_variable(y));
        formula->append_clause_l(x, y, literal_t__negated(r));
        formula->append_clause_l(literal_t__negated(x), r);
        formula->append_clause_l(literal_t__negated(y), r);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xedea
movl %esi, %r14d
leal -0x2(%r14), %eax
cmpl $-0x3, %eax
jae 0xee03
movl %edx, %r12d
leal -0x2(%r12), %eax
cmpl $-0x3, %eax
jae 0xee1c
movl %ecx, %ebx
leal -0x2(%rbx), %eax
cmpl $-0x3, %eax
jae 0xee35
movq %rdi, %r15
addq $0x78, %r15
movl %r14d, %ecx
xorl $0x1, %ecx
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %edx
callq 0xf2fa
xorl $0x1, %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0xf320
xorl $0x1, %ebx
movq %r15, %rdi
movl %ebx, %esi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf320
leaq 0x2db18(%rip), %rdi     # 0x3c909
leaq 0x22fac(%rip), %rsi     # 0x31da4
leaq 0x2315b(%rip), %rcx     # 0x31f5a
pushq $0x2b
jmp 0xee4c
leaq 0x23090(%rip), %rdi     # 0x31e9a
leaq 0x22f93(%rip), %rsi     # 0x31da4
leaq 0x23142(%rip), %rcx     # 0x31f5a
pushq $0x2c
jmp 0xee4c
leaq 0x230b7(%rip), %rdi     # 0x31eda
leaq 0x22f7a(%rip), %rsi     # 0x31da4
leaq 0x23129(%rip), %rcx     # 0x31f5a
pushq $0x2d
jmp 0xee4c
leaq 0x230de(%rip), %rdi     # 0x31f1a
leaq 0x22f61(%rip), %rsi     # 0x31da4
leaq 0x23110(%rip), %rcx     # 0x31f5a
pushq $0x2e
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::ch(bal::Cnf*, unsigned int, unsigned int, unsigned int, unsigned int)
void ch(Cnf* const formula, const literalid_t r, const literalid_t x, const literalid_t y, const literalid_t z) {
        _assert_level_1(formula != nullptr);
        _assert_level_1(literal_t__is_variable(r));
        _assert_level_1(literal_t__is_variable(x));
        _assert_level_1(literal_t__is_variable(y));
        _assert_level_1(literal_t__is_variable(z));
        formula->append_clause_l(literal_t__negated(x), y, literal_t__negated(r));
        formula->append_clause_l(x, z, literal_t__negated(r));
        formula->append_clause_l(literal_t__negated(x), literal_t__negated(y), r);
        formula->append_clause_l(x, literal_t__negated(z), r);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xef25
movl %ecx, %r13d
movl %esi, %ecx
leal -0x2(%rcx), %eax
cmpl $-0x3, %eax
jae 0xef3e
movl %edx, %ebx
leal -0x2(%rbx), %eax
cmpl $-0x3, %eax
jae 0xef57
leal -0x2(%r13), %eax
cmpl $-0x3, %eax
jae 0xef70
leal -0x2(%r8), %eax
cmpl $-0x3, %eax
movq %r8, -0x40(%rbp)
jae 0xef89
movq %rdi, %r12
addq $0x78, %r12
movl %ebx, %r14d
xorl $0x1, %r14d
movl %ecx, %r15d
xorl $0x1, %r15d
movq %r12, %rdi
movl %r14d, %esi
movq %rbx, -0x38(%rbp)
movl %r13d, %edx
movq %rcx, -0x30(%rbp)
movl %r15d, %ecx
callq 0xf2fa
movq %r12, %rdi
movl %ebx, %esi
movq -0x40(%rbp), %rbx
movl %ebx, %edx
movl %r15d, %ecx
callq 0xf2fa
xorl $0x1, %r13d
movq %r12, %rdi
movl %r14d, %esi
movl %r13d, %edx
movq -0x30(%rbp), %r14
movl %r14d, %ecx
callq 0xf2fa
xorl $0x1, %ebx
movq %r12, %rdi
movq -0x38(%rbp), %rsi
movl %ebx, %edx
movl %r14d, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf2fa
leaq 0x2d9dd(%rip), %rdi     # 0x3c909
leaq 0x22e71(%rip), %rsi     # 0x31da4
leaq 0x23074(%rip), %rcx     # 0x31fae
pushq $0x38
jmp 0xefa0
leaq 0x22f55(%rip), %rdi     # 0x31e9a
leaq 0x22e58(%rip), %rsi     # 0x31da4
leaq 0x2305b(%rip), %rcx     # 0x31fae
pushq $0x39
jmp 0xefa0
leaq 0x22f7c(%rip), %rdi     # 0x31eda
leaq 0x22e3f(%rip), %rsi     # 0x31da4
leaq 0x23042(%rip), %rcx     # 0x31fae
pushq $0x3a
jmp 0xefa0
leaq 0x22fa3(%rip), %rdi     # 0x31f1a
leaq 0x22e26(%rip), %rsi     # 0x31da4
leaq 0x23029(%rip), %rcx     # 0x31fae
pushq $0x3b
jmp 0xefa0
leaq 0x23083(%rip), %rdi     # 0x32013
leaq 0x22e0d(%rip), %rsi     # 0x31da4
leaq 0x23010(%rip), %rcx     # 0x31fae
pushq $0x3c
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::maj(bal::Cnf*, unsigned int, unsigned int, unsigned int, unsigned int)
void maj(Cnf* const formula, const literalid_t r, const literalid_t x, const literalid_t y, const literalid_t z) {
        _assert_level_1(formula != nullptr);
        _assert_level_1(literal_t__is_variable(r));
        _assert_level_1(literal_t__is_variable(x));
        _assert_level_1(literal_t__is_variable(y));
        _assert_level_1(literal_t__is_variable(z));
        formula->append_clause_l(x, y, literal_t__negated(r));
        formula->append_clause_l(x, z, literal_t__negated(r));
        formula->append_clause_l(y, z, literal_t__negated(r));
        formula->append_clause_l(literal_t__negated(x), literal_t__negated(y), r);
        formula->append_clause_l(literal_t__negated(x), literal_t__negated(z), r);
        formula->append_clause_l(literal_t__negated(y), literal_t__negated(z), r);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf08b
movl %ecx, %r15d
movl %esi, %ecx
leal -0x2(%rcx), %eax
cmpl $-0x3, %eax
jae 0xf0a4
movl %edx, %r13d
leal -0x2(%r13), %eax
cmpl $-0x3, %eax
jae 0xf0bd
leal -0x2(%r15), %eax
cmpl $-0x3, %eax
jae 0xf0d6
movl %r8d, %ebx
leal -0x2(%rbx), %eax
cmpl $-0x3, %eax
jae 0xf0ef
movq %rdi, %r12
addq $0x78, %r12
movl %ecx, %r14d
xorl $0x1, %r14d
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
movq %rcx, -0x30(%rbp)
movl %r14d, %ecx
callq 0xf2fa
movq %r12, %rdi
movl %r13d, %esi
movl %ebx, %edx
movl %r14d, %ecx
callq 0xf2fa
movq %r12, %rdi
movl %r15d, %esi
movl %ebx, %edx
movl %r14d, %ecx
callq 0xf2fa
xorl $0x1, %r13d
xorl $0x1, %r15d
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
movq -0x30(%rbp), %r14
movl %r14d, %ecx
callq 0xf2fa
xorl $0x1, %ebx
movq %r12, %rdi
movl %r13d, %esi
movl %ebx, %edx
movl %r14d, %ecx
callq 0xf2fa
movq %r12, %rdi
movl %r15d, %esi
movl %ebx, %edx
movl %r14d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf2fa
leaq 0x2d877(%rip), %rdi     # 0x3c909
leaq 0x22d0b(%rip), %rsi     # 0x31da4
leaq 0x22fb3(%rip), %rcx     # 0x32053
pushq $0x47
jmp 0xf106
leaq 0x22def(%rip), %rdi     # 0x31e9a
leaq 0x22cf2(%rip), %rsi     # 0x31da4
leaq 0x22f9a(%rip), %rcx     # 0x32053
pushq $0x48
jmp 0xf106
leaq 0x22e16(%rip), %rdi     # 0x31eda
leaq 0x22cd9(%rip), %rsi     # 0x31da4
leaq 0x22f81(%rip), %rcx     # 0x32053
pushq $0x49
jmp 0xf106
leaq 0x22e3d(%rip), %rdi     # 0x31f1a
leaq 0x22cc0(%rip), %rsi     # 0x31da4
leaq 0x22f68(%rip), %rcx     # 0x32053
pushq $0x4a
jmp 0xf106
leaq 0x22f1d(%rip), %rdi     # 0x32013
leaq 0x22ca7(%rip), %rsi     # 0x31da4
leaq 0x22f4f(%rip), %rcx     # 0x32053
pushq $0x4b
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::add(bal::Cnf&, unsigned int*, unsigned long, unsigned long, unsigned int, bool)
void add(Cnf& formula, literalid_t args[],
             const std::size_t input_size, const std::size_t output_size,
             const literalid_t constant, const bool b_2nd_c1) {
        _assert_level_0(input_size > 1);
        _assert_level_0(output_size >= 1 && output_size <= 3);
        _assert_level_0(literal_t__is_constant(constant) && (constant == 0 || constant == 1));
        _assert_level_0(!b_2nd_c1 || input_size == 3);
        _assert_level_0(!b_2nd_c1 || output_size == 2);
        
        bool is_2nd_carry = output_size == 3 && !b_2nd_c1;
        const addition_map_entry_t* p_map = b_2nd_c1 ? &ADD_31_C1_I0O2xC1_MAP : &(ADD_MAP[input_size][constant][is_2nd_carry]);
        
        formula.record_clauses(p_map->map, p_map->map_size, args, input_size, output_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x1, %rdx
jbe 0xf1ae
movq %rcx, %rax
movq %rdx, %r10
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
jae 0xf1c7
cmpl $0x2, %r8d
jae 0xf1e0
movq %rsi, %rcx
cmpq $0x3, %r10
sete %sil
movl %r9d, %edx
xorb $0x1, %dl
orb %dl, %sil
je 0xf1f9
cmpq $0x2, %rax
sete %sil
orb %dl, %sil
je 0xf212
xorl %edx, %edx
cmpq $0x3, %rax
sete %dl
movl %r8d, %esi
movq %r10, %r8
shlq $0x6, %r8
leaq 0x3e463(%rip), %r11     # 0x4d5e0
addq %r8, %r11
shlq $0x5, %rsi
addq %r11, %rsi
shll $0x4, %edx
addq %rsi, %rdx
leaq 0x3e43c(%rip), %r8      # 0x4d5d0
testb %r9b, %r9b
cmoveq %rdx, %r8
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %r10, %r8
movq %rax, %r9
popq %rbp
jmp 0xf342
leaq 0x22f04(%rip), %rdi     # 0x320b9
leaq 0x22be8(%rip), %rsi     # 0x31da4
leaq 0x22f05(%rip), %rcx     # 0x320c8
pushq $0x5a
jmp 0xf229
leaq 0x22f63(%rip), %rdi     # 0x32131
leaq 0x22bcf(%rip), %rsi     # 0x31da4
leaq 0x22eec(%rip), %rcx     # 0x320c8
pushq $0x5b
jmp 0xf229
leaq 0x22f6f(%rip), %rdi     # 0x32156
leaq 0x22bb6(%rip), %rsi     # 0x31da4
leaq 0x22ed3(%rip), %rcx     # 0x320c8
pushq $0x5c
jmp 0xf229
leaq 0x22fa5(%rip), %rdi     # 0x321a5
leaq 0x22b9d(%rip), %rsi     # 0x31da4
leaq 0x22eba(%rip), %rcx     # 0x320c8
pushq $0x5d
jmp 0xf229
leaq 0x22fa9(%rip), %rdi     # 0x321c2
leaq 0x22b84(%rip), %rsi     # 0x31da4
leaq 0x22ea1(%rip), %rcx     # 0x320c8
pushq $0x5e
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclausescontainer.hpp
// Function: bal::CnfClausesIndexedContainer<false>::append_clause(unsigned int const*, unsigned short)
inline void append_clause(const literalid_t* const literals, const clause_size_t literals_size) {
            this->reserve(_clauses_offset_size_memory_size(literals_size));
            uint32_t* const p_clause = _clauses_offset_clause(this->data_, this->size_);
            std::copy(literals, literals + literals_size, _clause_literals(p_clause));
            
            const clause_size_t clause_size = normalize_clause_literals(_clause_literals(p_clause), literals_size);
            clause_flags_t clause_flags = 0;
            
            // if necessary, unnegate the literals and calculate the aggregated flag
            if (_clause_size_is_aggregated(clause_size)) {
                uint16_t clause_bitmap = 0;
                for (auto i = 0; i < clause_size; i++) {
                    if (literal_t__is_unnegated(_clause_literal(p_clause, i))) {
                        clause_bitmap |= 0x1 << i;
                    } else {
                        literal_t__unnegate(_clause_literal(p_clause, i));
                    };
                };
                clause_flags = 0x1 << clause_bitmap;
            };
            _clause_header_set(p_clause, clause_flags, clause_size);
            
            insertion_point_t insertion_point;
            __insertion_point_t_init(insertion_point);
            append<false>(p_clause, insertion_point);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r13d
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
addq $0x8, %rdi
leal 0x4(%r13), %esi
callq 0xf470
movq 0x8(%rbx), %r14
movq %rbx, -0x38(%rbp)
movl 0x10(%rbx), %ebx
leaq (%r14,%rbx,4), %r15
addq $0x10, %r15
movzwl %r13w, %r12d
testl %r13d, %r13d
je 0xf288
leal (,%r12,4), %edx
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0xc440
leaq (%r14,%rbx,4), %r14
movq %r15, %rdi
movl %r12d, %esi
callq 0xf48a
xorl %esi, %esi
movzwl %ax, %edx
cmpw $0x4, %ax
ja 0xf2cd
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %rdx
je 0xf2c6
movl (%r15,%rax,4), %esi
testb $0x1, %sil
jne 0xf2be
orl $0x1, %esi
movl %esi, (%r15,%rax,4)
jmp 0xf2c1
btsl %eax, %ecx
incq %rax
jmp 0xf2a6
movl $0x10000, %esi          # imm = 0x10000
shll %cl, %esi
orl %edx, %esi
movl %esi, 0xc(%r14)
addq $0xc, %r14
leaq -0x48(%rbp), %rdx
orl $-0x1, 0x4(%rdx)
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xf540
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnf.hpp
// Function: bal::Cnf::record_clauses(char const* const*, unsigned long, unsigned int*, unsigned long, unsigned long)
void record_clauses(const char* const * const map, const std::size_t map_size,
                            literalid_t args[], const std::size_t input_size, const std::size_t output_size) {
            assert(map_size > 0 && input_size > 0 && output_size > 0);
            
            // create output literals
            for (auto i = 0; i < output_size; i++) {
                if (literal_t__is_unassigned(args[input_size + i])) {
                    args[input_size + i] = new_variable_literal();
                };
            };
            
            // buffer for clause literals
            literalid_t literalid_args[input_size + output_size];
            
            // record clauses one by one from the map
            for(auto i = 0; i < map_size; i++) {
                _assert_level_1(std::char_traits<char>::length(map[i]) == input_size + output_size);
                
                clause_size_t clause_size = 0;
                
                // record clause literals
                for (auto j = 0; j < input_size + output_size; j++) {
                    if (map[i][j] == '0' || map[i][j] == '1') {
                        literalid_args[clause_size++] = literal_t__negated_onlyif(args[j], map[i][j] == '0');
                    };
                };
                
                append_clause(literalid_args, clause_size);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdx, -0x40(%rbp)
testq %rdx, %rdx
je 0xf457
movq %r8, %r15
testq %r8, %r8
je 0xf457
movq %r9, %rbx
testq %r9, %r9
je 0xf457
movq %rcx, %r14
leaq (%rcx,%r15,4), %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0xf3a9
cmpl $-0x1, (%r12,%r13,4)
jne 0xf3a4
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, (%r12,%r13,4)
incq %r13
jmp 0xf38a
addq %r15, %rbx
leaq 0xf(,%rbx,4), %rax
andq $-0x10, %rax
movq %rsp, %r12
subq %rax, %r12
movq %r12, %rsp
addq $0x78, -0x30(%rbp)
xorl %r13d, %r13d
cmpq -0x40(%rbp), %r13
je 0xf42b
movq -0x38(%rbp), %rax
movq (%rax,%r13,8), %r15
movq %r15, %rdi
callq 0xc100
cmpq %rbx, %rax
jne 0xf43a
xorl %eax, %eax
xorl %ecx, %ecx
movzwl %cx, %edx
cmpq %rax, %rbx
je 0xf41a
movb (%r15,%rax), %sil
movl %esi, %edi
andb $-0x2, %dil
cmpb $0x30, %dil
jne 0xf415
xorl %edi, %edi
cmpb $0x30, %sil
sete %dil
xorl (%r14,%rax,4), %edi
leal 0x1(%rdx), %ecx
movl %edi, (%r12,%rdx,4)
incq %rax
jmp 0xf3e8
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0xf230
incq %r13
jmp 0xf3c9
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23e07(%rip), %rdi     # 0x33248
leaq 0x23d6a(%rip), %rsi     # 0x331b2
leaq 0x23d79(%rip), %rcx     # 0x331c8
pushq $0x67
popq %rdx
callq 0xc180
leaq 0x23d22(%rip), %rdi     # 0x33180
leaq 0x23d4d(%rip), %rsi     # 0x331b2
leaq 0x23d5c(%rip), %rcx     # 0x331c8
pushq $0x59
jmp 0xf451
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclausescontainer.hpp
// Function: bal::CnfClausesIndexedContainer<false>::normalize_clause_literals(unsigned int*, unsigned short)
inline static clause_size_t normalize_clause_literals(uint32_t* const literals, const clause_size_t literals_size) {
            assert(literals_size > 0);
            
            std::sort(literals, literals + literals_size);
            
            assert(literal_t__is_variable(literals[0]));
            clause_size_t validated_size = 1;
            for (auto i = 1; i < literals_size; i++) {
                assert(literal_t__is_variable(literals[i]));
                if (literals[i] == literals[validated_size - 1]) {
                    //warning(literals_size, literals, "ignoring duplicate literal");
                    continue;
                } else if (literal_t__is_negation_of(literals[i], literals[validated_size - 1])) {
                    //warning(literals_size, literals, "ignoring the clause, always satisfied");
                    return 0;
                } else {
                    if (validated_size < i) {
                        literals[validated_size] = literals[i];
                    };
                    validated_size++;
                };
            };
            
            return validated_size;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
je 0xf527
movq %rdi, %rbx
movzwl %si, %r14d
leaq (%rdi,%r14,4), %rsi
callq 0xf87c
movl (%rbx), %eax
incl %eax
cmpl $0x3, %eax
jb 0xf50e
movw $0x1, %ax
pushq $0x1
popq %rcx
cmpq %rcx, %r14
je 0xf4ec
movl (%rbx,%rcx,4), %edx
leal 0x1(%rdx), %esi
cmpl $0x2, %esi
jbe 0xf4f1
movzwl %ax, %esi
movl -0x4(%rbx,%rsi,4), %edi
cmpl %edi, %edx
je 0xf4e5
xorl %edx, %edi
cmpl $0x1, %edi
je 0xf4ea
cmpq %rsi, %rcx
jbe 0xf4e3
movl %edx, (%rbx,%rsi,4)
incl %eax
incq %rcx
jmp 0xf4b9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x23e89(%rip), %rdi     # 0x33381
leaq 0x23d9e(%rip), %rsi     # 0x3329d
leaq 0x23dbd(%rip), %rcx     # 0x332c3
pushq $0x47
popq %rdx
callq 0xc180
leaq 0x23e48(%rip), %rdi     # 0x3335d
leaq 0x23d81(%rip), %rsi     # 0x3329d
leaq 0x23da0(%rip), %rcx     # 0x332c3
pushq $0x44
jmp 0xf508
leaq 0x23d5d(%rip), %rdi     # 0x3328b
leaq 0x23d68(%rip), %rsi     # 0x3329d
leaq 0x23d87(%rip), %rcx     # 0x332c3
pushq $0x40
jmp 0xf508
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.hpp
// Function: int bal::compare_clauses<false>(unsigned int const*, unsigned int const*)
inline int compare_clauses(const uint32_t* lhs, const uint32_t* rhs) {
        
        __compare_clauses_++;
        
        clause_size_t lhs_size = _clause_size(lhs);
        clause_size_t rhs_size = _clause_size(rhs);
        
        if (compare_left_right) {
            const clause_size_t common_size = lhs_size > rhs_size ? rhs_size : lhs_size;
            for (auto i = 1; i <= common_size; i++) {
                if (lhs[i] != rhs[i]) {
                    return lhs[i] < rhs[i] ? -1 : 1;
                };
            };
        } else {
            while (lhs_size > 0 && rhs_size > 0) {
                if (lhs[lhs_size] != rhs[rhs_size]) {
                    return lhs[lhs_size] < rhs[rhs_size] ? -1 : 1;
                };
                lhs_size--;
                rhs_size--;
            };
        };
        
        // if all the corresponding literals match then the shorter clause is smaller
        return lhs_size < rhs_size ? -1 : (lhs_size == rhs_size ? 0 : 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x41248(%rip), %rax     # 0x512e4
incl (%rax)
movzwl (%rdi), %eax
movl $0x7fff, %edx           # imm = 0x7FFF
andl %edx, %eax
movzwl (%rsi), %ecx
andl %edx, %ecx
movl %ecx, %edx
movl %eax, %r8d
addw $-0x1, %dx
setb %r9b
addw $-0x1, %r8w
jae 0x100ea
testb %r9b, %r9b
je 0x100ea
movzwl %ax, %eax
movl (%rdi,%rax,4), %r9d
movzwl %cx, %eax
movl (%rsi,%rax,4), %r10d
movl %r8d, %eax
movl %edx, %ecx
cmpl %r10d, %r9d
je 0x100b2
xorl %eax, %eax
cmpl %r10d, %r9d
sbbl %eax, %eax
orl $0x1, %eax
jmp 0x100fa
xorl %edx, %edx
cmpw %ax, %cx
setne %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbel %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/binarytreeindex.hpp
// Function: bal::AvlTreesIndex<unsigned int, true, &int bal::compare_clauses<false>(unsigned int const*, unsigned int const*), &unsigned int bal::clause_index_variable_id<false>(unsigned int const*)>::_update_parent(unsigned int, unsigned int)
inline void _update_parent(const container_offset_t offset, const container_offset_t new_offset) {
            const container_offset_t* const p_item = _bti_item(this->data_, offset);
            const container_offset_t parent_offset = _bti_item_parent_offset(p_item);
            if (parent_offset != CONTAINER_END) {
                container_offset_t* const p_parent = _bti_item(this->data_, parent_offset);
                if (offset == _bti_item_right_offset(p_parent)) {
                    _bti_item_right_offset(p_parent) = new_offset;
                } else {
                    _assert_level_1(offset == _bti_item_left_offset(p_parent));
                    _bti_item_left_offset(p_parent) = new_offset;
                };
            } else {
                const container_offset_t instance_offset = instance_determiner(_bti_item_container_item(p_item));
                _assert_level_1(instance_offset < this->instances_.size_);
                _assert_level_1(this->instances_.data_[instance_offset] == offset);
                this->instances_.data_[instance_offset] = new_offset;
            };
            
            if (new_offset != CONTAINER_END) {
                _bti_parent_offset(this->data_, new_offset) = parent_offset;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movl %esi, %r8d
movl (%rax,%r8,4), %ecx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
cmpq %r9, %rcx
je 0x10156
cmpl %esi, 0x4(%rax,%rcx,4)
jne 0x1018b
leaq (%rax,%rcx,4), %rdi
addq $0x4, %rdi
jmp 0x10198
leaq (%rax,%r8,4), %r8
movl $0x7fff, %r9d           # imm = 0x7FFF
andl 0xc(%r8), %r9d
decl %r9d
movl 0x10(%r8,%r9,4), %r8d
shrl %r8d
decl %r8d
cmpl 0x38(%rdi), %r8d
jae 0x101a6
movq 0x30(%rdi), %rdi
movl %r8d, %r8d
cmpl %esi, (%rdi,%r8,4)
jne 0x101c5
leaq (%rdi,%r8,4), %rdi
jmp 0x10198
leaq (%rax,%rcx,4), %rdi
cmpl %esi, 0x8(%rdi)
jne 0x101e4
addq $0x8, %rdi
movl %edx, (%rdi)
cmpl $-0x1, %edx
je 0x101a4
movl %edx, %edx
movl %ecx, (%rax,%rdx,4)
popq %rbp
retq
leaq 0x23b74(%rip), %rdi     # 0x33d21
leaq 0x23579(%rip), %rsi     # 0x3372d
leaq 0x23a26(%rip), %rcx     # 0x33be1
movl $0xab, %edx
callq 0xc180
leaq 0x23b7e(%rip), %rdi     # 0x33d4a
leaq 0x2355a(%rip), %rsi     # 0x3372d
leaq 0x23a07(%rip), %rcx     # 0x33be1
movl $0xac, %edx
callq 0xc180
leaq 0x239d8(%rip), %rdi     # 0x33bc3
leaq 0x2353b(%rip), %rsi     # 0x3372d
leaq 0x239e8(%rip), %rcx     # 0x33be1
movl $0xa6, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::execute(bool, bal::FormulaProcessingMode)
bool CnfOptimizer::execute(const bool b_reindex_variables, const FormulaProcessingMode mode) {
        if (mode == fpmUnoptimized) {
            return assign_variable_values_unoptimized();
        } else {
            auto original_clauses_size = cnf_.clauses_size();
            
            bool result = base_execute(b_reindex_variables, mode);
            if (result) {
                std::cout << "Optimized: " << std::dec;
                std::cout << "(" << variables_.size() << ", " << original_clauses_size << ") -> ";
                std::cout << "(" << (signed long)cnf_.variables_size() - variables_.size() << ", ";
                std::cout << (signed long)cnf_.clauses_size() - original_clauses_size << ") -> ";
                std::cout << "(" << cnf_.variables_size() << ", " << cnf_.clauses_size() << ")";
                std::cout << std::endl;
            };
            return result;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
je 0x10438
movl %edx, %r14d
movl %esi, %r12d
movq 0x8(%rbx), %rdi
addq $0x78, %rdi
callq 0x107d8
movl %eax, %r15d
movzbl %r12b, %esi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x1085a
testb %al, %al
je 0x1044e
movq 0x40cbb(%rip), %r14     # 0x50fb0
leaq 0x23b5a(%rip), %rsi     # 0x33e56
movq %r14, %rdi
callq 0xc290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x23b42(%rip), %r12     # 0x33e62
movq %r14, %rdi
movq %r12, %rsi
callq 0xc290
movq 0xb8(%rbx), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0xc190
leaq 0x27fd2(%rip), %rsi     # 0x38316
movq %rax, %rdi
callq 0xc290
movl %r15d, %r13d
movq %rax, %rdi
movq %r13, %rsi
callq 0xc190
leaq 0x23b03(%rip), %r15     # 0x33e64
movq %rax, %rdi
movq %r15, %rsi
callq 0xc290
movq %r14, %rdi
movq %r12, %rsi
callq 0xc290
movq %rax, %r12
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, %esi
movq 0xb8(%rbx), %rax
movl 0x8(%rax), %eax
subq %rax, %rsi
movq %r12, %rdi
callq 0xc280
movq %rax, %rdi
leaq 0x27f71(%rip), %r12     # 0x38316
movq %r12, %rsi
callq 0xc290
movq 0x8(%rbx), %rdi
addq $0x78, %rdi
callq 0x107d8
movl %eax, %esi
subq %r13, %rsi
movq %r14, %rdi
callq 0xc280
movq %rax, %rdi
movq %r15, %rsi
callq 0xc290
movq %r14, %rdi
leaq 0x23a86(%rip), %rsi     # 0x33e62
callq 0xc290
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, %esi
movq %r15, %rdi
callq 0xc190
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
movq %rax, %r15
movq 0x8(%rbx), %rdi
addq $0x78, %rdi
callq 0x107d8
movl %eax, %esi
movq %r15, %rdi
callq 0xc190
leaq 0x2dde7(%rip), %rsi     # 0x3e20b
movq %rax, %rdi
callq 0xc290
movq %r14, %rdi
callq 0xc120
movb $0x1, %al
jmp 0x10450
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10652
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfVariableEvaluator::execute()
bool CnfVariableEvaluator::execute() {
        clauses_.transaction_begin();
        bool result = (evaluate_clauses() != erConflict);
        clauses_.transaction_rollback();
        
        if (result) {
            // update variables to resolve any sequenced references
            // lighter version of update_variables() with no reindexing
            literalid_t* var_values = variables_.data();
            
            // go through the variables sequentially
            for (variableid_t i = 0; i < variables_.size(); i++) {
                const literalid_t value = var_values[i];
                if (literal_t__is_variable(value) && i != literal_t__variable_id(value)) {
                    _assert_level_1(i > literal_t__variable_id(value));
                    const literalid_t new_value = var_values[literal_t__variable_id(value)];
                    _assert_level_1(!literal_t__is_unassigned(new_value));
                    var_values[i] = literal_t__substitute_literal(value, new_value);
                };
            };
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x109ec
movq %r14, %rdi
callq 0x10a2a
movl %eax, %ebx
movq 0x10(%r14), %rdi
callq 0x10b84
cmpl $0x4, %ebx
je 0x104cf
movq 0xb8(%r14), %rax
movq (%rax), %rcx
xorl %edx, %edx
movl 0x8(%rax), %esi
cmpq %rsi, %rdx
jae 0x104cf
movl (%rcx,%rdx,4), %esi
leal -0x2(%rsi), %edi
cmpl $-0x4, %edi
ja 0x104ca
movl %esi, %edi
shrl %edi
decl %edi
cmpq %rdi, %rdx
je 0x104ca
jbe 0x104da
movl (%rcx,%rdi,4), %edi
cmpl $-0x1, %edi
je 0x104f9
andl $0x1, %esi
xorl %edi, %esi
xorl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
jmp 0x10497
cmpl $0x4, %ebx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x23989(%rip), %rdi     # 0x33e6a
leaq 0x23920(%rip), %rsi     # 0x33e08
leaq 0x239a7(%rip), %rcx     # 0x33e96
movl $0x541, %edx            # imm = 0x541
callq 0xc180
leaq 0x239c8(%rip), %rdi     # 0x33ec8
leaq 0x23901(%rip), %rsi     # 0x33e08
leaq 0x23988(%rip), %rcx     # 0x33e96
movl $0x543, %edx            # imm = 0x543
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfVariableNormalizer::execute(bool)
bool CnfVariableNormalizer::execute(const bool b_reindex_variables) {
        cnf_.named_variables_assign_negations(variables_);
        
        // index is needed for checking if a variable is used
        build_clauses_index();
        const variableid_t new_variables_size = update_variables(b_reindex_variables);
        if (b_reindex_variables && new_variables_size != cnf_.variables_size()) {
            set_variables_size(new_variables_size);
        };
            
        // nothe that rebuild_clauses() invalidates clauses_index_ and processed_offset_
        // since these are not used below, its fine
        rebuild_clauses<CnfOptimizer, &CnfOptimizer::_update_clause_variables>(this, false);
        cnf_.named_variables_update(variables_);
        
        // it is possible that some negated references remain
        // since the same variable may appear straight and complemented
        // across named variables
        // for those, need to introduce new variables
        
        for (auto vit = named_variables_.begin(); vit != named_variables_.end(); vit++) {
            literalid_t* const template_ = vit->second.data();
            for (auto j = 0; j < vit->second.size(); j++) {
                if (literal_t__is_variable(template_[j]) && literal_t__is_negation(template_[j])) {
                    literalid_t value = cnf_.new_variable_literal();
                    clauses_.append_clause_l(value, literal_t__negated(template_[j]));
                    clauses_.append_clause_l(literal_t__negated(value), template_[j]);
                    template_[j] = value;
                };
            };
        };
        
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0xb8(%rbx), %rsi
callq 0x2e3e2
movq %rbx, %rdi
callq 0x10bd6
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10be4
testl %r15d, %r15d
je 0x10571
movl %eax, %r14d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
cmpl %eax, %r14d
je 0x10571
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10dcc
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10dda
movq 0x8(%rbx), %rdi
movq 0xb8(%rbx), %rsi
callq 0x2e31e
movq 0x28(%rbx), %rax
movq 0x18(%rax), %r14
addq $0x8, %rax
cmpq %rax, %r14
je 0x1060e
movq 0x40(%r14), %r12
xorl %r13d, %r13d
movl 0x48(%r14), %eax
cmpq %rax, %r13
jae 0x105fd
movl (%r12,%r13,4), %eax
leal -0x2(%rax), %ecx
cmpl $-0x3, %ecx
setae %cl
orb %cl, %al
testb $0x1, %al
jne 0x105f8
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %r15d
movq 0x10(%rbx), %rdi
movl (%r12,%r13,4), %edx
xorl $0x1, %edx
movl %eax, %esi
callq 0xf320
movq 0x10(%rbx), %rdi
movl %r15d, %esi
xorl $0x1, %esi
movl (%r12,%r13,4), %edx
callq 0xf320
movl %r15d, (%r12,%r13,4)
incq %r13
jmp 0x105a6
movq %r14, %rdi
callq 0xc1b0
movq %rax, %r14
movq 0x28(%rbx), %rax
jmp 0x10596
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclausescontainer.hpp
// Function: unsigned int const bal::CnfClausesIndexedContainer<false>::clauses_size<(unsigned short)0, false, false>() const
const clauses_size_t clauses_size() const {
            clauses_size_t result = 0;
            for (auto it: clauses()) {
                const uint32_t* const p_clause = _clauses_offset_item_clause(it);
                const clause_size_t current_clause_size = _clause_size(p_clause);
                if (clause_size == 0 || clause_size == current_clause_size) {
                    if(!aggregated && _clause_size_is_aggregated(current_clause_size)) {
                        result += get_cardinality_uint16(_clause_flags(p_clause)) * (literals ? current_clause_size : 1);
                    } else {
                        result += literals ? current_clause_size : 1;
                    };
                };
            };
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq -0x28(%rbp), %r14
movq %rdi, (%r14)
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x115a2
movq (%r14), %rax
movl 0x38(%rax), %r15d
xorl %r14d, %r14d
pushq $0x1
popq %r12
cmpl %r15d, -0x30(%rbp)
jne 0x10817
cmpl $-0x1, -0x2c(%rbp)
je 0x1084a
movq %rbx, %rdi
callq 0x115c0
movl 0xc(%rax), %edi
movl %edi, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
movl %r12d, %eax
cmpl $0x4, %ecx
ja 0x1083d
shrl $0x10, %edi
callq 0x1533e
movzwl %ax, %eax
addl %eax, %r14d
movq %rbx, %rdi
callq 0x11fa0
jmp 0x1080b
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq