LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray::assign_template_into(bal::VariablesArray const&, bal::VariablesArray&) const
inline void assign_template_into(const VariablesArray& template_, VariablesArray& value) const {
            assert(template_.size_ == value.size_);
            const literalid_t* src = template_.data_;
            literalid_t* dst = value.data_;
            const literalid_t* dst_end = value.data_ + value.size_;
            while (dst < dst_end) {
                if (literal_t__is_variable(*src)) {
                    assert(literal_t__variable_id(*src) < size_);
                    *dst = literal_t__lookup(data_, *src);
                } else {
                    *dst = *src;
                };
                src++;
                dst++;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1072e
jmp 0x1074d
leaq 0x4b101(%rip), %rdi     # 0x5b836
leaq 0x4aff0(%rip), %rsi     # 0x5b72c
movl $0xc5, %edx
leaq 0x4b18b(%rip), %rcx     # 0x5b8d3
callq 0xd1c0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x10846
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x39(%rbp)
jbe 0x107a5
movq -0x20(%rbp), %rax
cmpl $-0x2, (%rax)
setbe %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x107ae
jmp 0x1081d
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movl (%rax), %eax
shrl %eax
subl $0x1, %eax
cmpl 0x8(%rcx), %eax
jae 0x107c4
jmp 0x107e3
leaq 0x4b167(%rip), %rdi     # 0x5b932
leaq 0x4af5a(%rip), %rsi     # 0x5b72c
movl $0xcb, %edx
leaq 0x4b0f5(%rip), %rcx     # 0x5b8d3
callq 0xd1c0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
shrl %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl (%rax), %esi
xorl $-0x1, %esi
andl $0x1, %esi
xorl %eax, %eax
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %eax
xorl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x10829
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x1077c
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/bal/container.hpp
// Function: bal::Container<unsigned int>::resize_(unsigned int)
inline void resize_(const container_size_t size) {
            if (allocated_size_ != size) {
                if (data_ != nullptr) {
                    if (size == 0) {
                        free(data_);
                        data_ = nullptr;
                        size_ = 0;
                    } else {
                        void* new_data = realloc(data_, size * sizeof(T));
                        assert(new_data != nullptr);
                        data_ = (T*)new_data;
                    };
                } else if (size != 0) {
                    data_ = (T*)malloc(size * sizeof(T));
                    assert(data_ != nullptr);
                    size_ = 0;
                } else {
                    size_ = 0;
                };
                allocated_size_ = size;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x114da
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11471
cmpl $0x0, -0xc(%rbp)
jne 0x11423
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xd3c0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
jmp 0x1146f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0xd530
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11445
jmp 0x11464
leaq 0x4a357(%rip), %rdi     # 0x5b7a3
leaq 0x4a364(%rip), %rsi     # 0x5b7b7
movl $0x33, %edx
leaq 0x4a370(%rip), %rcx     # 0x5b7cf
callq 0xd1c0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x114d0
cmpl $0x0, -0xc(%rbp)
je 0x114c3
movl -0xc(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0xd410
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x11497
jmp 0x114b6
leaq 0x4a387(%rip), %rdi     # 0x5b825
leaq 0x4a312(%rip), %rsi     # 0x5b7b7
movl $0x38, %edx
leaq 0x4a31e(%rip), %rcx     # 0x5b7cf
callq 0xd1c0
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x114ce
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x114d0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12100
jmp 0x1211f
leaq 0x54cf5(%rip), %rdi     # 0x66dfc
leaq 0x49875(%rip), %rsi     # 0x5b983
movl $0xf, %edx
leaq 0x49883(%rip), %rcx     # 0x5b99d
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x25(%rbp)
jbe 0x12134
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x26(%rbp)
jne 0x1214b
cmpl $-0x1, -0xc(%rbp)
sete %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
testb $0x1, %al
jne 0x12154
jmp 0x12156
jmp 0x12175
leaq 0x49895(%rip), %rdi     # 0x5b9f2
leaq 0x4981f(%rip), %rsi     # 0x5b983
movl $0x10, %edx
leaq 0x4982d(%rip), %rcx     # 0x5b99d
callq 0xd1c0
movq -0x8(%rbp), %rdi
callq 0xde70
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x121fd
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
xorl %eax, %eax
cmpl $0x1, (%rcx,%rdx,4)
movb %al, -0x27(%rbp)
jbe 0x121b4
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $-0x2, (%rax,%rcx,4)
setbe %al
movb %al, -0x27(%rbp)
movb -0x27(%rbp), %al
testb $0x1, %al
jne 0x121bd
jmp 0x121bf
jmp 0x121de
leaq 0x49898(%rip), %rdi     # 0x5ba5e
leaq 0x497b6(%rip), %rsi     # 0x5b983
movl $0x13, %edx
leaq 0x497c4(%rip), %rcx     # 0x5b99d
callq 0xd1c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0xe600
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12185
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cmpl $-0x1, -0xc(%rbp)
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xe670
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1223e
jmp 0x1225d
leaq 0x54bb7(%rip), %rdi     # 0x66dfc
leaq 0x49737(%rip), %rsi     # 0x5b983
movl $0x1a, %edx
leaq 0x49852(%rip), %rcx     # 0x5baaa
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
jbe 0x12272
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x16(%rbp)
jne 0x12289
cmpl $-0x1, -0xc(%rbp)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x12292
jmp 0x12294
jmp 0x122b3
leaq 0x49757(%rip), %rdi     # 0x5b9f2
leaq 0x496e1(%rip), %rsi     # 0x5b983
movl $0x1b, %edx
leaq 0x497fc(%rip), %rcx     # 0x5baaa
callq 0xd1c0
movq -0x8(%rbp), %rdi
callq 0xde70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cmpl $-0x1, -0xc(%rbp)
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xe670
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1230e
jmp 0x1232d
leaq 0x54ae7(%rip), %rdi     # 0x66dfc
leaq 0x49667(%rip), %rsi     # 0x5b983
movl $0x23, %edx
leaq 0x497d6(%rip), %rcx     # 0x5bafe
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
jbe 0x12342
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x16(%rbp)
jne 0x12359
cmpl $-0x1, -0xc(%rbp)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x12362
jmp 0x12364
jmp 0x12383
leaq 0x49687(%rip), %rdi     # 0x5b9f2
leaq 0x49611(%rip), %rsi     # 0x5b983
movl $0x24, %edx
leaq 0x49780(%rip), %rcx     # 0x5bafe
callq 0xd1c0
movq -0x8(%rbp), %rdi
callq 0xde70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xe600
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xe600
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cmpl $-0x1, -0xc(%rbp)
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xe670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12402
jmp 0x12421
leaq 0x549f3(%rip), %rdi     # 0x66dfc
leaq 0x49573(%rip), %rsi     # 0x5b983
movl $0x2e, %edx
leaq 0x49736(%rip), %rcx     # 0x5bb52
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x19(%rbp)
jbe 0x12436
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x1244d
cmpl $-0x1, -0xc(%rbp)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x12456
jmp 0x12458
jmp 0x12477
leaq 0x49593(%rip), %rdi     # 0x5b9f2
leaq 0x4951d(%rip), %rsi     # 0x5b983
movl $0x2f, %edx
leaq 0x496e0(%rip), %rcx     # 0x5bb52
callq 0xd1c0
movq -0x8(%rbp), %rdi
callq 0xde70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cmpl $-0x1, -0xc(%rbp)
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xe670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x124f2
jmp 0x12511
leaq 0x54903(%rip), %rdi     # 0x66dfc
leaq 0x49483(%rip), %rsi     # 0x5b983
movl $0x39, %edx
leaq 0x496ac(%rip), %rcx     # 0x5bbb8
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x19(%rbp)
jbe 0x12526
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1a(%rbp)
jne 0x1253d
cmpl $-0x1, -0xc(%rbp)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x12546
jmp 0x12548
jmp 0x12567
leaq 0x494a3(%rip), %rdi     # 0x5b9f2
leaq 0x4942d(%rip), %rsi     # 0x5b983
movl $0x3a, %edx
leaq 0x49656(%rip), %rcx     # 0x5bbb8
callq 0xd1c0
movq -0x8(%rbp), %rdi
callq 0xde70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xe600
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cmpl $-0x1, -0xc(%rbp)
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xe670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x126b9
jmp 0x126d8
leaq 0x5473c(%rip), %rdi     # 0x66dfc
leaq 0x492bc(%rip), %rsi     # 0x5b983
movl $0x4e, %edx
leaq 0x495d7(%rip), %rcx     # 0x5bcaa
callq 0xd1c0
movq -0x8(%rbp), %rdi
callq 0xde70
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xe600
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xe600
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xe600
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0xe600
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl 0x10(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl 0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xe630
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
cmpl $-0x1, -0xc(%rbp)
sete %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xe670
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movl $0x0, 0x70bfa(%rip)     # 0x8336c
movl $0x0, 0x70bf4(%rip)     # 0x83370
movl $0x0, 0x70bee(%rip)     # 0x83374
movl $0x0, 0x70be8(%rip)     # 0x83378
callq 0xd060
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x70bdc(%rip)     # 0x83380
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
jne 0x128d9
leaq 0x4949d(%rip), %rax     # 0x5bd70
movq %rax, -0x10(%rbp)
jmp 0x128e6
leaq 0x4f286(%rip), %rax     # 0x61b66
movq %rax, -0x10(%rbp)
jmp 0x128e6
movq -0x10(%rbp), %rsi
movq 0x706af(%rip), %rdi     # 0x82fa0
callq 0xd320
movq %rax, %rdi
leaq 0x4fab5(%rip), %rsi     # 0x623b5
callq 0xd320
movq -0x8(%rbp), %rsi
movq 0x70690(%rip), %rdi     # 0x82fa0
leaq 0x4945b(%rip), %rdx     # 0x5bd72
callq 0x12b20
movq 0x7067d(%rip), %rdi     # 0x82fa0
movq 0x70656(%rip), %rsi     # 0x82f80
callq 0xd360
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x70649(%rip), %rdi     # 0x82fa0
leaq 0x49417(%rip), %rsi     # 0x5bd75
callq 0xd320
movq %rax, %rdi
movq 0x70613(%rip), %rsi     # 0x82f80
callq 0xd360
movq 0x70627(%rip), %rdi     # 0x82fa0
leaq 0x493fe(%rip), %rsi     # 0x5bd7e
callq 0xd320
movq %rax, %rdi
movq 0x705f1(%rip), %rsi     # 0x82f80
callq 0xd360
movq -0x10(%rbp), %rdi
callq 0x128b0
movq 0x705fc(%rip), %rdi     # 0x82fa0
leaq 0x493de(%rip), %rsi     # 0x5bd89
callq 0xd320
movq %rax, %rdi
movq 0x705c6(%rip), %rsi     # 0x82f80
callq 0xd360
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
cmpl %ecx, %eax
jae 0x12a73
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shrl %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x12cc0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %esi
addl $0x1, %esi
shll %esi
orl $0x1, %esi
leaq -0x24(%rbp), %rdi
callq 0x12e30
movq 0x7057f(%rip), %rdi     # 0x82fa0
leaq -0x24(%rbp), %rsi
callq 0x12d50
movq %rax, %rdi
leaq 0x49362(%rip), %rsi     # 0x5bd96
callq 0xd320
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x12e30
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12d50
movq %rax, %rdi
movq 0x70520(%rip), %rsi     # 0x82f80
callq 0xd360
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x129c6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x11(%rbp)
jbe 0x12ce6
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x12cef
jmp 0x12d49
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shrl %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x12d13
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x12d31
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %esi
xorl $-0x1, %esi
andl $0x1, %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x12d41
jmp 0x12d49
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x12cd1
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x11(%rbp)
jbe 0x12d7b
movq -0x10(%rbp), %rax
cmpl $-0x2, (%rax)
setbe %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x12d84
jmp 0x12dca
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x12da2
movq -0x8(%rbp), %rdi
leaq 0x4a1d9(%rip), %rsi     # 0x5cf76
callq 0xd320
movq -0x8(%rbp), %rdi
leaq -0x2aed(%rip), %rsi     # 0x102c0
callq 0xd0f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
shrl %esi
subl $0x1, %esi
addl $0x1, %esi
callq 0xd420
jmp 0x12e1f
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x12de5
movq -0x8(%rbp), %rdi
leaq 0x48fbc(%rip), %rsi     # 0x5bd9a
callq 0xd320
jmp 0x12e1d
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x12e03
leaq 0x48f9f(%rip), %rax     # 0x5bd9c
movq %rax, -0x28(%rbp)
jmp 0x12e10
leaq 0x48f96(%rip), %rax     # 0x5bda0
movq %rax, -0x28(%rbp)
jmp 0x12e10
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xd320
jmp 0x12e1f
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1313e
jmp 0x1315d
leaq 0x53cb7(%rip), %rdi     # 0x66dfc
leaq 0x48c58(%rip), %rsi     # 0x5bda4
movl $0x21, %edx
leaq 0x48cee(%rip), %rcx     # 0x5be46
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
jbe 0x13172
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1317b
jmp 0x1317d
jmp 0x1319c
leaq 0x48d16(%rip), %rdi     # 0x5be9a
leaq 0x48c19(%rip), %rsi     # 0x5bda4
movl $0x22, %edx
leaq 0x48caf(%rip), %rcx     # 0x5be46
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0x10(%rbp)
movb %al, -0x16(%rbp)
jbe 0x131b1
cmpl $-0x2, -0x10(%rbp)
setbe %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x131ba
jmp 0x131bc
jmp 0x131db
leaq 0x48d17(%rip), %rdi     # 0x5beda
leaq 0x48bda(%rip), %rsi     # 0x5bda4
movl $0x23, %edx
leaq 0x48c70(%rip), %rcx     # 0x5be46
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0x14(%rbp)
movb %al, -0x17(%rbp)
jbe 0x131f0
cmpl $-0x2, -0x14(%rbp)
setbe %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
testb $0x1, %al
jne 0x131f9
jmp 0x131fb
jmp 0x1321a
leaq 0x48d18(%rip), %rdi     # 0x5bf1a
leaq 0x48b9b(%rip), %rsi     # 0x5bda4
movl $0x24, %edx
leaq 0x48c31(%rip), %rcx     # 0x5be46
callq 0xd1c0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
xorl $0x1, %esi
movl -0x14(%rbp), %edx
xorl $0x1, %edx
movl -0xc(%rbp), %ecx
callq 0x13a90
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
xorl $0x1, %edx
callq 0x13ae0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
xorl $0x1, %edx
callq 0x13ae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1328e
jmp 0x132ad
leaq 0x53b67(%rip), %rdi     # 0x66dfc
leaq 0x48b08(%rip), %rsi     # 0x5bda4
movl $0x2b, %edx
leaq 0x48cb2(%rip), %rcx     # 0x5bf5a
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
jbe 0x132c2
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x132cb
jmp 0x132cd
jmp 0x132ec
leaq 0x48bc6(%rip), %rdi     # 0x5be9a
leaq 0x48ac9(%rip), %rsi     # 0x5bda4
movl $0x2c, %edx
leaq 0x48c73(%rip), %rcx     # 0x5bf5a
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0x10(%rbp)
movb %al, -0x16(%rbp)
jbe 0x13301
cmpl $-0x2, -0x10(%rbp)
setbe %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x1330a
jmp 0x1330c
jmp 0x1332b
leaq 0x48bc7(%rip), %rdi     # 0x5beda
leaq 0x48a8a(%rip), %rsi     # 0x5bda4
movl $0x2d, %edx
leaq 0x48c34(%rip), %rcx     # 0x5bf5a
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0x14(%rbp)
movb %al, -0x17(%rbp)
jbe 0x13340
cmpl $-0x2, -0x14(%rbp)
setbe %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
testb $0x1, %al
jne 0x13349
jmp 0x1334b
jmp 0x1336a
leaq 0x48bc8(%rip), %rdi     # 0x5bf1a
leaq 0x48a4b(%rip), %rsi     # 0x5bda4
movl $0x2e, %edx
leaq 0x48bf5(%rip), %rcx     # 0x5bf5a
callq 0xd1c0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
xorl $0x1, %ecx
callq 0x13a90
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
xorl $0x1, %esi
movl -0xc(%rbp), %edx
callq 0x13ae0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x14(%rbp), %esi
xorl $0x1, %esi
movl -0xc(%rbp), %edx
callq 0x13ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x133e2
jmp 0x13401
leaq 0x53a13(%rip), %rdi     # 0x66dfc
leaq 0x489b4(%rip), %rsi     # 0x5bda4
movl $0x38, %edx
leaq 0x48bb2(%rip), %rcx     # 0x5bfae
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x19(%rbp)
jbe 0x13416
cmpl $-0x2, -0xc(%rbp)
setbe %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1341f
jmp 0x13421
jmp 0x13440
leaq 0x48a72(%rip), %rdi     # 0x5be9a
leaq 0x48975(%rip), %rsi     # 0x5bda4
movl $0x39, %edx
leaq 0x48b73(%rip), %rcx     # 0x5bfae
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0x10(%rbp)
movb %al, -0x1a(%rbp)
jbe 0x13455
cmpl $-0x2, -0x10(%rbp)
setbe %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x1345e
jmp 0x13460
jmp 0x1347f
leaq 0x48a73(%rip), %rdi     # 0x5beda
leaq 0x48936(%rip), %rsi     # 0x5bda4
movl $0x3a, %edx
leaq 0x48b34(%rip), %rcx     # 0x5bfae
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0x14(%rbp)
movb %al, -0x1b(%rbp)
jbe 0x13494
cmpl $-0x2, -0x14(%rbp)
setbe %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0x1349d
jmp 0x1349f
jmp 0x134be
leaq 0x48a74(%rip), %rdi     # 0x5bf1a
leaq 0x488f7(%rip), %rsi     # 0x5bda4
movl $0x3b, %edx
leaq 0x48af5(%rip), %rcx     # 0x5bfae
callq 0xd1c0
xorl %eax, %eax
cmpl $0x1, -0x18(%rbp)
movb %al, -0x1c(%rbp)
jbe 0x134d3
cmpl $-0x2, -0x18(%rbp)
setbe %al
movb %al, -0x1c(%rbp)
movb -0x1c(%rbp), %al
testb $0x1, %al
jne 0x134dc
jmp 0x134de
jmp 0x134fd
leaq 0x48b2e(%rip), %rdi     # 0x5c013
leaq 0x488b8(%rip), %rsi     # 0x5bda4
movl $0x3c, %edx
leaq 0x48ab6(%rip), %rcx     # 0x5bfae
callq 0xd1c0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
xorl $0x1, %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
xorl $0x1, %ecx
callq 0x13a90
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0xc(%rbp), %ecx
xorl $0x1, %ecx
callq 0x13a90
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
xorl $0x1, %esi
movl -0x14(%rbp), %edx
xorl $0x1, %edx
movl -0xc(%rbp), %ecx
callq 0x13a90
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
xorl $0x1, %edx
movl -0xc(%rbp), %ecx
callq 0x13a90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x6db91(%rip), %rax     # 0x83374
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x6db85(%rip), %rax     # 0x83374
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movw %ax, -0x1c(%rbp)
movzwl -0x1a(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
jle 0x1582a
movzwl -0x1c(%rbp), %eax
cmpl $0x0, %eax
setg %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x15833
jmp 0x1588f
movq -0x10(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movzwl -0x1c(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
je 0x15875
movq -0x10(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movzwl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x158c2
movw -0x1a(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x1a(%rbp)
movw -0x1c(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x1c(%rbp)
jmp 0x1580f
movzwl -0x1a(%rbp), %eax
movzwl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x158a5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x158bc
movzwl -0x1a(%rbp), %edx
movzwl -0x1c(%rbp), %esi
movl $0x1, %eax
xorl %ecx, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: vsklad[P]cgen/./bal/cnf/cnf/cnfclausescontainer.hpp
// Function: unsigned int const bal::CnfClausesIndexedContainer<false>::clauses_size<(unsigned short)2, 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
callq 0x17e90
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x17ec0
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x17ef0
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x17f20
testb $0x1, %al
jne 0x2d4f8
jmp 0x2d570
leaq -0x40(%rbp), %rdi
callq 0x17f50
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movl (%rax), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movw %ax, -0x72(%rbp)
movzwl -0x72(%rbp), %ecx
movl $0x2, %eax
cmpl %ecx, %eax
jne 0x2d560
movzwl -0x72(%rbp), %eax
cmpl $0x4, %eax
jg 0x2d555
movq -0x70(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
movzwl %ax, %edi
callq 0x1f670
movzwl %ax, %eax
shll $0x0, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x2d55e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d560
jmp 0x2d562
leaq -0x40(%rbp), %rdi
callq 0x17fe0
jmp 0x2d4e5
movl -0xc(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<unsigned int, unsigned int, bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>, bal::avl_tree_insertion_point_t>::transaction_begin()
inline void transaction_begin() {
            _assert_level_1(!transaction_is_in());
            transaction_size_ = this->size_;
            transaction_container_size_ = p_container_->size_;
            transaction_instances_size_ = instances_.size_;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x178b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x16841
jmp 0x16843
jmp 0x16862
leaq 0x47f1d(%rip), %rdi     # 0x5e767
leaq 0x471b4(%rip), %rsi     # 0x5da05
movl $0x63, %edx
leaq 0x49fb6(%rip), %rcx     # 0x60813
callq 0xd1c0
movq -0x10(%rbp), %rax
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)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::evaluate_clauses()
inline processor_result_t CnfOptimizer::evaluate_clauses() {
        evaluations_ = 0;
        evaluations_aggregated_ = 0;
        variables_assigned_ = 0;
        
        const processor_result_t result = process_clauses<CnfOptimizer, &CnfOptimizer::process_clause_evaluate>(this);
        
        std::cout << "Evaluation: " << std::dec << evaluations_ << "/" << evaluations_aggregated_ << " cls, size: ";
        std::cout << cnf_.clauses_size() << "/" << cnf_.clauses_size<0, true>() << " cls, ";
        std::cout << (cnf_.memory_size() >> 10) << "/";
        std::cout << (clauses_index_.memory_size() >> 10) << " Kb";
        std::cout << std::endl;
        
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq $0x0, 0xc0(%rsi)
movq $0x0, 0xc8(%rsi)
movq $0x0, 0xd0(%rsi)
movq %rsi, %rdi
callq 0x1a7d0
movl %eax, -0xc(%rbp)
movq 0x6c6c9(%rip), %rdi     # 0x82fa0
leaq 0x480b5(%rip), %rsi     # 0x5e993
callq 0xd320
movq %rax, %rdi
leaq -0x662d(%rip), %rsi     # 0x102c0
callq 0xd0f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rsi
callq 0xd0a0
movq %rax, %rdi
leaq 0x4544f(%rip), %rsi     # 0x5bd5e
callq 0xd320
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rsi
callq 0xd0a0
movq %rax, %rdi
leaq 0x4806f(%rip), %rsi     # 0x5e9a0
callq 0xd320
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x78, %rdi
callq 0x164d0
movl %eax, %esi
movq 0x6c650(%rip), %rdi     # 0x82fa0
callq 0xd420
movq %rax, %rdi
leaq 0x453ff(%rip), %rsi     # 0x5bd5e
callq 0xd320
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
addq $0x78, %rdi
callq 0x1a960
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xd420
movq %rax, %rdi
leaq 0x4801c(%rip), %rsi     # 0x5e9ad
callq 0xd320
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, %rdi
addq $0x78, %rdi
movq 0x78(%rax), %rax
callq *0x10(%rax)
movq %rax, %rsi
shrq $0xa, %rsi
movq 0x6c5e6(%rip), %rdi     # 0x82fa0
callq 0xd0a0
movq %rax, %rdi
leaq 0x45395(%rip), %rsi     # 0x5bd5e
callq 0xd320
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x1aa00
movq %rax, %rsi
shrq $0xa, %rsi
movq 0x6c5b7(%rip), %rdi     # 0x82fa0
callq 0xd0a0
movq %rax, %rdi
leaq 0x47fbc(%rip), %rsi     # 0x5e9b4
callq 0xd320
movq 0x6c59c(%rip), %rdi     # 0x82fa0
movq 0x6c575(%rip), %rsi     # 0x82f80
callq 0xd360
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<unsigned int, unsigned int, bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>, bal::avl_tree_insertion_point_t>::transaction_rollback()
inline void transaction_rollback() {
            _assert_level_1(transaction_is_in() && this->size_ >= transaction_size_);
            rollback(transaction_size_, transaction_instances_size_, transaction_container_size_);
            transaction_size_ = CONTAINER_END;
            transaction_container_size_ = CONTAINER_END;
            transaction_instances_size_ = CONTAINER_END;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x178b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x16a47
jmp 0x16a57
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %eax
cmpl 0x50(%rcx), %eax
setae %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x16a60
jmp 0x16a62
jmp 0x16a81
leaq 0x49f63(%rip), %rdi     # 0x609cc
leaq 0x46f95(%rip), %rsi     # 0x5da05
movl $0x71, %edx
leaq 0x49f88(%rip), %rcx     # 0x60a04
callq 0xd1c0
movq -0x18(%rbp), %rdi
movl 0x50(%rdi), %esi
movl 0x58(%rdi), %edx
movl 0x54(%rdi), %ecx
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<unsigned int, unsigned int, bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>, bal::avl_tree_insertion_point_t>::transaction_commit()
inline void transaction_commit() {
            _assert_level_1(transaction_is_in());
            transaction_size_ = CONTAINER_END;
            transaction_container_size_ = CONTAINER_END;
            transaction_instances_size_ = CONTAINER_END;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x178b0
testb $0x1, %al
jne 0x1786f
jmp 0x17871
jmp 0x17890
leaq 0x46ef0(%rip), %rdi     # 0x5e768
leaq 0x46186(%rip), %rsi     # 0x5da05
movl $0x6a, %edx
leaq 0x468d7(%rip), %rcx     # 0x5e162
callq 0xd1c0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x54(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nop
// File: vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::_normalize_clause(unsigned int*) const
inline bool CnfOptimizer::_normalize_clause(uint32_t* const p_clause) const {
        processor_result_t result = erUndetermined;
        const clause_size_t clause_size = _clause_size(p_clause);
        
        if (_clause_size_is_aggregated(clause_size)) {
            result = normalize_ca(p_clause, p_clause);
        } else {
            result = normalize_cu(p_clause, p_clause);
        };
        _assert_level_1(result != erConflict);
        _assert_level_1(result == erSatisfied || _clause_size(p_clause) > 0);
        return (result != erSatisfied);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %eax
cmpl $0x4, %eax
jg 0x17ddd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x180b0
movl %eax, -0x14(%rbp)
jmp 0x17df1
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x18400
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
je 0x17df9
jmp 0x17e18
leaq 0x46678(%rip), %rdi     # 0x5e478
leaq 0x4610d(%rip), %rsi     # 0x5df14
movl $0x472, %edx            # imm = 0x472
leaq 0x4667a(%rip), %rcx     # 0x5e48d
callq 0xd1c0
movb $0x1, %al
cmpl $0x3, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x17e37
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
cmpl $0x0, %eax
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x17e40
jmp 0x17e42
jmp 0x17e61
leaq 0x46685(%rip), %rdi     # 0x5e4ce
leaq 0x460c4(%rip), %rsi     # 0x5df14
movl $0x473, %edx            # imm = 0x473
leaq 0x46631(%rip), %rcx     # 0x5e48d
callq 0xd1c0
cmpl $0x3, -0x14(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.hpp
// Function: bal::ca_flags_negate(unsigned short&, unsigned short)
inline void ca_flags_negate(uint16_t& flags, const clause_size_t index) {
        constexpr uint16_t map0[4] = { 0x5555, 0x3333, 0x0F0F, 0x00FF };
        constexpr uint16_t map1[4] = { 0xAAAA, 0xCCCC, 0xF0F0, 0xFF00 };
        const uint16_t shift = 1 << index;
        flags = ((flags & map1[index]) >> shift) | ((flags & map0[index]) << shift);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq 0x485aa(%rip), %rax     # 0x60da0
movq %rax, -0x12(%rbp)
movq 0x485a7(%rip), %rax     # 0x60da8
movq %rax, -0x1a(%rbp)
movzwl -0xa(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movw %ax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movzwl -0xa(%rbp), %ecx
movzwl -0x1a(%rbp,%rcx,2), %ecx
andl %ecx, %eax
movzwl -0x1c(%rbp), %ecx
sarl %cl, %eax
movq -0x8(%rbp), %rcx
movzwl (%rcx), %edx
movzwl -0xa(%rbp), %ecx
movzwl -0x12(%rbp,%rcx,2), %ecx
andl %ecx, %edx
movzwl -0x1c(%rbp), %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x19220
testb $0x1, -0x11(%rbp)
je 0x191fb
movq -0x20(%rbp), %rdi
movl $0x0, 0x18(%rdi)
callq 0x19250
jmp 0x1920f
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x18(%rax)
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop