LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: bal::CnfGexfStreamWriter<false, true>::write_edge(unsigned int, unsigned int, bal::CnfVigStreamWriter<false, true>::__edge_data_t const&)
void write_edge(const variableid_t source_id, const variableid_t target_id, const edge_data_t& edge) override {
            stream << "<edge id=\"" << edge.id << "\"";
            stream << " source=\"" << literal_t(variable_t__literal_id(source_id)) << "\"";
            stream << " target=\"" << literal_t(variable_t__literal_id(target_id)) << "\"";
            CnfGexfStreamWriter_write_edge_dynamic(stream, edge);
            CnfGexfStreamWriter_write_edge_weighted(stream, edge);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r13d
movq %rdi, %r14
movq 0x10(%rdi), %rdi
leaq 0x123f2(%rip), %rsi     # 0x3aa9b
callq 0xc290
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0xc190
leaq 0x14523(%rip), %r12     # 0x3cbe3
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
movq 0x10(%r14), %rdi
leaq 0x123d0(%rip), %rsi     # 0x3aaa6
callq 0xc290
leal 0x3(,%r13,2), %ecx
leaq -0x30(%rbp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xeb12
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
movq 0x10(%r14), %rdi
leaq 0x123a9(%rip), %rsi     # 0x3aab0
callq 0xc290
leal 0x3(,%r15,2), %ecx
leaq -0x2c(%rbp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xeb12
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x19d72
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x23585
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: bal::CnfGexfStreamWriter<false, false>::current_date_string[abi:cxx11]()
std::string current_date_string() {
            std::time_t t = std::time(nullptr);
            char mbstr[100];
            if (std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%d", std::localtime(&t))) {
                return std::string(mbstr);
            } else {
                return "";
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0xc240
leaq -0x18(%rbp), %rdi
movq %rax, (%rdi)
callq 0xc1e0
leaq 0x1740b(%rip), %rdx     # 0x3a959
leaq -0x80(%rbp), %rdi
pushq $0x64
popq %rsi
movq %rax, %rcx
callq 0xc210
testq %rax, %rax
je 0x23568
leaq -0x80(%rbp), %rsi
jmp 0x2356f
leaq 0x1a975(%rip), %rsi     # 0x3dee4
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0xc0e0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfpolybori.hpp
// Function: bal::PolyBoRiStreamWriter::write(bal::Anf const&)
void write(const Anf& value) override {
            write_header(value);
            write_parameters(value);
            write_variables(value);
            write_equations(value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x235d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2363c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23704
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x23790
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: void bal::assign<32ul, bal::Literal<bal::Anf>, 0>(bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>*, unsigned long, bal::Literal<bal::Anf>::Formula&, bal::VariablesArray const&)
inline void assign(Ref<GF2NElement<N, GF2E>> *lhs, const size_t lhs_size,
                       typename GF2E::Formula& formula, const VariablesArray& rhs) {
        _assert_level_0(lhs_size * N == rhs.size());
        const literalid_t* literals = rhs.data();
        for (auto i = 0; i < lhs_size; i++) {
            lhs[i] = new GF2NElement<N, GF2E>();
            for (auto j = 0; j < N; j++) {
                (*lhs[i])[j] = GF2E::from_literal(&formula, literals[N - 1 - j]);
            };
            literals += N;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rsi, %rax
shlq $0x5, %rax
movl 0x8(%rcx), %edx
cmpq %rdx, %rax
jne 0x23dfa
movq (%rcx), %r14
addq $0x7c, %r14
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
cmpq -0x40(%rbp), %r13
je 0x23deb
movl $0x148, %edi            # imm = 0x148
callq 0xc2a0
movq %rax, %r15
movl $0x148, %edx            # imm = 0x148
movq %rax, %rdi
xorl %esi, %esi
callq 0xc160
movq %r15, %rdi
callq 0x2484e
movq -0x38(%rbp), %rax
movq %r13, -0x48(%rbp)
leaq (%rax,%r13,8), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2480c
movq %r14, -0x50(%rbp)
movq %r14, %r15
xorl %r14d, %r14d
cmpq $0x20, %r14
je 0x23dd7
movl (%r15), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x248c8
movq (%r13), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r14,8)
andq $0x0, -0x30(%rbp)
movq %r12, %rdi
callq 0x1f456
incq %r14
addq $-0x4, %r15
jmp 0x23da0
movq -0x48(%rbp), %r13
incq %r13
movq -0x50(%rbp), %r14
subq $-0x80, %r14
jmp 0x23d51
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16f3d(%rip), %rdi     # 0x3ad3e
leaq 0x16173(%rip), %rsi     # 0x39f7b
leaq 0x16f4a(%rip), %rcx     # 0x3ad59
movl $0x1a3, %edx            # imm = 0x1A3
callq 0xc180
movq %rax, %rbx
movq %r15, %rdi
callq 0xc260
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Literal<bal::Anf>::from_literal(bal::Anf*, unsigned int)
static Ref<Literal> from_literal(FORMULA_T* const formula, const literalid_t value) {
            if (literal_t__is_variable(value)) {
                return new Literal(formula, value);
            } else {
                return value;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movl %edx, -0x24(%rbp)
leal -0x2(%r14), %eax
cmpl $-0x4, %eax
ja 0x24917
movq %rsi, %r15
pushq $0x40
popq %rdi
callq 0xc2a0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x251ae
movq %r12, (%rbx)
movq (%r12), %rax
movq -0x20(%rax), %rax
incl 0x8(%r12,%rax)
jmp 0x24923
leaq -0x24(%rbp), %rsi
movq %rbx, %rdi
callq 0x25262
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::VariablesArray bal::variables_array<32ul, bal::Literal<bal::Anf>, 0>(bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> const&)
inline VariablesArray variables_array(const Ref<GF2NElement<N, GF2E>>& value) {
        VariablesArray result(1, N);
        literalid_t* const literals = result.data();
        const GF2E* const * const p_word_bits = value->data();
        for (auto j = 0; j < N; j++) {
            _assert_level_1(p_word_bits[N - j - 1] != nullptr);
            literals[j] = p_word_bits[N - j - 1]->value;
        };
        
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x20
popq %rsi
callq 0xdf92
movl $0x20, 0x1c(%rbx)
movq (%rbx), %rax
movq (%r14), %rcx
pushq $0x25
popq %rdx
cmpq $0x5, %rdx
je 0x255d8
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x255e0
movl 0x20(%rsi), %esi
movl %esi, (%rax)
decq %rdx
addq $0x4, %rax
jmp 0x255bb
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15db4(%rip), %rdi     # 0x3b39b
leaq 0x1498d(%rip), %rsi     # 0x39f7b
leaq 0x15dc8(%rip), %rcx     # 0x3b3bd
movl $0x188, %edx            # imm = 0x188
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./acl/sha1.hpp
// Function: acl::SHA1<bal::Literal<bal::Anf>>::f(unsigned int, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>&, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>&, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>&)
const Ref<Word> f(unsigned int t, Ref<Word> &b, Ref<Word> &c, Ref<Word> &d) {
            switch (t / 20) {
                case 0: return ch(b, c, d);
                case 1: return parity(b, c, d);
                case 2: return maj(b, c, d);
                case 3: return parity(b, c, d);
                default:
                    assert(false);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %eax
pushq $0x14
popq %rsi
xorl %edx, %edx
divl %esi
cmpl $0x3, %eax
ja 0x2572e
movq %rdi, %rbx
leaq 0x12b0c(%rip), %rdx     # 0x381f0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq 0x25d2a
jmp 0x25724
movq %rbx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq 0x25d01
jmp 0x25724
movq %rbx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
callq 0x25d53
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x14686(%rip), %rdi     # 0x39dbb
leaq 0x15d28(%rip), %rsi     # 0x3b464
leaq 0x15f30(%rip), %rcx     # 0x3b673
pushq $0x29
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::rotr<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, int)
Ref<GF2NElement<N, GF2E>> rotr(GF2NElement<N, GF2E>* const r,
                                   const GF2NElement<N, GF2E>* const value, const int n) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            (*result)[i] = (*value)[(i + n) % N];
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
callq 0x258e4
addq $0x30, %r14
pushq $0x30
popq %r12
cmpq $0x130, %r12            # imm = 0x130
je 0x258d8
movl %ebx, %eax
andl $0x1f, %eax
leaq (%r14,%rax,8), %rsi
movq (%r15), %rdi
addq %r12, %rdi
callq 0x24dfc
incl %ebx
addq $0x8, %r12
jmp 0x258b3
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/referenceable.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::new_instance_if_unassigned<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>, 0>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*)
Ref<T> new_instance_if_unassigned(T* const value) {
        Ref<T> result = value;
        if (value == nullptr) {
            new_instance(result);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
testq %rsi, %rsi
je 0x25903
movq (%rsi), %rax
movq -0x20(%rax), %rax
incl 0x8(%rsi,%rax)
jmp 0x2590b
movq %rbx, %rdi
callq 0x25926
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x23cce
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::eor<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const* const*, unsigned long)
Ref<GF2NElement<N, GF2E>> eor(GF2NElement<N, GF2E>* const r,
                                  const GF2NElement<N, GF2E>* const args[], const std::size_t args_size) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            const GF2E* args_i[args_size];
            for (auto j = 0; j < args_size; j++) {
                args_i[j] = (*args[j])[i];
            };
            (*result)[i] = eor((*result)[i].data(), args_i, args_size);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, -0x30(%rbp)
callq 0x258e4
xorl %r13d, %r13d
leaq 0xf(,%r14,8), %rax
andq $-0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %r12
cmpq $0x20, %r13
je 0x25a15
movq %rsp, -0x48(%rbp)
movq %rsp, %rdx
subq -0x40(%rbp), %rdx
movq %rdx, %rsp
xorl %eax, %eax
leaq -0x38(%rbp), %rbx
cmpq %rax, %r14
je 0x259de
movq (%r15,%rax,8), %rcx
movq 0x30(%rcx,%r13,8), %rcx
movq %rcx, (%rdx,%rax,8)
incq %rax
jmp 0x259c7
movq (%r12), %rax
movq 0x30(%rax,%r13,8), %rsi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x25a3b
movq (%r12), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax,%r13,8)
andq $0x0, -0x38(%rbp)
movq %rbx, %rdi
callq 0x1f456
movq -0x48(%rbp), %rsp
incq %r13
jmp 0x259ad
movq -0x30(%rbp), %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x23cce
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::update_formula(bal::Anf*&, bal::Literal<bal::Anf> const*)
void update_formula(FORMULA_T*& formula, const Literal* const instance) {
            _assert_level_0(instance != nullptr);
            if (instance->formula != nullptr) {
                _assert_level_1(formula == nullptr || formula == instance->formula);
                formula = instance->formula;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x25bac
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x25baa
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
cmpq %rax, %rcx
sete %cl
orb %dl, %cl
je 0x25bc5
movq %rax, (%rdi)
popq %rbp
retq
leaq 0x15993(%rip), %rdi     # 0x3b546
leaq 0x143c1(%rip), %rsi     # 0x39f7b
leaq 0x15999(%rip), %rcx     # 0x3b55a
pushq $0x57
jmp 0x25bdc
leaq 0x159d6(%rip), %rdi     # 0x3b5a2
leaq 0x143a8(%rip), %rsi     # 0x39f7b
leaq 0x15980(%rip), %rcx     # 0x3b55a
pushq $0x59
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::ch<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*)
Ref<GF2NElement<N, GF2E>> ch(GF2NElement<N, GF2E>* const r,
                                 const GF2NElement<N, GF2E>* const x,
                                 const GF2NElement<N, GF2E>* const y,
                                 const GF2NElement<N, GF2E>* const z) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            (*result)[i] = ch((*result)[i].data(), (*x)[i].data(), (*y)[i].data(), (*z)[i].data());
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x258e4
xorl %r14d, %r14d
leaq -0x30(%rbp), %r13
cmpq $0x100, %r14            # imm = 0x100
je 0x25df1
movq (%rbx), %rax
movq 0x30(%rax,%r14), %rsi
movq 0x30(%r12,%r14), %rdx
movq 0x30(%r15,%r14), %rcx
movq -0x38(%rbp), %rax
movq 0x30(%rax,%r14), %r8
movq %r13, %rdi
callq 0x25e16
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r14)
andq $0x0, -0x30(%rbp)
movq %r13, %rdi
callq 0x1f456
addq $0x8, %r14
jmp 0x25da6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x23cce
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Ref<bal::Literal<bal::Anf>> bal::inv<bal::Anf>(bal::Literal<bal::Anf>*, bal::Literal<bal::Anf> const*)
Ref<Literal<FORMULA_T>> inv(Literal<FORMULA_T>* const r,
                                const Literal<FORMULA_T>* const x) {
        if (literal_t__is_variable(x->value)) {
            return new Literal<FORMULA_T>(x->formula, literal_t__negated(x->value));
        } else if (literal_t__is_constant(x->value)) {
            return literal_t__negated(x->value);
        } else if (literal_t__is_unassigned(x->value)) {
            return x->value;
        } else {
            _assert_level_0(false);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movl 0x20(%rdx), %r14d
leal 0x1(%r14), %eax
cmpl $0x3, %eax
jae 0x260a5
cmpl $0x1, %r14d
ja 0x26094
xorl $0x1, %r14d
leaq -0x24(%rbp), %rsi
movl %r14d, (%rsi)
movq %rbx, %rdi
jmp 0x2609e
addq $0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x25262
jmp 0x260d3
pushq $0x40
popq %rdi
callq 0xc2a0
movq %rax, %r12
movq 0x18(%r15), %rsi
xorl $0x1, %r14d
movq %rax, %rdi
movl %r14d, %edx
callq 0x251ae
movq %r12, (%rbx)
movq (%r12), %rax
movq -0x20(%rax), %rax
incl 0x8(%r12,%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Ref<bal::Literal<bal::Anf>> bal::con2<bal::Anf>(bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*)
Ref<Literal<FORMULA_T>> con2(Literal<FORMULA_T>* const r,
                                 Literal<FORMULA_T>* const x, Literal<FORMULA_T>* const y) {
        if (x->value == y->value) {
            return x;
        } else if (literal_t__is_negation_of(x->value, y->value)) {
            return 0;
        } else if (literal_t__is_constant_0(x->value) || literal_t__is_constant_0(y->value)) {
            return 0;
        } else if (literal_t__is_constant_1(x->value)) {
            return y;
        } else if (literal_t__is_constant_1(y->value)) {
            return x;
        } else {
            _assert_level_1(x->formula != nullptr && x->formula == y->formula);
            const literalid_t r_value = x->formula->new_variable_literal();
            con2(x->formula, r_value, x->value, y->value);
            return new Literal<FORMULA_T>(x->formula, r_value);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movl 0x20(%rdx), %ecx
movl 0x20(%r15), %eax
cmpl %eax, %ecx
jne 0x26117
movq %r14, (%rbx)
movq (%r14), %rax
movq -0x20(%rax), %rax
incl 0x8(%r14,%rax)
jmp 0x26145
movl %eax, %edx
xorl %ecx, %edx
cmpl $0x1, %edx
jne 0x26126
leaq -0x28(%rbp), %rsi
jmp 0x2613a
testl %ecx, %ecx
setne %dl
testl %eax, %eax
setne %sil
testb %sil, %dl
jne 0x26155
leaq -0x24(%rbp), %rsi
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x261d4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %ecx
je 0x261a4
cmpl $0x1, %eax
je 0x26106
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x261b5
cmpq 0x18(%r15), %rdi
jne 0x261b5
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %r12d
movq 0x18(%r14), %rdi
movl 0x20(%r14), %edx
movl 0x20(%r15), %ecx
movl %eax, %esi
callq 0xe3c8
pushq $0x40
popq %rdi
callq 0xc2a0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
movl %r12d, %edx
callq 0x251ae
movq %r15, (%rbx)
movq (%r15), %rax
movq -0x20(%rax), %rax
incl 0x8(%r15,%rax)
jmp 0x26145
leaq 0x15631(%rip), %rdi     # 0x3b7ed
leaq 0x13db8(%rip), %rsi     # 0x39f7b
leaq 0x15655(%rip), %rcx     # 0x3b81f
movl $0xf8, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Ref<bal::Literal<bal::Anf>> bal::dis2<bal::Anf>(bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*)
Ref<Literal<FORMULA_T>> dis2(Literal<FORMULA_T>* const r,
                                 Literal<FORMULA_T>* const x, Literal<FORMULA_T>* const y) {
        if (x->value == y->value) {
            return x;
        } else if (literal_t__is_negation_of(x->value, y->value)) {
            return 1;
        } else if (literal_t__is_constant_0(x->value)) {
            return y;
        } else if (literal_t__is_constant_0(y->value)) {
            return x;
        } else if (literal_t__is_constant_1(x->value) || literal_t__is_constant_1(y->value)) {
            return 1;
        } else {
            _assert_level_1(x->formula != nullptr && x->formula == y->formula);
            const literalid_t r_value = x->formula->new_variable_literal();
            dis2(x->formula, r_value, x->value, y->value);
            return new Literal<FORMULA_T>(x->formula, r_value);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movl 0x20(%rdx), %ecx
movl 0x20(%r15), %eax
cmpl %eax, %ecx
jne 0x26219
movq %r14, (%rbx)
movq (%r14), %rax
movq -0x20(%rax), %rax
incl 0x8(%r14,%rax)
jmp 0x262a8
movl %eax, %edx
xorl %ecx, %edx
cmpl $0x1, %edx
jne 0x26236
leaq -0x28(%rbp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x261d4
jmp 0x262a8
testl %ecx, %ecx
je 0x26299
testl %eax, %eax
je 0x26205
cmpl $0x1, %ecx
setne %cl
cmpl $0x1, %eax
setne %al
testb %al, %cl
jne 0x26254
leaq -0x24(%rbp), %rsi
jmp 0x26226
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x262b8
cmpq 0x18(%r15), %rdi
jne 0x262b8
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %r12d
movq 0x18(%r14), %rdi
movl 0x20(%r14), %edx
movl 0x20(%r15), %ecx
movl %eax, %esi
callq 0xe459
pushq $0x40
popq %rdi
callq 0xc2a0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
movl %r12d, %edx
callq 0x251ae
movq %r15, (%rbx)
movq (%r15), %rax
movq -0x20(%rax), %rax
incl 0x8(%r15,%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1552e(%rip), %rdi     # 0x3b7ed
leaq 0x13cb5(%rip), %rsi     # 0x39f7b
leaq 0x155dc(%rip), %rcx     # 0x3b8a9
movl $0x112, %edx            # imm = 0x112
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::parity<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*)
Ref<GF2NElement<N, GF2E>> parity(GF2NElement<N, GF2E>* const r,
                                     const GF2NElement<N, GF2E>* const x,
                                     const GF2NElement<N, GF2E>* const y,
                                     const GF2NElement<N, GF2E>* const z) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            (*result)[i] = parity((*result)[i].data(), (*x)[i].data(), (*y)[i].data(), (*z)[i].data());
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x258e4
xorl %r14d, %r14d
leaq -0x30(%rbp), %r13
cmpq $0x100, %r14            # imm = 0x100
je 0x26378
movq (%rbx), %rax
movq 0x30(%rax,%r14), %rsi
movq 0x30(%r12,%r14), %rdx
movq 0x30(%r15,%r14), %rcx
movq -0x38(%rbp), %rax
movq 0x30(%rax,%r14), %r8
movq %r13, %rdi
callq 0x2639d
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r14)
andq $0x0, -0x30(%rbp)
movq %r13, %rdi
callq 0x1f456
addq $0x8, %r14
jmp 0x2632d
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x23cce
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::maj<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*)
Ref<GF2NElement<N, GF2E>> maj(GF2NElement<N, GF2E>* const r,
                                  const GF2NElement<N, GF2E>* const x,
                                  const GF2NElement<N, GF2E>* const y,
                                  const GF2NElement<N, GF2E>* const z) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            (*result)[i] = maj((*result)[i].data(), (*x)[i].data(), (*y)[i].data(), (*z)[i].data());
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x258e4
xorl %r14d, %r14d
leaq -0x30(%rbp), %r13
cmpq $0x100, %r14            # imm = 0x100
je 0x26442
movq (%rbx), %rax
movq 0x30(%rax,%r14), %rsi
movq 0x30(%r12,%r14), %rdx
movq 0x30(%r15,%r14), %rcx
movq -0x38(%rbp), %rax
movq 0x30(%rax,%r14), %r8
movq %r13, %rdi
callq 0x26467
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r14)
andq $0x0, -0x30(%rbp)
movq %r13, %rdi
callq 0x1f456
addq $0x8, %r14
jmp 0x263f7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x23cce
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Ref<bal::Literal<bal::Anf>> bal::maj<bal::Anf>(bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*)
Ref<Literal<FORMULA_T>> maj(Literal<FORMULA_T>* const r,
                                Literal<FORMULA_T>* const x, Literal<FORMULA_T>* const y, Literal<FORMULA_T>* const z) {
        if (literal_t__is_constant_0(x->value)) {
            return con2(r, y, z);
        } else if (literal_t__is_constant_0(y->value)) {
            return con2(r, x, z);
        } else if (literal_t__is_constant_0(z->value)) {
            return con2(r, x, y);
        } else if (literal_t__is_constant_1(x->value)) {
            return dis2(r, y, z);
        } else if (literal_t__is_constant_1(y->value)) {
            return dis2(r, x, z);
        } else if (literal_t__is_constant_1(z->value)) {
            return dis2(r, x, y);
        } else if (x->value == y->value || x->value == z->value) {
            return x;
        } else if (y->value == z->value) {
            return y;
        } else {
            _assert_level_1(x->formula != nullptr && x->formula == y->formula && x->formula == z->formula);
            const literalid_t r_value = x->formula->new_variable_literal();
            maj(x->formula, r_value, x->value, y->value, z->value);
            return new Literal<FORMULA_T>(x->formula, r_value);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rdi, %rbx
movl 0x20(%rdx), %ecx
testl %ecx, %ecx
je 0x264a6
movq %rdx, %r14
movl 0x20(%r15), %eax
testl %eax, %eax
je 0x264ae
movl 0x20(%r12), %edx
testl %edx, %edx
je 0x264be
cmpl $0x1, %ecx
jne 0x264c9
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x264d4
movq %rbx, %rdi
movq %r15, %rdx
jmp 0x264b4
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x260e3
jmp 0x264dc
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
jmp 0x264b7
cmpl $0x1, %eax
jne 0x264ee
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x261e2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %edx
jne 0x264fe
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
jmp 0x264d7
cmpl %eax, %ecx
setne %sil
cmpl %edx, %ecx
setne %cl
testb %cl, %sil
jne 0x2651f
movq %r14, (%rbx)
movq (%r14), %rax
movq -0x20(%rax), %rax
incl 0x8(%r14,%rax)
jmp 0x264dc
cmpl %edx, %eax
je 0x26574
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x26588
cmpq 0x18(%r15), %rdi
jne 0x26588
cmpq 0x18(%r12), %rdi
jne 0x26588
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %r13d
movq 0x18(%r14), %rdi
movl 0x20(%r14), %edx
movl 0x20(%r15), %ecx
movl 0x20(%r12), %r8d
movl %eax, %esi
callq 0xe500
pushq $0x40
popq %rdi
callq 0xc2a0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
movl %r13d, %edx
callq 0x251ae
movq %r15, (%rbx)
movq (%r15), %rax
movq -0x20(%rax), %rax
incl 0x8(%r15,%rax)
jmp 0x264dc
leaq 0x1516d(%rip), %rdi     # 0x3b6fc
leaq 0x139e5(%rip), %rsi     # 0x39f7b
leaq 0x15396(%rip), %rcx     # 0x3b933
movl $0x13a, %edx            # imm = 0x13A
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/field.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::reduce<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> (*)(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*), bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const* const*, unsigned long)
Ref<T> reduce(T* const r, Function2_<T> function, const T* const args[], const std::size_t args_size) {
        _assert_level_1(args_size >= 2);
        Ref<T> result = function(r, args[0], args[1]);
        for (auto i = 2; i < args_size; i++) {
            _assert_level_1(r != args[i]); // because its overwritten already
            result = function(result, result, args[i]);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x40(%rbp)
cmpq $0x1, %r8
jbe 0x26673
movq %rdx, %rax
movq %rdi, %rbx
movq (%rcx), %rdx
movq %rcx, -0x38(%rbp)
movq 0x8(%rcx), %rcx
movq %rsi, %r13
movq %rax, %r15
callq *%rax
pushq $0x2
popq %r14
leaq -0x30(%rbp), %r12
cmpq %r14, -0x40(%rbp)
je 0x26644
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %rcx
cmpq %r13, %rcx
je 0x26656
movq (%rbx), %rdx
movq %r12, %rdi
movq %rdx, %rsi
callq *%r15
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
andq $0x0, -0x30(%rbp)
movq %r12, %rdi
callq 0x23cce
incq %r14
jmp 0x2660c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15428(%rip), %rdi     # 0x3ba85
leaq 0x15382(%rip), %rsi     # 0x3b9e6
leaq 0x15394(%rip), %rcx     # 0x3b9ff
pushq $0x2d
popq %rdx
callq 0xc180
leaq 0x1535d(%rip), %rdi     # 0x3b9d7
leaq 0x15365(%rip), %rsi     # 0x3b9e6
leaq 0x15377(%rip), %rcx     # 0x3b9ff
pushq $0x2a
jmp 0x2666d
movq %rax, %r14
movq %rbx, %rdi
callq 0x23cce
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anf.hpp
// Function: bal::process(bal::Anf&, bal::VariablesArray const&, bool, bal::FormulaProcessingMode)
inline bool process(Anf& anf, const VariablesArray& variables,
                                   const bool b_reindex_variables, const FormulaProcessingMode mode) {
            _assert_level_0(mode == fpmUnoptimized); // other modes not supported
            _assert_level_1(anf.variables_size() == variables.size());
            
            const literalid_t* const values = variables.data();
            
            for (variableid_t i = 0; i < variables.size(); i++) {
                if (variable_t__literal_id(i) != values[i]) {
                    anf.append_equation();
                    anf.append_equation_term(values[i]);
                    literalid_t first_id = anf.symbols_[anf.terms_[anf.equations_[anf.equations_.size() - 1]]];
                    first_id = literal_t__substitute_literal(literal_t__negated(first_id), variable_t__literal_id(i));
                    anf.symbols_[anf.terms_[anf.equations_[anf.equations_.size() - 1]]] = first_id;
                };
            };
            
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jne 0x26953
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x58(%rax)
cmpl 0x8(%rbx), %eax
jne 0x2696c
movq (%rbx), %r15
xorl %r12d, %r12d
movl %eax, %eax
leal 0x1(,%r12,2), %r13d
movq %r12, %rcx
cmpq %rax, %rcx
jae 0x26942
leaq 0x1(%rcx), %r12
addl $0x2, %r13d
cmpl (%r15,%rcx,4), %r13d
movq %r12, %rcx
je 0x268ee
movq %r14, %rdi
callq 0xcaa4
movl -0x4(%r15,%r12,4), %esi
movq %r14, %rdi
callq 0xce90
movq 0xb0(%r14), %rax
movl -0x4(%rax), %eax
movq 0x78(%r14), %rcx
movq 0x90(%r14), %rdx
movl (%rdx,%rax,4), %eax
movl (%rcx,%rax,4), %edx
andl $0x1, %edx
xorl %r13d, %edx
movl %edx, (%rcx,%rax,4)
movl 0x8(%rbx), %eax
jmp 0x268e1
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x152dc(%rip), %rdi     # 0x3bc36
leaq 0x12e1d(%rip), %rsi     # 0x3977e
leaq 0x152e5(%rip), %rcx     # 0x3bc4d
pushq $0x6c
jmp 0x26983
leaq 0x15334(%rip), %rdi     # 0x3bca7
leaq 0x12e04(%rip), %rsi     # 0x3977e
leaq 0x152cc(%rip), %rcx     # 0x3bc4d
pushq $0x6d
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::shr<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, int)
Ref<GF2NElement<N, GF2E>> shr(GF2NElement<N, GF2E>* const r,
                                  const GF2NElement<N, GF2E>* const value, const int n) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            if ((0 <= (i + n)) && ((i + n) < N))
                (*result)[i] = (*value)[i + n];
            else
                (*result)[i] = 0b0;
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
callq 0x258e4
movslq %r14d, %r12
leaq (%r15,%r12,8), %r15
pushq $0x30
popq %r13
leaq -0x2c(%rbp), %r14
cmpq $0x130, %r13            # imm = 0x130
je 0x27f73
cmpq $0x1f, %r12
ja 0x27f58
leaq (%r15,%r13), %rsi
movq (%rbx), %rdi
addq %r13, %rdi
callq 0x24dfc
jmp 0x27f6a
andl $0x0, -0x2c(%rbp)
movq (%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x24c20
addq $0x8, %r13
incq %r12
jmp 0x27f38
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x23cce
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/tracer/cnfgexftracer.hpp
// Function: bal::CnfGexfTracer::start(bal::Cnf const&)
void start(const Cnf& cnf) override {
            _assert_level_0(p_cnf_ == nullptr);
            _assert_level_0(edges_.size() == 0);
            next_edge_id_ = 0;
            timestamp_ = TIMESTAMP_MIN;
            p_cnf_ = &cnf;
            writer::write_header(cnf);
            writer::compute_edges(cnf, timestamp_, edges_, next_edge_id_);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x30(%rdi)
jne 0x280dc
movq %rdi, %r14
cmpq $0x0, 0x60(%rdi)
jne 0x280f5
movq %rsi, %rbx
andq $0x0, 0x68(%r14)
leaq 0x38(%r14), %r15
leaq 0x68(%r14), %r12
movq %rsi, 0x30(%r14)
leaq 0x18(%r14), %r13
movq %r13, %rdi
callq 0x282bc
movl 0x6c(%r14), %edx
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rcx
movq %r12, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28958
leaq 0x10a7c(%rip), %rdi     # 0x38b5f
leaq 0x13e64(%rip), %rsi     # 0x3bf4e
leaq 0x13e80(%rip), %rcx     # 0x3bf71
pushq $0x2f
jmp 0x2810c
leaq 0x13ea9(%rip), %rdi     # 0x3bfa5
leaq 0x13e4b(%rip), %rsi     # 0x3bf4e
leaq 0x13e67(%rip), %rcx     # 0x3bf71
pushq $0x30
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/tracer/cnfgexftracer.hpp
// Function: bal::CnfGexfTracer::finish()
void finish() override {
            _assert_level_0(p_cnf_ != nullptr);
            write_nodes(*p_cnf_, edges_);
            write_edges(*p_cnf_, edges_);
            writer::write_footer(*p_cnf_);
            p_cnf_ = nullptr;
            edges_.clear();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rsi
testq %rsi, %rsi
je 0x28171
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x38(%rdi), %r15
movq 0x18(%rdi), %rax
movq %r14, %rdi
movq %r15, %rdx
callq *0x30(%rax)
movq 0x18(%rbx), %rax
movq 0x30(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq *0x40(%rax)
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x28460
andq $0x0, 0x30(%rbx)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28c72
leaq 0x13e40(%rip), %rdi     # 0x3bfb8
leaq 0x13dcf(%rip), %rsi     # 0x3bf4e
leaq 0x13e44(%rip), %rcx     # 0x3bfca
pushq $0x39
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::edge_dynamic_data_t<true>::update(unsigned int, bal::edge_action_t, unsigned int)
void update(const uint32_t clause_header, const edge_action_t action, const timestamp_t timestamp) {
            switch(action) {
                case eaInsert:
                    clauses_count = 1;
                    start = timestamp;
                    end = TIMESTAMP_MAX;
                    break;
                case eaUpdate:
                    clauses_count++;
                    break;
                case eaRemove:
                    _assert_level_0(timestamp >= start);
                    _assert_level_0(clauses_count > 0);
                    clauses_count--;
                    if (clauses_count == 0) {
                        end = timestamp;
                    };
                    break;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %edx
je 0x28e09
cmpl $0x1, %edx
je 0x28e05
testl %edx, %edx
jne 0x28e1d
movl $0x1, (%rdi)
movl %ecx, 0x4(%rdi)
orl $-0x1, 0x8(%rdi)
jmp 0x28e1d
incl (%rdi)
jmp 0x28e1d
cmpl %ecx, 0x4(%rdi)
ja 0x28e1f
movl (%rdi), %eax
testl %eax, %eax
je 0x28e38
decl %eax
movl %eax, (%rdi)
jne 0x28e1d
movl %ecx, 0x8(%rdi)
popq %rbp
retq
leaq 0x131ce(%rip), %rdi     # 0x3bff4
leaq 0x11840(%rip), %rsi     # 0x3a66d
leaq 0x131d3(%rip), %rcx     # 0x3c007
pushq $0x31
jmp 0x28e4f
leaq 0x1322c(%rip), %rdi     # 0x3c06b
leaq 0x11827(%rip), %rsi     # 0x3a66d
leaq 0x131ba(%rip), %rcx     # 0x3c007
pushq $0x32
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literaladd.hpp
// Function: bal::add_append_variable_(unsigned int, std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int&)
inline void add_append_variable_(const literalid_t arg,
                                     std::vector<literalid_t>& variables,
                                     std::vector<literalid_t>& carry_out_1,
                                     unsigned& constant) {
        if (literal_t__is_constant(arg)) {
            constant += literal_t__is_constant_1(arg) ? 1 : 0;
        } else {
            // check for duplicates including negation
            for (auto i = 0; i < variables.size(); i++) {
                if (literal_t__is_same_variable(arg, variables[i])) {
                    if (literal_t__is_negation_of(arg, variables[i])) {
                        // if negation, x + !x <=> 1; remove variables[i] and add 1
                        constant += 1;
                    } else {
                        add_append_carry_(arg, carry_out_1);
                    };
                    
                    // remove the variable
                    if (variables.size() > 1) {
                        variables[i] = variables[variables.size() - 1];
                    };
                    variables.resize(variables.size() - 1);
                    
                    return;
                };
            };
            variables.push_back(arg);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, -0x14(%rbp)
cmpl $0x2, %edi
jae 0x2b323
xorl %eax, %eax
cmpl $0x1, %edi
sete %al
addl %eax, (%rcx)
jmp 0x2b361
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r8
subq %rax, %r8
movq %r8, %rsi
sarq $0x2, %rsi
xorl %r14d, %r14d
cmpq %r14, %rsi
je 0x2b355
movl (%rax,%r14,4), %r9d
xorl %edi, %r9d
incq %r14
cmpl $0x1, %r9d
ja 0x2b33a
jne 0x2b36a
incl (%rcx)
jmp 0x2b383
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0xd89e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %rsi
callq 0x2b3a6
movq (%rbx), %rax
movq 0x8(%rbx), %r8
subq %rax, %r8
movq %r8, %rsi
sarq $0x2, %rsi
cmpq $0x2, %rsi
jb 0x2b393
movl -0x4(%rax,%r8), %ecx
movl %ecx, -0x4(%rax,%r14,4)
decq %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1c4d8
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>> bal::add2<32ul>(bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Cnf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Cnf>> const*)
Ref<GF2NElement<N, Literal<Cnf>>> add2(GF2NElement<N, Literal<Cnf>>* const r,
                                            const GF2NElement<N, Literal<Cnf>>* const x,
                                            const GF2NElement<N, Literal<Cnf>>* const y) {
        Ref<GF2NElement<N, Literal<Cnf>>> result = new_instance_if_unassigned(r);
        const GF2NElement<N, Literal<Cnf>>* args[2] = { x, y };
        literal_word_add<N, Literal<Cnf>, add>(result, args, 2);
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x2a0e2
leaq -0x30(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movq (%rbx), %rdi
pushq $0x2
popq %rdx
callq 0x2adec
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bd90
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: operator<<(std::ostream&, TextReaderException const&)
std::ostream& operator << (std::ostream& stream, const TextReaderException &e) {
        stream << e.message_;
        if (e.line_index_ > 0) {
            stream << ", line: " << e.line_index_ << ", pos: " << e.pos_ << ", \"" << e.line_ << "\"";
        };
        return stream;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rsi
callq 0xc230
cmpq $0x0, (%r14)
je 0x2d19b
leaq 0xfa90(%rip), %rsi      # 0x3cbd0
movq %rbx, %rdi
callq 0xc290
movq (%r14), %rsi
movq %rax, %rdi
callq 0xc190
leaq 0xfa7f(%rip), %rsi      # 0x3cbd9
movq %rax, %rdi
callq 0xc290
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0xc190
leaq 0xfa6c(%rip), %rsi      # 0x3cbe1
movq %rax, %rdi
callq 0xc290
addq $0x10, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xc230
leaq 0xfa50(%rip), %rsi      # 0x3cbe3
movq %rax, %rdi
callq 0xc290
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::skip_space()
inline void skip_space() {
        while (current_token_pos_ < current_line_.size()) {
            if (current_line_[current_token_pos_] != ' ')
                break;
            current_token_pos_++;
            if (current_token_len_ > 0) {
                reset_token();
            };
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq $0x0, 0x10(%rdi)
sete %sil
cmpq %rax, %rcx
jae 0x2d2c5
cmpb $0x20, (%rdx,%rcx)
jne 0x2d2c5
incq %rcx
movq %rcx, 0x8(%rdi)
testb $0x1, %sil
jne 0x2d2c0
andq $0x0, 0x10(%rdi)
andl $0x0, 0x40(%rdi)
movb $0x1, %sil
jmp 0x2d29f
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfpolybori.hpp
// Function: bal::PolyBoRiStreamReader::read_parameters(bal::Anf&)
void read_parameters(Anf& anf) {
            const std::string key = read_literal();
            skip_space();
            read_symbol('=');
            skip_space();
            read_symbol('{');
            skip_space();
            
            read_parameter(anf, key);
            skip_space();
            while (is_symbol(',')) {
                read_symbol(',');
                skip_space();
                read_parameter(anf, key);
                skip_space();
            };
            
            read_symbol('}');
            skip_space();
            read_eol();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rsi
addq %rdi, %rsi
leaq -0x48(%rbp), %rdi
callq 0x18938
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2d286
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x3d
popq %rsi
callq 0x18ac2
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2d286
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x7b
popq %rsi
callq 0x18ac2
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2d286
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc360
leaq -0x68(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2d57c
pushq $0x2c
popq %r15
leaq -0x88(%rbp), %r13
movq %r12, %rdi
callq 0xc110
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2d286
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl %r15d, %esi
callq 0x18a92
movq (%rbx), %rcx
movq -0x18(%rcx), %rdi
addq %rbx, %rdi
testb %al, %al
je 0x2d3da
movl %r15d, %esi
callq 0x18ac2
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2d286
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
callq 0xc360
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2d57c
movq %r13, %r12
jmp 0x2d36d
pushq $0x7d
popq %rsi
callq 0x18ac2
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2d286
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
callq 0x18c3c
leaq -0x48(%rbp), %rdi
callq 0xc110
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x2d42d
jmp 0x2d434
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xc110
jmp 0x2d437
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anfpolybori.hpp
// Function: bal::PolyBoRiStreamReader::read_named_variable(bal::Anf&)
void read_named_variable(Anf& anf) {
            std::string name = read_literal();
            skip_space();
            read_symbol('=');
            skip_space();
            VariablesArray value = read_variable_value();
            skip_space();
            read_eol();
            anf.add_named_variable(name.data(), value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rsi
addq %rdi, %rsi
leaq -0x50(%rbp), %rdi
callq 0x18938
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
callq 0x2d286
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
pushq $0x3d
popq %rsi
callq 0x18ac2
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
callq 0x2d286
movq (%r14), %rax
movq -0x28(%rax), %rsi
addq %r14, %rsi
leaq -0x30(%rbp), %rdi
callq 0x302e4
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
callq 0x2d286
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
callq 0x18c3c
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x2e102
leaq -0x30(%rbp), %rdi
callq 0xde58
leaq -0x50(%rbp), %rdi
callq 0xc110
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2d4fa
movq %rax, %rbx
jmp 0x2d50b
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xde58
leaq -0x50(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0