LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/gasparfm[P]anapache/lib/gcommon/gstr.cpp
// Function: GCommon::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
std::string replace(std::string source, std::string from, std::string to, int offset, int times)
  {
    int total = 0;
    std::string::size_type pos=offset;

    do
      {
	pos = source.find(from, pos);

	if (pos == std::string::npos)
	  break;

	source.replace(pos, from.length(), to);
	pos+=to.size();

      } while ( (times==0) || (++total<times) );

    return source;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movslq %r8d, %r13
cmpl $0x2, %r9d
movl $0x1, %eax
cmovgel %r9d, %eax
movl %eax, 0xc(%rsp)
xorl %r14d, %r14d
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3580
cmpq $-0x1, %rax
je 0x91b4
movq %rax, %r13
movq 0x8(%r12), %rdx
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33d0
addq 0x8(%r15), %r13
testl %ebp, %ebp
je 0x916e
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x916e
movq 0x10(%rsp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rsi
cmpq %rsi, %rdx
je 0x91d8
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x91de
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::initialize()
void Anf::initialize() {
        Formula::initialize();
        symbols_.clear();
        terms_.clear();
        equations_.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3af24
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0xce2e
movq %rax, 0x80(%rbx)
movq 0x90(%rbx), %rax
cmpq %rax, 0x98(%rbx)
je 0xce45
movq %rax, 0x98(%rbx)
movq 0xa8(%rbx), %rax
cmpq %rax, 0xb0(%rbx)
je 0xce5c
movq %rax, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::append_equation()
void Anf::append_equation() {
        assert(terms_.size() < UINT32_MAX);
        equations_.push_back((uint32_t)terms_.size());
        // add the constant term
        terms_.push_back((uint32_t)symbols_.size());
        symbols_.push_back(literal_t__constant(0));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x98(%rdi), %rsi
movq %rsi, %rcx
subq 0x90(%rdi), %rcx
sarq $0x2, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rcx
jae 0xcf49
movq %rdi, %rbx
movl %ecx, -0x10(%rbp)
movq 0xb0(%rdi), %rax
cmpq 0xb8(%rdi), %rax
je 0xceb2
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0xb0(%rbx)
jmp 0xcecc
leaq 0xa8(%rbx), %rdi
leaq -0x10(%rbp), %rdx
movq %rax, %rsi
callq 0xe7da
movq 0x98(%rbx), %rsi
movq 0x80(%rbx), %rax
movq %rax, %rcx
subq 0x78(%rbx), %rcx
shrq $0x2, %rcx
movl %ecx, -0xc(%rbp)
cmpq 0xa0(%rbx), %rsi
je 0xcef9
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x98(%rbx)
jmp 0xcf10
leaq 0x90(%rbx), %rdi
leaq -0xc(%rbp), %rdx
callq 0xe7da
movq 0x80(%rbx), %rax
cmpq 0x88(%rbx), %rax
je 0xcf2c
movl $0x0, (%rax)
addq $0x4, %rax
movq %rax, 0x80(%rbx)
jmp 0xcf42
addq $0x78, %rbx
leaq 0x32a29(%rip), %rdx     # 0x3f960
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe912
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x320b4(%rip), %rdi     # 0x3f004
leaq 0x320c8(%rip), %rsi     # 0x3f01f
leaq 0x320d3(%rip), %rcx     # 0x3f031
movl $0x34, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anf.cpp
// Function: bal::Anf::is_incomplete_last_equation_() const
void Anf::is_incomplete_last_equation_() const {
        assert(equations_.size() > 0);
        assert(terms_size_(equations_.size() - 1) > 0);
        assert(symbols_size_(equations_[equations_.size() - 1]) == 1);
        assert(literal_t__is_constant(symbols_[terms_[equations_[equations_.size() - 1]]]));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb0(%rdi), %rax
cmpq 0xa8(%rdi), %rax
je 0xe56e
movq 0x98(%rdi), %rcx
subq 0x90(%rdi), %rcx
sarq $0x2, %rcx
movl -0x4(%rax), %eax
cmpq %rax, %rcx
je 0xe58d
movq 0x90(%rdi), %rcx
movq 0x98(%rdi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
decq %rdx
cmpq %rax, %rdx
jne 0xe552
movq 0x80(%rdi), %rdx
subq 0x78(%rdi), %rdx
sarq $0x2, %rdx
jmp 0xe556
movl 0x4(%rcx,%rax,4), %edx
movl (%rcx,%rax,4), %eax
subq %rax, %rdx
cmpq $0x1, %rdx
jne 0xe5ac
movq 0x78(%rdi), %rcx
cmpl $0x2, (%rcx,%rax,4)
jae 0xe5cb
popq %rbp
retq
leaq 0x30fa3(%rip), %rdi     # 0x3f518
leaq 0x30aa3(%rip), %rsi     # 0x3f01f
leaq 0x30fab(%rip), %rcx     # 0x3f52e
movl $0x16, %edx
callq 0xb180
leaq 0x30fce(%rip), %rdi     # 0x3f562
leaq 0x30a84(%rip), %rsi     # 0x3f01f
leaq 0x30f8c(%rip), %rcx     # 0x3f52e
movl $0x17, %edx
callq 0xb180
leaq 0x30fd6(%rip), %rdi     # 0x3f589
leaq 0x30a65(%rip), %rsi     # 0x3f01f
leaq 0x30f6d(%rip), %rcx     # 0x3f52e
movl $0x18, %edx
callq 0xb180
leaq 0x30fed(%rip), %rdi     # 0x3f5bf
leaq 0x30a46(%rip), %rsi     # 0x3f01f
leaq 0x30f4e(%rip), %rcx     # 0x3f52e
movl $0x19, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::eor(bal::Anf*, unsigned int, unsigned int const*, unsigned long)
void eor(Anf* const formula, const literalid_t r, const literalid_t args[], const std::size_t args_size) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        for (auto i = 0; i < args_size; i++) {
            _assert_level_0(literal_t__is_variable(args[i]));
            formula->append_equation_term(args[i]);
        };
        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
testq %rdi, %rdi
je 0xea77
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xea96
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
callq 0xce64
testq %r15, %r15
je 0xea38
xorl %r13d, %r13d
movl (%r12,%r13,4), %esi
leal 0x1(%rsi), %eax
cmpl $0x2, %eax
jbe 0xea58
movq %r14, %rdi
callq 0xd46a
incq %r13
cmpq %r13, %r15
jne 0xea1c
xorl %edx, %edx
cmpl $-0x1, %ebx
sete %dl
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4b0
leaq 0x30feb(%rip), %rdi     # 0x3fa4a
leaq 0x30f09(%rip), %rsi     # 0x3f96f
leaq 0x30f1c(%rip), %rcx     # 0x3f989
movl $0x13, %edx
callq 0xb180
leaq 0x3bc84(%rip), %rdi     # 0x4a702
leaq 0x30eea(%rip), %rsi     # 0x3f96f
leaq 0x30efd(%rip), %rcx     # 0x3f989
movl $0xf, %edx
callq 0xb180
leaq 0x30f41(%rip), %rdi     # 0x3f9de
leaq 0x30ecb(%rip), %rsi     # 0x3f96f
leaq 0x30ede(%rip), %rcx     # 0x3f989
movl $0x10, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::con2(bal::Anf*, unsigned int, unsigned int, unsigned int)
void con2(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x, y);
        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
testq %rdi, %rdi
je 0xeb10
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xeb2f
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xce64
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xd48c
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4b0
leaq 0x3bbeb(%rip), %rdi     # 0x4a702
leaq 0x30e51(%rip), %rsi     # 0x3f96f
leaq 0x30f71(%rip), %rcx     # 0x3fa96
movl $0x1a, %edx
callq 0xb180
leaq 0x30ea8(%rip), %rdi     # 0x3f9de
leaq 0x30e32(%rip), %rsi     # 0x3f96f
leaq 0x30f52(%rip), %rcx     # 0x3fa96
movl $0x1b, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::dis2(bal::Anf*, unsigned int, unsigned int, unsigned int)
void dis2(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x);
        formula->append_equation_term(y);
        formula->append_equation_term(x, y);
        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
testq %rdi, %rdi
je 0xebbf
movl %esi, %ebx
cmpl $0x1, %esi
jbe 0xebde
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xce64
movq %r14, %rdi
movl %r12d, %esi
callq 0xd46a
movq %r14, %rdi
movl %r15d, %esi
callq 0xd46a
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xd48c
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4b0
leaq 0x3bb3c(%rip), %rdi     # 0x4a702
leaq 0x30da2(%rip), %rsi     # 0x3f96f
leaq 0x30f16(%rip), %rcx     # 0x3faea
movl $0x23, %edx
callq 0xb180
leaq 0x30df9(%rip), %rdi     # 0x3f9de
leaq 0x30d83(%rip), %rsi     # 0x3f96f
leaq 0x30ef7(%rip), %rcx     # 0x3faea
movl $0x24, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::maj(bal::Anf*, unsigned int, unsigned int, unsigned int, unsigned int)
void maj(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y, const literalid_t z) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x, y);
        formula->append_equation_term(x, z);
        formula->append_equation_term(y, z);
        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
testq %rdi, %rdi
je 0xec80
movl %esi, %ebx
movl %r8d, -0x2c(%rbp)
cmpl $0x1, %esi
jbe 0xec9f
movl %ecx, %r12d
movl %edx, %r15d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xce64
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0xd48c
movq %r14, %rdi
movl %r15d, %esi
movl -0x2c(%rbp), %r15d
movl %r15d, %edx
callq 0xd48c
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xd48c
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4b0
leaq 0x3ba7b(%rip), %rdi     # 0x4a702
leaq 0x30ce1(%rip), %rsi     # 0x3f96f
leaq 0x30ea9(%rip), %rcx     # 0x3fb3e
movl $0x2e, %edx
callq 0xb180
leaq 0x30d38(%rip), %rdi     # 0x3f9de
leaq 0x30cc2(%rip), %rsi     # 0x3f96f
leaq 0x30e8a(%rip), %rcx     # 0x3fb3e
movl $0x2f, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anfencoding.cpp
// Function: bal::ch(bal::Anf*, unsigned int, unsigned int, unsigned int, unsigned int)
void ch(Anf* const formula, const literalid_t r, const literalid_t x, const literalid_t y, const literalid_t z) {
        _assert_level_0(formula != nullptr);
        _assert_level_0(literal_t__is_variable(r) || literal_t__is_unassigned(r));
        formula->append_equation();
        formula->append_equation_term(x, y);
        formula->append_equation_term(x, z);
        formula->append_equation_term(z);
        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
testq %rdi, %rdi
je 0xed35
movl %esi, %ebx
movl %ecx, -0x2c(%rbp)
cmpl $0x1, %esi
jbe 0xed54
movl %r8d, %r15d
movl %edx, %r12d
movq %rdi, %r14
xorl %r13d, %r13d
cmpl $-0x1, %ebx
sete %r13b
callq 0xce64
movq %r14, %rdi
movl %r12d, %esi
movl -0x2c(%rbp), %edx
callq 0xd48c
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xd48c
movq %r14, %rdi
movl %r15d, %esi
callq 0xd46a
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd4b0
leaq 0x3b9c6(%rip), %rdi     # 0x4a702
leaq 0x30c2c(%rip), %rsi     # 0x3f96f
leaq 0x30e5a(%rip), %rcx     # 0x3fba4
movl $0x39, %edx
callq 0xb180
leaq 0x30c83(%rip), %rdi     # 0x3f9de
leaq 0x30c0d(%rip), %rsi     # 0x3f96f
leaq 0x30e3b(%rip), %rcx     # 0x3fba4
movl $0x3a, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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 0xee6e
movl %r9d, %r12d
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
movl 0x10(%rbp), %r13d
callq 0xce64
movq %r14, %rdi
movl %r15d, %esi
callq 0xd46a
movq %r14, %rdi
movl %ebx, %esi
callq 0xd46a
movq %r14, %rdi
movl %r12d, %esi
callq 0xd46a
movq %r14, %rdi
movl %r13d, %esi
callq 0xd46a
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0xd48c
movq %r14, %rdi
movl %r12d, %esi
movl -0x2c(%rbp), %ebx
movl %ebx, %edx
callq 0xd48c
movq %r14, %rdi
movl %r13d, %esi
movl %ebx, %edx
callq 0xd48c
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 0xd4b0
leaq 0x3b88d(%rip), %rdi     # 0x4a702
leaq 0x30af3(%rip), %rsi     # 0x3f96f
leaq 0x30e13(%rip), %rcx     # 0x3fc96
movl $0x4e, %edx
callq 0xb180
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %eax, %eax
movl %eax, 0x4d450(%rip)     # 0x5c2ec
movl %eax, 0x4d44e(%rip)     # 0x5c2f0
movl %eax, 0x4d44c(%rip)     # 0x5c2f4
movl %eax, 0x4d44a(%rip)     # 0x5c2f8
callq 0xb050
movq %rax, 0x4d446(%rip)     # 0x5c300
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
cmpw $0x0, (%rdi)
leaq 0x30d61(%rip), %rax     # 0x3fd5c
leaq 0x36b4c(%rip), %rsi     # 0x45b4e
cmovnsq %rax, %rsi
movq 0x4cfa3(%rip), %rbx     # 0x5bfb0
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb320
leaq 0x373a8(%rip), %rsi     # 0x463c9
movl $0x2, %edx
movq %rbx, %rdi
callq 0xb320
leaq 0x30d29(%rip), %rdx     # 0x3fd5e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf214
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4cf27(%rip), %r15     # 0x5bfb0
leaq 0x30cd1(%rip), %rsi     # 0x3fd61
movl $0x8, %edx
movq %r15, %rdi
callq 0xb320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
leaq 0x30c9f(%rip), %rsi     # 0x3fd6a
movl $0xa, %edx
movq %r15, %rdi
callq 0xb320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
movq %rbx, %rdi
callq 0xefe6
leaq 0x30c67(%rip), %rsi     # 0x3fd75
movl $0xc, %edx
movq %r15, %rdi
callq 0xb320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
movzwl (%rbx), %eax
testl $0x7fff, %eax           # imm = 0x7FFF
je 0xf205
xorl %r13d, %r13d
movl 0x4(%rbx,%r13,4), %eax
movl %eax, %ecx
leal -0x2(%rcx), %edx
cmpl $-0x4, %edx
ja 0xf188
movl %ecx, %edx
shrl %edx
movl -0x4(%r14,%rdx,4), %edx
movl %ecx, %r15d
andl $0x1, %r15d
xorl %edx, %r15d
xorl $0x1, %r15d
cmpl $-0x1, %edx
cmovnel %r15d, %edx
cmpl %ecx, %edx
movl %edx, %ecx
jne 0xf15a
jmp 0xf18b
movl %ecx, %r15d
orl $0x1, %eax
movl %eax, -0x30(%rbp)
movq 0x4ce18(%rip), %rdi     # 0x5bfb0
leaq -0x30(%rbp), %rsi
callq 0xf3a7
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
leaq 0x30bcf(%rip), %rsi     # 0x3fd82
callq 0xb320
movl %r15d, -0x2c(%rbp)
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
callq 0xf3a7
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r12, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
incq %r13
movl (%rbx), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
cmpq %rax, %r13
jb 0xf153
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf3d7
cmpl $0x1, %esi
leaq 0x309c3(%rip), %rax     # 0x3fd88
leaq 0x309c0(%rip), %rsi     # 0x3fd8c
cmoveq %rax, %rsi
movl $0x3, %edx
jmp 0xf3e8
cmpl $-0x1, %esi
jne 0xf3f2
leaq 0x309a3(%rip), %rsi     # 0x3fd86
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb320
jmp 0xf42e
testb $0x1, %sil
jne 0xf40f
leaq 0x31b63(%rip), %rsi     # 0x40f62
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb320
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 0xb190
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf4f2
movq %rcx, %rbx
leaq -0x2(%rcx), %rax
cmpq $0x1e, %rax
jae 0xf511
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
xorl %eax, %eax
xorl %esi, %esi
movl %esi, %ecx
xorl %edx, %edx
btl %eax, %r12d
setb %dl
movl (%r14,%rax,4), %esi
xorl %edx, %esi
movl %esi, (%r13,%rax,4)
movl %edx, %esi
xorl %ecx, %esi
incq %rax
cmpq %rax, %rbx
jne 0xf495
xorl %eax, %eax
cmpl %ecx, %edx
sete %al
xorl -0x2c(%rbp), %eax
movl %eax, (%r13,%rbx,4)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0xfc72
incl %r12d
movl %r12d, %eax
movl %ebx, %ecx
shrl %cl, %eax
testl %eax, %eax
je 0xf491
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b209(%rip), %rdi     # 0x4a702
leaq 0x30890(%rip), %rsi     # 0x3fd90
leaq 0x308ac(%rip), %rcx     # 0x3fdb3
movl $0x10, %edx
callq 0xb180
leaq 0x308f0(%rip), %rdi     # 0x3fe08
leaq 0x30871(%rip), %rsi     # 0x3fd90
leaq 0x3088d(%rip), %rcx     # 0x3fdb3
movl $0x11, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xf5f7
movl %esi, %r15d
leal -0x2(%r15), %eax
cmpl $-0x3, %eax
jae 0xf616
movl %edx, %r12d
leal -0x2(%r12), %eax
cmpl $-0x3, %eax
jae 0xf635
movl %ecx, %r14d
leal -0x2(%r14), %eax
cmpl $-0x3, %eax
jae 0xf654
movq %rdi, %rbx
addq $0x78, %rbx
movl %r12d, %eax
xorl $0x1, %eax
movl %r14d, %ecx
xorl $0x1, %ecx
leaq -0x34(%rbp), %r13
movl %eax, (%r13)
movl %ecx, 0x4(%r13)
movl %r15d, 0x8(%r13)
movq %rbx, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq 0xfc72
xorl $0x1, %r15d
movl %r12d, (%r13)
movl %r15d, 0x4(%r13)
leaq -0x34(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0xfc72
movl %r14d, (%r12)
movl %r15d, 0x4(%r12)
leaq -0x34(%rbp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0xfc72
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b104(%rip), %rdi     # 0x4a702
leaq 0x3078b(%rip), %rsi     # 0x3fd90
leaq 0x30826(%rip), %rcx     # 0x3fe32
movl $0x21, %edx
callq 0xb180
leaq 0x30869(%rip), %rdi     # 0x3fe86
leaq 0x3076c(%rip), %rsi     # 0x3fd90
leaq 0x30807(%rip), %rcx     # 0x3fe32
movl $0x22, %edx
callq 0xb180
leaq 0x3088a(%rip), %rdi     # 0x3fec6
leaq 0x3074d(%rip), %rsi     # 0x3fd90
leaq 0x307e8(%rip), %rcx     # 0x3fe32
movl $0x23, %edx
callq 0xb180
leaq 0x308ab(%rip), %rdi     # 0x3ff06
leaq 0x3072e(%rip), %rsi     # 0x3fd90
leaq 0x307c9(%rip), %rcx     # 0x3fe32
movl $0x24, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xf738
movl %esi, %r15d
leal -0x2(%r15), %eax
cmpl $-0x3, %eax
jae 0xf757
movl %edx, %r12d
leal -0x2(%r12), %eax
cmpl $-0x3, %eax
jae 0xf776
movl %ecx, %r14d
leal -0x2(%r14), %eax
cmpl $-0x3, %eax
jae 0xf795
movq %rdi, %rbx
addq $0x78, %rbx
movl %r15d, %eax
xorl $0x1, %eax
leaq -0x34(%rbp), %r13
movl %r12d, (%r13)
movl %r14d, 0x4(%r13)
movl %eax, 0x8(%r13)
movq %rbx, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq 0xfc72
xorl $0x1, %r12d
movl %r12d, (%r13)
movl %r15d, 0x4(%r13)
leaq -0x34(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0xfc72
xorl $0x1, %r14d
movl %r14d, (%r12)
movl %r15d, 0x4(%r12)
leaq -0x34(%rbp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0xfc72
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3afc3(%rip), %rdi     # 0x4a702
leaq 0x3064a(%rip), %rsi     # 0x3fd90
leaq 0x307f9(%rip), %rcx     # 0x3ff46
movl $0x2b, %edx
callq 0xb180
leaq 0x30728(%rip), %rdi     # 0x3fe86
leaq 0x3062b(%rip), %rsi     # 0x3fd90
leaq 0x307da(%rip), %rcx     # 0x3ff46
movl $0x2c, %edx
callq 0xb180
leaq 0x30749(%rip), %rdi     # 0x3fec6
leaq 0x3060c(%rip), %rsi     # 0x3fd90
leaq 0x307bb(%rip), %rcx     # 0x3ff46
movl $0x2d, %edx
callq 0xb180
leaq 0x3076a(%rip), %rdi     # 0x3ff06
leaq 0x305ed(%rip), %rsi     # 0x3fd90
leaq 0x3079c(%rip), %rcx     # 0x3ff46
movl $0x2e, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
testq %rdi, %rdi
je 0xf8bc
leal -0x2(%rsi), %eax
cmpl $-0x3, %eax
jae 0xf8db
leal -0x2(%rdx), %eax
cmpl $-0x3, %eax
jae 0xf8fa
movl %ecx, %r13d
leal -0x2(%r13), %eax
cmpl $-0x3, %eax
jae 0xf919
leal -0x2(%r8), %eax
cmpl $-0x3, %eax
movq %r8, -0x58(%rbp)
jae 0xf938
addq $0x78, %rdi
movl %edx, %r12d
xorl $0x1, %r12d
movl %esi, %r14d
xorl $0x1, %r14d
leaq -0x34(%rbp), %r15
movl %r12d, (%r15)
movl %r13d, 0x4(%r15)
movl %r14d, 0x8(%r15)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %r15, %rsi
movq %rdx, %rbx
movq %rdx, -0x50(%rbp)
movl $0x3, %edx
callq 0xfc72
movl %ebx, (%r15)
movq -0x58(%rbp), %rbx
movl %ebx, 0x4(%r15)
movl %r14d, 0x8(%r15)
movq -0x40(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0xfc72
xorl $0x1, %r13d
movl %r12d, (%r15)
movl %r13d, 0x4(%r15)
movq -0x48(%rbp), %r12
movl %r12d, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0xfc72
xorl $0x1, %ebx
movq -0x50(%rbp), %rax
movl %eax, (%r15)
movl %ebx, 0x4(%r15)
movl %r12d, 0x8(%r15)
leaq -0x34(%rbp), %rsi
movq %r14, %rdi
movl $0x3, %edx
callq 0xfc72
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ae3f(%rip), %rdi     # 0x4a702
leaq 0x304c6(%rip), %rsi     # 0x3fd90
leaq 0x306c9(%rip), %rcx     # 0x3ff9a
movl $0x38, %edx
callq 0xb180
leaq 0x305a4(%rip), %rdi     # 0x3fe86
leaq 0x304a7(%rip), %rsi     # 0x3fd90
leaq 0x306aa(%rip), %rcx     # 0x3ff9a
movl $0x39, %edx
callq 0xb180
leaq 0x305c5(%rip), %rdi     # 0x3fec6
leaq 0x30488(%rip), %rsi     # 0x3fd90
leaq 0x3068b(%rip), %rcx     # 0x3ff9a
movl $0x3a, %edx
callq 0xb180
leaq 0x305e6(%rip), %rdi     # 0x3ff06
leaq 0x30469(%rip), %rsi     # 0x3fd90
leaq 0x3066c(%rip), %rcx     # 0x3ff9a
movl $0x3b, %edx
callq 0xb180
leaq 0x306c0(%rip), %rdi     # 0x3ffff
leaq 0x3044a(%rip), %rsi     # 0x3fd90
leaq 0x3064d(%rip), %rcx     # 0x3ff9a
movl $0x3c, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfbd7
movq %rcx, %rax
movq %rdx, %r10
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
jae 0xfbf6
cmpl $0x2, %r8d
jae 0xfc15
movq %rsi, %rcx
cmpq $0x3, %r10
sete %sil
movl %r9d, %edx
xorb $0x1, %dl
orb %dl, %sil
je 0xfc34
cmpq $0x2, %rax
sete %sil
orb %dl, %sil
je 0xfc53
xorl %edx, %edx
cmpq $0x3, %rax
sete %dl
movl %r8d, %esi
movq %r10, %r8
shlq $0x6, %r8
leaq 0x492ba(%rip), %r11     # 0x58e60
addq %r8, %r11
shlq $0x5, %rsi
addq %r11, %rsi
shll $0x4, %edx
addq %rsi, %rdx
leaq 0x49293(%rip), %r8      # 0x58e50
testb %r9b, %r9b
cmoveq %rdx, %r8
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %r10, %r8
movq %rax, %r9
popq %rbp
jmp 0xfe30
leaq 0x304c7(%rip), %rdi     # 0x400a5
leaq 0x301ab(%rip), %rsi     # 0x3fd90
leaq 0x304c8(%rip), %rcx     # 0x400b4
movl $0x5a, %edx
callq 0xb180
leaq 0x30520(%rip), %rdi     # 0x4011d
leaq 0x3018c(%rip), %rsi     # 0x3fd90
leaq 0x304a9(%rip), %rcx     # 0x400b4
movl $0x5b, %edx
callq 0xb180
leaq 0x30526(%rip), %rdi     # 0x40142
leaq 0x3016d(%rip), %rsi     # 0x3fd90
leaq 0x3048a(%rip), %rcx     # 0x400b4
movl $0x5c, %edx
callq 0xb180
leaq 0x30556(%rip), %rdi     # 0x40191
leaq 0x3014e(%rip), %rsi     # 0x3fd90
leaq 0x3046b(%rip), %rcx     # 0x400b4
movl $0x5d, %edx
callq 0xb180
leaq 0x30554(%rip), %rdi     # 0x401ae
leaq 0x3012f(%rip), %rsi     # 0x3fd90
leaq 0x3044c(%rip), %rcx     # 0x400b4
movl $0x5e, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
testq %rdx, %rdx
je 0xff4b
movq %r8, %r15
testq %r8, %r8
je 0xff4b
movq %r9, %rbx
testq %r9, %r9
je 0xff4b
movq %rcx, %r14
leaq (%rcx,%r15,4), %r12
xorl %r13d, %r13d
cmpl $-0x1, (%r12,%r13,4)
jne 0xfe8d
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, (%r12,%r13,4)
incq %r13
cmpq %r13, %rbx
jne 0xfe78
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
movq -0x40(%rbp), %rax
movq (%rax,%r13,8), %r15
movq %r15, %rdi
callq 0xb110
cmpq %rbx, %rax
jne 0xff2c
testq %rbx, %rbx
je 0xff03
xorl %eax, %eax
xorl %ecx, %ecx
movb (%r15,%rax), %dl
movl %edx, %esi
andb $-0x2, %sil
cmpb $0x30, %sil
jne 0xfef9
xorl %esi, %esi
cmpb $0x30, %dl
sete %sil
xorl (%r14,%rax,4), %esi
movzwl %cx, %edx
incl %ecx
movl %esi, (%r12,%rdx,4)
incq %rax
cmpq %rax, %rbx
jne 0xfed3
jmp 0xff05
xorl %ecx, %ecx
movzwl %cx, %edx
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0xfc72
incq %r13
cmpq -0x38(%rbp), %r13
jne 0xfeb5
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31301(%rip), %rdi     # 0x41234
leaq 0x31264(%rip), %rsi     # 0x4119e
leaq 0x31273(%rip), %rcx     # 0x411b4
movl $0x67, %edx
callq 0xb180
leaq 0x3121a(%rip), %rdi     # 0x4116c
leaq 0x31245(%rip), %rsi     # 0x4119e
leaq 0x31254(%rip), %rcx     # 0x411b4
movl $0x59, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
je 0x10042
movl %esi, %r14d
movq %rdi, %rbx
movzwl %r14w, %r12d
leaq (%rdi,%r12,4), %r15
bsrq %r12, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rsi
callq 0x105bc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10695
movl (%rbx), %eax
incl %eax
cmpl $0x3, %eax
jb 0x10023
movw $0x1, %ax
cmpw $0x1, %r14w
je 0xfffb
movw $0x1, %ax
movl $0x1, %ecx
movl (%rbx,%rcx,4), %edx
leal 0x1(%rdx), %esi
cmpl $0x2, %esi
jbe 0x10004
movzwl %ax, %esi
movl -0x4(%rbx,%rsi,4), %edi
cmpl %edi, %edx
je 0xffef
xorl %edx, %edi
cmpl $0x1, %edi
je 0xfff9
cmpq %rsi, %rcx
jbe 0xffed
movl %edx, (%rbx,%rsi,4)
incl %eax
incq %rcx
cmpq %rcx, %r12
jne 0xffc8
jmp 0xfffb
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31376(%rip), %rdi     # 0x41381
leaq 0x3128b(%rip), %rsi     # 0x4129d
leaq 0x312aa(%rip), %rcx     # 0x412c3
movl $0x47, %edx
callq 0xb180
leaq 0x31333(%rip), %rdi     # 0x4135d
leaq 0x3126c(%rip), %rsi     # 0x4129d
leaq 0x3128b(%rip), %rcx     # 0x412c3
movl $0x44, %edx
callq 0xb180
leaq 0x31242(%rip), %rdi     # 0x4128b
leaq 0x3124d(%rip), %rsi     # 0x4129d
leaq 0x3126c(%rip), %rcx     # 0x412c3
movl $0x40, %edx
callq 0xb180
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpl $-0x1, 0x50(%rax)
jne 0x11178
movq %rdi, %r14
movl 0x10(%rax), %ecx
movl %ecx, 0x50(%rax)
movq 0x28(%rax), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x54(%rax)
movl 0x38(%rax), %ecx
movl %ecx, 0x58(%rax)
callq 0x11b94
movq 0x10(%r14), %r15
movl 0x50(%r15), %esi
cmpl $-0x1, %esi
je 0x11197
cmpl %esi, 0x10(%r15)
jb 0x11197
movl %eax, %ebx
movl 0x58(%r15), %edx
movl 0x54(%r15), %ecx
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq $-0x1, 0x50(%r15)
movl $0xffffffff, 0x58(%r15) # imm = 0xFFFFFFFF
cmpl $0x4, %ebx
je 0x11129
movq 0xb8(%r14), %rax
movl 0x8(%rax), %esi
testl %esi, %esi
je 0x11129
movq (%rax), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %edi
leal -0x2(%rdi), %r8d
cmpl $-0x4, %r8d
ja 0x1111f
movl %edi, %r8d
shrl %r8d
decl %r8d
cmpq %r8, %rdx
je 0x1111f
jbe 0x1113a
movl (%rcx,%r8,4), %esi
cmpl $-0x1, %esi
je 0x11159
andl $0x1, %edi
xorl %esi, %edi
xorl $0x1, %edi
movl %edi, (%rcx,%rdx,4)
movl 0x8(%rax), %esi
incq %rdx
movl %esi, %edi
cmpq %rdi, %rdx
jb 0x110eb
cmpl $0x4, %ebx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30d29(%rip), %rdi     # 0x41e6a
leaq 0x30cc0(%rip), %rsi     # 0x41e08
leaq 0x30d47(%rip), %rcx     # 0x41e96
movl $0x541, %edx            # imm = 0x541
callq 0xb180
leaq 0x30d68(%rip), %rdi     # 0x41ec8
leaq 0x30ca1(%rip), %rsi     # 0x41e08
leaq 0x30d28(%rip), %rcx     # 0x41e96
movl $0x543, %edx            # imm = 0x543
callq 0xb180
leaq 0x314dc(%rip), %rdi     # 0x4265b
leaq 0x3085e(%rip), %rsi     # 0x419e4
leaq 0x3357a(%rip), %rcx     # 0x44707
movl $0x63, %edx
callq 0xb180
leaq 0x33722(%rip), %rdi     # 0x448c0
leaq 0x3083f(%rip), %rsi     # 0x419e4
leaq 0x3374c(%rip), %rcx     # 0x448f8
movl $0x71, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndexIterator<bal::CnfClausesIndexedContainer<false>>::ContainerIndexIterator(bal::CnfClausesIndexedContainer<false> const&, bool)
ContainerIndexIterator(const INDEX_T& index, const bool b_begin): index_(index), instance_iterator_(index) {
            if (b_begin) {
                instance_offset_ = 0;
                load_instance();
            } else {
                instance_offset_ = index_.instances_.size_;
                container_offset_ = CONTAINER_END;
            };
        }

// Assembly:
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
movq $-0x1, 0x10(%rdi)
testl %edx, %edx
je 0x1371f
movl $0x0, 0x18(%rdi)
movl 0x38(%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x1376d
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rsi), %rdx
xorl %r8d, %r8d
cmpl $-0x1, (%rdx,%r8,4)
jne 0x1372c
incq %r8
movl %r8d, 0x18(%rdi)
cmpq %r8, %rcx
jne 0x1370a
jmp 0x1376c
movl 0x38(%rsi), %eax
movl %eax, 0x18(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1376d
movl %r8d, 0x10(%rdi)
cmpl %r8d, %ecx
jbe 0x13765
movl (%rdx,%r8,4), %r8d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r8d, 0x14(%rdi)
cmpq %rcx, %r8
je 0x1376c
movq 0x8(%rsi), %rcx
movl 0x8(%rcx,%r8,4), %edx
movl %r8d, %eax
cmpl $-0x1, %edx
je 0x1376c
movl %edx, %eax
movl %edx, 0x14(%rdi)
movl %edx, %edx
movl 0x8(%rcx,%rdx,4), %edx
jmp 0x13753
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
popq %rbp
movl %eax, 0x1c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<bal::list_index_item_t, unsigned int, bal::LinkedListsIndexInstanceOffsetIterator<unsigned int>, bal::list_index_insertion_point_t>::reset(unsigned int, unsigned int)
virtual void reset(const container_size_t instances_size, const container_size_t index_size) {
            _assert_level_1(!transaction_is_in());
            instances_.reset(instances_size);
            instances_.append(CONTAINER_END, instances_size);
            Container<INDEX_DATA_T>::reset(index_size);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $-0x1, 0x50(%rdi)
jne 0x13c1e
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x30(%rdi), %r12
cmpl %esi, 0x48(%rdi)
je 0x13b67
movq (%r12), %rdi
testq %rdi, %rdi
je 0x13b24
testl %r15d, %r15d
je 0x13b58
movl %r15d, %esi
shlq $0x2, %rsi
callq 0xb470
testq %rax, %rax
jne 0x13b5f
leaq 0x2d766(%rip), %rdi     # 0x41277
leaq 0x2bc8b(%rip), %rsi     # 0x3f7a3
leaq 0x2bc9c(%rip), %rcx     # 0x3f7bb
jmp 0x13bbc
testl %r15d, %r15d
je 0x13b63
movl %r15d, %edi
shlq $0x2, %rdi
callq 0xb380
movq %rax, (%r12)
testq %rax, %rax
jne 0x13b63
leaq 0x2bccc(%rip), %rdi     # 0x3f811
leaq 0x2bc57(%rip), %rsi     # 0x3f7a3
leaq 0x2bc68(%rip), %rcx     # 0x3f7bb
jmp 0x13bf5
callq 0xb350
xorl %eax, %eax
movq %rax, (%r12)
movl %r15d, 0x48(%rbx)
movl $0x0, 0x38(%rbx)
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %r15d, %edx
callq 0x10ce8
cmpl %r14d, 0x20(%rbx)
je 0x13c0e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x13bc6
testl %r14d, %r14d
je 0x13bff
movl %r14d, %esi
shlq $0x3, %rsi
callq 0xb470
testq %rax, %rax
jne 0x13c06
leaq 0x2d6c9(%rip), %rdi     # 0x41277
leaq 0x2bbee(%rip), %rsi     # 0x3f7a3
leaq 0x2ec61(%rip), %rcx     # 0x4281d
movl $0x33, %edx
callq 0xb180
testl %r14d, %r14d
je 0x13c0a
movl %r14d, %edi
shlq $0x3, %rdi
callq 0xb380
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x13c0a
leaq 0x2bc2a(%rip), %rdi     # 0x3f811
leaq 0x2bbb5(%rip), %rsi     # 0x3f7a3
leaq 0x2ec28(%rip), %rcx     # 0x4281d
movl $0x38, %edx
callq 0xb180
callq 0xb350
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movl %r14d, 0x20(%rbx)
movl $0x0, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ea36(%rip), %rdi     # 0x4265b
leaq 0x2ddb8(%rip), %rsi     # 0x419e4
leaq 0x2ea3d(%rip), %rcx     # 0x42670
movl $0x5c, %edx
callq 0xb180
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::process_clause_evaluate(unsigned int*)
inline processor_result_t CnfOptimizer::process_clause_evaluate(uint32_t* const p_clause) {
        
        if ((evaluations_ & 0x3FFF) == 0) {
             std::cout << "s:" << std::dec << std::setfill(' ') << std::setw(8) << (clauses_size_ >> 10) << " Kb d: " << std::setw(8) << ((clauses_size_ - processed_offset_) >> 10) << "Kb v: " << std::setw(8) << variables_assigned_ << std::flush << "\r";
        };
        
        _assert_level_3(p_clause == _clauses_offset_clause(clauses_data_, processed_offset_));
        const processor_result_t result = evaluate_clause(processed_offset_);
        if (result == erConflict) {
            __print_conflict(variables_.data(), p_clause);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0xc0(%rdi), %eax
testl $0x3fff, %eax           # imm = 0x3FFF
jne 0x13ed3
movq 0x481e6(%rip), %r15     # 0x5bfb0
leaq 0x2eadb(%rip), %rsi     # 0x428ac
movl $0x2, %edx
movq %r15, %rdi
callq 0xb320
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r15,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%r15,%rcx)
movq -0x18(%rax), %rcx
leaq (%r15,%rcx), %r12
cmpb $0x0, 0xe1(%r15,%rcx)
jne 0x13e21
movq %r12, %rdi
movl $0x20, %esi
callq 0xb2a0
movb $0x1, 0xe1(%r12)
movq (%r15), %rax
movb $0x20, 0xe0(%r12)
movq -0x18(%rax), %rax
movl $0x8, %r12d
movq %r12, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movl (%rax), %esi
shrl $0xa, %esi
movq %r15, %rdi
callq 0xb190
movq %rax, %r15
leaq 0x2ea5b(%rip), %rsi     # 0x428af
movl $0x7, %edx
movq %rax, %rdi
callq 0xb320
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movl (%rax), %esi
subl 0xb0(%r14), %esi
shrl $0xa, %esi
movq %r15, %rdi
callq 0xb190
movq %rax, %r15
leaq 0x2ea28(%rip), %rsi     # 0x428b7
movl $0x6, %edx
movq %rax, %rdi
callq 0xb320
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq 0xd0(%r14), %rsi
movq %r15, %rdi
callq 0xb190
movq %rax, %rdi
callq 0xb1a0
leaq 0x2e9f8(%rip), %rsi     # 0x428be
movl $0x1, %edx
movq %rax, %rdi
callq 0xb320
movq 0x18(%r14), %rax
movq (%rax), %rax
movl 0xb0(%r14), %esi
leaq (%rax,%rsi,4), %rax
addq $0xc, %rax
cmpq %rbx, %rax
jne 0x13f1c
movq %r14, %rdi
callq 0x140e6
movl %eax, %r15d
cmpl $0x4, %eax
jne 0x13f10
movq 0xb8(%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xf06e
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e99d(%rip), %rdi     # 0x428c0
leaq 0x2dede(%rip), %rsi     # 0x41e08
leaq 0x2e9cb(%rip), %rcx     # 0x428fc
movl $0x84, %edx
callq 0xb180
nop