LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamWriter::write(bal::Cnf const&)
void write(const Cnf& value) override {
            write_parameters(value);
            write_variables(value);
            write_header(value);
            write_clauses(value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a9c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2aa8a
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamWriter::write_parameters(bal::Cnf const&)
virtual void write_parameters(const Cnf& value) {
            const formula_parameters_t parameters = value.get_parameters();
            for (auto it = parameters.begin(); it != parameters.end(); it++) {
                if (it->first.compare("writer") != 0) {
                    write_parameter(it->first, it->second);
                };
            };
            if (!value.is_empty()) {
                std::string writer_parameters = "is_sorted: 1, literals_order: \"ascending\", literals_compare_order: ";
                writer_parameters += (value.is_compare_left_right() ? "\"left-right\"" : "\"right-left\"");
                write_parameter("writer", writer_parameters);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
callq 0x3d444
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x2a750
movq 0x18(%r15), %r15
leaq -0x98(%rbp), %r14
cmpq %r14, %r15
je 0x2a449
leaq 0x1fc53(%rip), %r12     # 0x4a06a
leaq 0x20(%r15), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xc0b0
testl %eax, %eax
je 0x2a439
leaq 0x40(%r15), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2a6aa
movq %r15, %rdi
callq 0xc330
movq %rax, %r15
cmpq %r14, %rax
jne 0x2a417
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb %al, %al
jne 0x2a4d1
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1fc0b(%rip), %rsi     # 0x4a071
leaq 0x1fc47(%rip), %rdx     # 0x4a0b4
leaq -0x50(%rbp), %rdi
callq 0x1f29e
leaq 0x1fc38(%rip), %rsi     # 0x4a0b5
leaq -0x50(%rbp), %rdi
callq 0xc530
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1fbd5(%rip), %rsi     # 0x4a06a
leaq 0x1fbd4(%rip), %rdx     # 0x4a070
leaq -0x70(%rbp), %rdi
callq 0x1f29e
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
callq 0x2a6aa
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a4c3
callq 0xc280
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2a4d1
callq 0xc280
leaq -0xa0(%rbp), %rdi
callq 0x27bbc
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a504
callq 0xc280
jmp 0x2a504
jmp 0x2a501
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2a51b
callq 0xc280
jmp 0x2a51b
jmp 0x2a518
jmp 0x2a518
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x27bbc
movq %rbx, %rdi
callq 0xc4e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::CnfVigStreamWriter<false, false>::write(bal::Cnf const&)
void write(const Cnf& value) override {
            edges_data_t edges;
            unsigned next_edge_id = 0;
            compute_edges(value, TIMESTAMP_MIN, edges, next_edge_id);
            
            write_header(value);
            write_nodes(value, edges);
            write_edges(value, edges);
            write_footer(value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x14(%rbp), %r8
movl %ecx, (%r8)
movq (%rdi), %rax
leaq -0x48(%rbp), %rcx
xorl %edx, %edx
callq *0x38(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq (%r14), %rax
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r14), %rax
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq -0x48(%rbp), %rdi
callq 0x2bd54
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2bd54
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/io/cnfgraphml.hpp
// Function: bal::CnfGraphMLStreamWriter<true>::write_edge(unsigned int, unsigned int, bal::CnfVigStreamWriter<true, false>::__edge_data_t const&)
void write_edge(const variableid_t source_id, const variableid_t target_id, const edge_data_t& edge) override {
            if (WEIGHTED) {
                stream << "<edge source=\"v" << literal_t(variable_t__literal_id(source_id)) << "\" target=\"v" << literal_t(variable_t__literal_id(target_id)) << "\">" << std::endl;
                CnfGraphMLStreamWriter_write_edge_weighted<WEIGHTED>(stream, edge);
                stream << "</edge>" << std::endl;
            } else {
                stream << "<edge source=\"v" << literal_t(variable_t__literal_id(source_id)) << "\" target=\"v" << literal_t(variable_t__literal_id(target_id)) << "\"/>" << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x10(%rdi), %r13
leaq 0x1dfb3(%rip), %rsi     # 0x4a3de
movl $0xf, %edx
movq %r13, %rdi
callq 0xc320
leal 0x3(,%r12,2), %eax
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movq %r13, %rdi
callq 0x10712
movq %rax, %r12
leaq 0x1df96(%rip), %rsi     # 0x4a3ee
movl $0xb, %edx
movq %rax, %rdi
callq 0xc320
leal 0x3(,%r15,2), %eax
leaq -0x2c(%rbp), %rsi
movl %eax, (%rsi)
movq %r12, %rdi
callq 0x10712
movq %rax, %r15
leaq 0x1e16c(%rip), %rsi     # 0x4a5f1
movl $0x2, %edx
movq %rax, %rdi
callq 0xc320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1f83f
movq 0x10(%rbx), %rbx
leaq 0x1be35(%rip), %rsi     # 0x48305
movl $0x7, %edx
movq %rbx, %rdi
callq 0xc320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::edge_weight_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) {
            const clause_size_t clause_size = _clause_header_size(clause_header);
            const unsigned clause_cardinality = clause_size < 4 ?
                get_cardinality_uint16(_clause_header_flags(clause_header)) : 1;
            const double clause_weight = 2.0 * clause_cardinality / clause_size / (clause_size - 1);
            
            switch(action) {
                case eaInsert:
                case eaUpdate:
                    cardinality += clause_cardinality;
                    weight += clause_weight;
                    break;
                case eaRemove:
                    _assert_level_0(cardinality >= clause_cardinality);
                    cardinality -= clause_cardinality;
                    weight -= clause_weight;
                    break;
            };
        }

// Assembly:
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movl $0x1, %ecx
cmpl $0x3, %eax
ja 0x2cfa2
movl %esi, %ecx
shrl $0xf, %ecx
andl $0x1e, %ecx
leaq 0x19d3c(%rip), %r8      # 0x46cb0
movl %esi, %r9d
shrl $0x13, %r9d
andl $0x1e, %r9d
movzwl (%r9,%r8), %r9d
addw (%rcx,%r8), %r9w
movl %esi, %ecx
shrl $0x17, %ecx
andl $0x1e, %ecx
addw (%rcx,%r8), %r9w
shrl $0x1c, %esi
addw (%r8,%rsi,2), %r9w
movzwl %r9w, %ecx
leal (%rcx,%rcx), %esi
cvtsi2sd %esi, %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
decl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
cmpl $0x2, %edx
jae 0x2cfd0
addl %ecx, (%rdi)
addsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
retq
jne 0x2cfe8
movl (%rdi), %eax
subl %ecx, %eax
jb 0x2cfe9
movl %eax, (%rdi)
movsd 0x8(%rdi), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1d499(%rip), %rdi     # 0x4a48d
leaq 0x1d4b4(%rip), %rsi     # 0x4a4af
leaq 0x1d4c5(%rip), %rcx     # 0x4a4c7
movl $0x50, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, -0x30(%rbp)
movl %esi, %r13d
movq %rdi, %r14
movq 0x10(%rdi), %r12
leaq 0x16654(%rip), %rsi     # 0x4a8dd
movl $0xa, %edx
movq %r12, %rdi
callq 0xc320
movl 0xc(%rbx), %esi
movq %r12, %rdi
callq 0xc190
leaq 0x18832(%rip), %r12     # 0x4cada
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xc320
movq 0x10(%r14), %r15
leaq 0x16625(%rip), %rsi     # 0x4a8e8
movl $0x9, %edx
movq %r15, %rdi
callq 0xc320
leal 0x3(,%r13,2), %eax
leaq -0x38(%rbp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x10712
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xc320
movq 0x10(%r14), %r15
leaq 0x165f1(%rip), %rsi     # 0x4a8f2
movl $0x9, %edx
movq %r15, %rdi
callq 0xc320
movq -0x30(%rbp), %rax
leal 0x3(,%rax,2), %eax
leaq -0x34(%rbp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x10712
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xc320
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x1f7b4
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x2db9b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0xc260
leaq -0x18(%rbp), %rdi
movq %rax, (%rdi)
callq 0xc200
leaq 0x1cc57(%rip), %rdx     # 0x4a79b
leaq -0x80(%rbp), %rdi
movl $0x64, %esi
movq %rax, %rcx
callq 0xc220
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testq %rax, %rax
je 0x2db7d
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0xc110
leaq (%rax,%rbp), %rdx
addq $-0x80, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x2db8a
leaq 0x20250(%rip), %rdx     # 0x4ddd4
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1f29e
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2dc1a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2dcae
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ddba
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2de82
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f463
movq %rsi, %r15
movl $0x40, %edi
callq 0xc2c0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x301b2
movq %r12, (%rbx)
movq (%r12), %rax
movq -0x20(%rax), %rax
incl 0x8(%r12,%rax)
jmp 0x2f476
movq $0x0, (%rbx)
leaq -0x24(%rbp), %rsi
movq %rbx, %rdi
callq 0x2ff78
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/encoding/formulatracer.hpp
// Function: bal::FormulaTracer<32ul, bal::Literal<bal::Anf>>::trace(char const*, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> const&)
void trace(const char* const name, const Ref<GF2NElement<N, GF2E>>& value) override {
            Tracer<N, GF2E>::trace(name, value);
            VariablesArray array = variables_array(value);
#ifdef TRACER_LOG_COUT
            std::cout << name << ": " << array << std::endl;
#endif
            formula_.add_named_variable(name, array);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movl $0x20, %esi
callq 0xfa02
movl $0x20, 0x1c(%r12)
movq (%r12), %rax
movq (%r15), %rcx
movl $0x25, %edx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x304b4
movl 0x20(%rsi), %esi
movl %esi, (%rax)
decq %rdx
addq $0x4, %rax
cmpq $0x5, %rdx
jne 0x30458
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rdx
movq %rbx, %rsi
callq 0x3cea8
cmpl $0x0, -0x28(%rbp)
je 0x304a7
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x3049f
callq 0xc350
movq $0x0, -0x40(%rbp)
xorl %eax, %eax
movl %eax, -0x38(%rbp)
movl %eax, -0x28(%rbp)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ad22(%rip), %rdi     # 0x4b1dd
leaq 0x19945(%rip), %rsi     # 0x49e07
leaq 0x1ad36(%rip), %rcx     # 0x4b1ff
movl $0x188, %edx            # imm = 0x188
callq 0xc180
movq %rax, %rbx
cmpl $0x0, -0x28(%rbp)
je 0x304e9
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xcab1
movq %rbx, %rdi
callq 0xc4e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/encoding/formulatracer.hpp
// Function: bal::FormulaTracer<32ul, bal::Literal<bal::Anf>>::trace(char const*, unsigned long, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> const&)
void trace(const char* const name, const size_t index, const Ref<GF2NElement<N, GF2E>>& value) override {
            Tracer<N, GF2E>::trace(name, index, value);
            VariablesArray array = variables_array(value);
#ifdef TRACER_LOG_COUT
            std::cout << name << "[" << index << "]: " << array << std::endl;
#endif
            formula_.add_named_variable(name, array, (variables_size_t)index);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movl $0x20, %esi
callq 0xfa02
movl $0x20, 0x1c(%r13)
movq (%r13), %rax
movq (%r12), %rcx
movl $0x25, %edx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x30595
movl 0x20(%rsi), %esi
movl %esi, (%rax)
decq %rdx
addq $0x4, %rax
cmpq $0x5, %rdx
jne 0x30535
movq 0x8(%r15), %rdi
leaq -0x48(%rbp), %rdx
movq %r14, %rsi
movl %ebx, %ecx
callq 0x3cfae
cmpl $0x0, -0x30(%rbp)
je 0x30586
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x3057e
callq 0xc350
movq $0x0, -0x48(%rbp)
xorl %eax, %eax
movl %eax, -0x40(%rbp)
movl %eax, -0x30(%rbp)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ac41(%rip), %rdi     # 0x4b1dd
leaq 0x19864(%rip), %rsi     # 0x49e07
leaq 0x1ac55(%rip), %rcx     # 0x4b1ff
movl $0x188, %edx            # imm = 0x188
callq 0xc180
movq %rax, %rbx
cmpl $0x0, -0x30(%rbp)
je 0x305ca
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xcadc
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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, %edx
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rdx, %rax
shrq $0x24, %rax
cmpl $0x3, %eax
ja 0x30646
movq %rdi, %rbx
leaq 0x17caa(%rip), %rdx     # 0x482a0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq (%rcx), %rdx
movq (%r8), %rcx
movq (%r9), %r8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x313e9
jmp 0x3063c
movq (%rcx), %rdx
movq (%r8), %rcx
movq (%r9), %r8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30d77
jmp 0x3063c
movq (%rcx), %rdx
movq (%r8), %rcx
movq (%r9), %r8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31489
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x19645(%rip), %rdi     # 0x49c92
leaq 0x1ac52(%rip), %rsi     # 0x4b2a6
leaq 0x1ae5a(%rip), %rcx     # 0x4b4b5
movl $0x29, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0x308e7
movl $0x30, %r12d
movl %ebx, %eax
andl $0x1f, %eax
movq (%r15), %rdi
addq %r12, %rdi
movq 0x30(%r14,%rax,8), %rsi
callq 0x3003c
incl %ebx
addq $0x8, %r12
cmpq $0x130, %r12            # imm = 0x130
jne 0x308b7
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30906
movq (%rsi), %rax
movq -0x20(%rax), %rax
incl 0x8(%rsi,%rax)
jmp 0x3090e
movq %rbx, %rdi
callq 0x30931
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x30929
movq %rbx, %rsi
callq 0xcb3e
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x308e7
xorl %r13d, %r13d
leaq 0xf(,%r14,8), %rax
andq $-0x10, %rax
movq %rax, -0x30(%rbp)
movq %rsp, %r12
movq %rsp, %rdx
subq -0x30(%rbp), %rdx
movq %rdx, %rsp
testq %r14, %r14
je 0x30a39
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movq 0x30(%rcx,%r13,8), %rcx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x30a24
movq (%rbx), %rax
movq 0x30(%rax,%r13,8), %rsi
leaq -0x38(%rbp), %rdi
movq %r14, %rcx
callq 0x30a92
movq %r12, %rsp
movq (%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax,%r13,8)
incq %r13
cmpq $0x20, %r13
jne 0x30a10
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x30a8a
movq %rbx, %rsi
callq 0xcb75
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30c19
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x30c17
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
cmpq %rax, %rcx
sete %cl
orb %dl, %cl
je 0x30c38
movq %rax, (%rdi)
popq %rbp
retq
leaq 0x1a768(%rip), %rdi     # 0x4b388
leaq 0x191e0(%rip), %rsi     # 0x49e07
leaq 0x1a76e(%rip), %rcx     # 0x4b39c
movl $0x57, %edx
callq 0xc180
leaq 0x1a7a5(%rip), %rdi     # 0x4b3e4
leaq 0x191c1(%rip), %rsi     # 0x49e07
leaq 0x1a74f(%rip), %rcx     # 0x4b39c
movl $0x59, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x308e7
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x30(%rax,%r13), %rsi
movq 0x30(%r12,%r13), %rdx
movq 0x30(%r15,%r13), %rcx
movq 0x30(%r14,%r13), %r8
leaq -0x30(%rbp), %rdi
callq 0x30dff
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r13)
addq $0x8, %r13
cmpq $0x100, %r13            # imm = 0x100
jne 0x30d99
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
testq %rdi, %rdi
je 0x30df7
movq %rbx, %rsi
callq 0xcbac
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movl 0x20(%rdx), %r15d
leal 0x1(%r15), %eax
cmpl $0x3, %eax
jae 0x3116d
cmpl $0x1, %r15d
ja 0x3114f
xorl $0x1, %r15d
leaq -0x24(%rbp), %rsi
movl %r15d, (%rsi)
movq $0x0, (%rbx)
movq %rbx, %rdi
jmp 0x31166
cmpl $-0x1, %r15d
jne 0x311ad
addq $0x20, %r14
movq $0x0, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ff78
jmp 0x3119d
movl $0x40, %edi
callq 0xc2c0
movq %rax, %r12
movq 0x18(%r14), %rsi
xorl $0x1, %r15d
movq %rax, %rdi
movl %r15d, %edx
callq 0x301b2
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
leaq 0x18ade(%rip), %rdi     # 0x49c92
leaq 0x18c4c(%rip), %rsi     # 0x49e07
leaq 0x1a46d(%rip), %rcx     # 0x4b62f
movl $0x74, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31205
movq %r14, (%rbx)
testq %r14, %r14
je 0x3123d
movq (%r14), %rax
movq -0x20(%rax), %rax
incl 0x8(%r14,%rax)
jmp 0x3123d
movl %eax, %edx
xorl %ecx, %edx
cmpl $0x1, %edx
jne 0x31214
leaq -0x28(%rbp), %rsi
jmp 0x31228
testl %ecx, %ecx
setne %dl
testl %eax, %eax
setne %sil
testb %sil, %dl
jne 0x3124d
leaq -0x24(%rbp), %rsi
movl $0x0, (%rsi)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x2ffda
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %ecx
jne 0x3125c
movq %r15, (%rbx)
testq %r15, %r15
jne 0x312ab
jmp 0x3123d
cmpl $0x1, %eax
je 0x311ef
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x312b9
cmpq 0x18(%r15), %rdi
jne 0x312b9
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 0xfe1d
movl $0x40, %edi
callq 0xc2c0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
movl %r12d, %edx
callq 0x301b2
movq %r15, (%rbx)
movq (%r15), %rax
movq -0x20(%rax), %rax
incl 0x8(%r15,%rax)
jmp 0x3123d
leaq 0x1a3e3(%rip), %rdi     # 0x4b6a3
leaq 0x18b40(%rip), %rsi     # 0x49e07
leaq 0x1a407(%rip), %rcx     # 0x4b6d5
movl $0xf8, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31318
movq %r14, (%rbx)
testq %r14, %r14
je 0x313ba
movq (%r14), %rax
movq -0x20(%rax), %rax
incl 0x8(%r14,%rax)
jmp 0x313ba
movl %eax, %edx
xorl %ecx, %edx
cmpl $0x1, %edx
jne 0x3133c
leaq -0x28(%rbp), %rsi
movl $0x1, (%rsi)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x2ffda
jmp 0x313ba
testl %ecx, %ecx
je 0x3135a
testl %eax, %eax
je 0x312fb
cmpl $0x1, %ecx
setne %cl
cmpl $0x1, %eax
setne %al
testb %al, %cl
jne 0x31364
leaq -0x24(%rbp), %rsi
jmp 0x31325
movq %r15, (%rbx)
testq %r15, %r15
jne 0x313ae
jmp 0x313ba
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x313ca
cmpq 0x18(%r15), %rdi
jne 0x313ca
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 0xfeb6
movl $0x40, %edi
callq 0xc2c0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
movl %r12d, %edx
callq 0x301b2
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 0x1a2d2(%rip), %rdi     # 0x4b6a3
leaq 0x18a2f(%rip), %rsi     # 0x49e07
leaq 0x1a380(%rip), %rcx     # 0x4b75f
movl $0x112, %edx            # imm = 0x112
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x308e7
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x30(%rax,%r13), %rsi
movq 0x30(%r12,%r13), %rax
movq 0x30(%r15,%r13), %rcx
movq 0x30(%r14,%r13), %rdx
movq %rax, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movl $0x3, %ecx
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x30a92
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r13)
addq $0x8, %r13
cmpq $0x100, %r13            # imm = 0x100
jne 0x3140e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31481
movq %rbx, %rsi
callq 0xcc88
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x308e7
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x30(%rax,%r13), %rsi
movq 0x30(%r12,%r13), %rdx
movq 0x30(%r15,%r13), %rcx
movq 0x30(%r14,%r13), %r8
leaq -0x30(%rbp), %rdi
callq 0x31511
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r13)
addq $0x8, %r13
cmpq $0x100, %r13            # imm = 0x100
jne 0x314ab
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
testq %rdi, %rdi
je 0x31509
movq %rbx, %rsi
callq 0xccbf
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15d
movq %rdx, %r14
movq %rdi, %rbx
callq 0x308e7
movslq %r15d, %r12
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r15
leaq (%r12,%r13), %rax
cmpq $0x1f, %rax
ja 0x33654
movq (%rbx), %rcx
leaq (%rcx,%r13,8), %rdi
addq $0x30, %rdi
movq 0x30(%r14,%rax,8), %rsi
callq 0x3003c
jmp 0x3366e
movl $0x0, -0x2c(%rbp)
movq (%rbx), %rax
leaq (%rax,%r13,8), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x2ffda
incq %r13
cmpq $0x20, %r13
jne 0x33633
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
testq %rdi, %rdi
je 0x3369c
movq %rbx, %rsi
callq 0xd188
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x338f9
movq %rdi, %r14
cmpq $0x0, 0x60(%rdi)
jne 0x33918
movq %rsi, %rbx
leaq 0x38(%r14), %r15
leaq 0x68(%r14), %r12
movq $0x0, 0x68(%r14)
movq %rsi, 0x30(%r14)
leaq 0x18(%r14), %r13
movq %r13, %rdi
callq 0x33b0a
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 0x34996
leaq 0x1530f(%rip), %rdi     # 0x48c0f
leaq 0x184ca(%rip), %rsi     # 0x4bdd1
leaq 0x184e6(%rip), %rcx     # 0x4bdf4
movl $0x2f, %edx
callq 0xc180
leaq 0x18509(%rip), %rdi     # 0x4be28
leaq 0x184ab(%rip), %rsi     # 0x4bdd1
leaq 0x184c7(%rip), %rcx     # 0x4bdf4
movl $0x30, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3399a
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 0x33ea8
movq $0x0, 0x30(%rbx)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x34e34
leaq 0x1849a(%rip), %rdi     # 0x4be3b
leaq 0x18429(%rip), %rsi     # 0x4bdd1
leaq 0x1849e(%rip), %rcx     # 0x4be4d
movl $0x39, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34fc6
cmpl $0x1, %edx
je 0x34fc2
testl %edx, %edx
jne 0x34fda
movl $0x1, (%rdi)
movl %ecx, 0x4(%rdi)
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
jmp 0x34fda
incl (%rdi)
jmp 0x34fda
cmpl %ecx, 0x4(%rdi)
ja 0x34fdc
movl (%rdi), %eax
testl %eax, %eax
je 0x34ffb
decl %eax
movl %eax, (%rdi)
jne 0x34fda
movl %ecx, 0x8(%rdi)
popq %rbp
retq
leaq 0x16e94(%rip), %rdi     # 0x4be77
leaq 0x154c5(%rip), %rsi     # 0x4a4af
leaq 0x16e99(%rip), %rcx     # 0x4be8a
movl $0x31, %edx
callq 0xc180
leaq 0x16eec(%rip), %rdi     # 0x4beee
leaq 0x154a6(%rip), %rsi     # 0x4a4af
leaq 0x16e7a(%rip), %rcx     # 0x4be8a
movl $0x32, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, -0x1c(%rbp)
cmpl $0x2, %edi
jae 0x37a64
xorl %eax, %eax
cmpl $0x1, %edi
sete %al
addl %eax, (%rcx)
jmp 0x37b44
movq %rsi, %rbx
movq (%rsi), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
setne %r14b
je 0x37b1f
sarq $0x2, %rax
cmpq $0x1, %rax
movq %rax, %r9
adcq $0x0, %r9
movl (%rsi), %r8d
xorl %edi, %r8d
cmpl $0x2, %r8d
jae 0x37a9b
xorl %r15d, %r15d
jmp 0x37abe
decq %r9
xorl %r15d, %r15d
cmpq %r15, %r9
je 0x37b1f
movl 0x4(%rsi,%r15,4), %r8d
xorl %edi, %r8d
incq %r15
cmpl $0x1, %r8d
ja 0x37aa1
cmpq %r15, %rax
seta %r14b
cmpl $0x1, %r8d
jne 0x37ac8
incl (%rcx)
jmp 0x37af0
movl %edi, -0x20(%rbp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0x37ae1
movl %edi, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdx)
jmp 0x37af0
leaq -0x20(%rbp), %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0xfc7c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rsi
sarq $0x2, %rsi
cmpq $0x2, %rsi
jb 0x37b0f
movl -0x4(%rax,%rcx), %ecx
movl %ecx, (%rax,%r15,4)
decq %rsi
movq %rbx, %rdi
callq 0x23056
testb %r14b, %r14b
jne 0x37b44
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x37b38
movl -0x1c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x37b44
leaq -0x1c(%rbp), %rdx
movq %rbx, %rdi
callq 0xfc7c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3664f
leaq -0x30(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movq (%rbx), %rdi
movl $0x2, %edx
callq 0x37419
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x37d8c
movq %rbx, %rsi
callq 0xd579
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
movq 0x38(%r14), %rdx
callq 0xc320
cmpq $0x0, (%r14)
je 0x3aa3b
leaq 0x12102(%rip), %rsi     # 0x4cac7
movl $0x8, %edx
movq %rbx, %rdi
callq 0xc320
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xc190
movq %rax, %r15
leaq 0x120e9(%rip), %rsi     # 0x4cad0
movl $0x7, %edx
movq %rax, %rdi
callq 0xc320
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xc190
movq %rax, %r15
leaq 0x120ce(%rip), %rsi     # 0x4cad8
movl $0x3, %edx
movq %rax, %rdi
callq 0xc320
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %r15, %rdi
callq 0xc320
leaq 0x120ac(%rip), %rsi     # 0x4cada
movl $0x1, %edx
movq %rax, %rdi
callq 0xc320
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_quoted[abi:cxx11]()
std::string read_quoted() {
        load_next_token();
        if (current_token_type_ == ttQuoted) {
            std::string result = current_line_.substr(current_token_pos_ + 1, current_token_len_ - 2);
            skip_token();
            return result;
        } else {
            parse_error("Expect a quoted value");
            return std::string();
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1eae0
cmpl $0x7, 0x40(%r14)
jne 0x3b52d
leaq 0x18(%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
incq %rdx
addq $-0x2, %rcx
movq %rbx, %rdi
callq 0xc2e0
movq 0x10(%r14), %rax
addq %rax, 0x8(%r14)
movq $0x0, 0x10(%r14)
movl $0x0, 0x40(%r14)
jmp 0x3b57c
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x1155d(%rip), %rsi     # 0x4ca9a
leaq 0x1156b(%rip), %rdx     # 0x4caaf
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x1f29e
movq %r14, %rdi
movq %r15, %rsi
callq 0x1de0a
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3b569
callq 0xc280
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3b59d
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0
nop