LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_bin()
inline void parse_bin() {
        current_token_len_++;
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_bin_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_BIN_INVALID_SYMBOL);
        } else if (current_token_len_ == 2) {
            parse_error(ERROR_MISSING_BIN_VALUE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
leaq 0x2(%rcx), %rax
movq 0x20(%rdi), %rsi
movq %rax, 0x10(%rdi)
addq %rdx, %rcx
addq $0x2, %rcx
cmpq %rsi, %rcx
setb %dil
jae 0x1eeda
movq 0x18(%rbx), %r8
movb (%r8,%rcx), %r9b
andb $-0x2, %r9b
cmpb $0x30, %r9b
jne 0x1ee6f
leaq (%rdx,%rax), %rcx
incq %rcx
incq %rax
movq %rax, 0x10(%rbx)
cmpq %rsi, %rcx
setb %dil
jb 0x1ee48
jmp 0x1eeda
testb %dil, %dil
je 0x1eeda
movq 0x18(%rbx), %rdx
movb (%rdx,%rcx), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
setb %dl
leal -0x41(%rcx), %esi
cmpb $0x1a, %sil
setb %sil
orb %dl, %sil
jne 0x1eea7
leal -0x61(%rcx), %edx
cmpb $0x1a, %dl
setae %dl
cmpb $0x5f, %cl
setne %cl
testb %dl, %cl
jne 0x1eeda
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28fac(%rip), %rsi     # 0x47e62
leaq 0x28fc3(%rip), %rdx     # 0x47e80
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x1f29e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1de0a
movq -0x58(%rbp), %rdi
jmp 0x1ef11
cmpq $0x2, %rax
jne 0x1ef1b
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28f92(%rip), %rsi     # 0x47e81
leaq 0x28fba(%rip), %rdx     # 0x47eb0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1f29e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1de0a
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1ef1b
callq 0xc280
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x1ef36
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1ef40
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_dec()
inline void parse_dec() {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_dec_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_DEC_INVALID_SYMBOL);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
incq %rcx
movq 0x8(%rdi), %rsi
addq %rcx, %rsi
movq %rcx, 0x10(%rbx)
cmpq %rax, %rsi
jae 0x1f002
movq %rsi, %rdi
movb (%rdx,%rsi), %r8b
addb $-0x30, %r8b
incq %rsi
incq %rcx
cmpb $0xa, %r8b
jb 0x1ef6e
cmpq %rax, %rdi
jae 0x1f002
movq 0x18(%rbx), %rax
movb -0x1(%rax,%rsi), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
setb %cl
leal -0x41(%rax), %edx
cmpb $0x1a, %dl
setb %dl
orb %cl, %dl
jne 0x1efc7
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
setae %cl
cmpb $0x5f, %al
setne %al
testb %cl, %al
jne 0x1f002
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28edb(%rip), %rsi     # 0x47eb1
leaq 0x28ef3(%rip), %rdx     # 0x47ed0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1f29e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1de0a
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f002
callq 0xc280
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f01e
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_quoted(char)
inline void parse_quoted(const char quote_symbol) {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
            (current_line_[current_token_pos_ + current_token_len_] != quote_symbol)) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            (current_line_[current_token_pos_ + current_token_len_] == quote_symbol)) {
            current_token_len_++;
        } else {
            parse_error(ERROR_MISSING_CLOSING_QUOTE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
incq %rdx
movq 0x18(%rdi), %rdi
addq %rax, %rdi
movq %rdx, 0x10(%rbx)
leaq (%rax,%rdx), %r9
cmpq %rcx, %r9
jae 0x1f07c
leaq 0x1(%rdx), %r8
cmpb %sil, (%rdi,%rdx)
movq %r8, %rdx
jne 0x1f04c
cmpq %rcx, %r9
jae 0x1f07c
addq 0x18(%rbx), %rax
cmpb %sil, -0x1(%r8,%rax)
jne 0x1f07c
movq %r8, 0x10(%rbx)
jmp 0x1f0b7
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28e46(%rip), %rsi     # 0x47ed1
leaq 0x28e5b(%rip), %rdx     # 0x47eed
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1f29e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1de0a
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f0b7
callq 0xc280
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f0d3
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: void bal::CnfGexfStreamWriter_write_edge_weighted<true>(std::ostream&, bal::edge_weight_data_t<true> const&)
void CnfGexfStreamWriter_write_edge_weighted<true>(std::ostream& stream, const edge_weight_data_t<true>& edge) {
        stream << " weight=\"" << edge.weight << "\"";
        if (edge.cardinality != 1) {
            stream << ">" << std::endl;
            stream << "  <attvalues>" << std::endl;
            stream << "    <attvalue for=\"0\" value=\"" << edge.cardinality << "\"/>" << std::endl;
            stream << "  </attvalues>" << std::endl;
            stream << "</edge>" << std::endl;
        } else {
            stream << "/>" << std::endl;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28c9c(%rip), %rsi     # 0x482c0
movl $0x9, %edx
callq 0xc320
movsd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0xc440
leaq 0x2d497(%rip), %rsi     # 0x4cada
movl $0x1, %edx
movq %rax, %rdi
callq 0xc320
cmpl $0x1, (%r14)
jne 0x1f667
leaq 0x2ae2d(%rip), %rsi     # 0x4a48a
movl $0x2, %edx
jmp 0x1f781
leaq 0x2af84(%rip), %rsi     # 0x4a5f2
movl $0x1, %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
leaq 0x28c21(%rip), %rsi     # 0x482ca
movl $0xd, %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
leaq 0x28bf4(%rip), %rsi     # 0x482d8
movl $0x1d, %edx
movq %rbx, %rdi
callq 0xc320
movl (%r14), %esi
movq %rbx, %rdi
callq 0xc190
movq %rax, %r14
leaq 0x2ad83(%rip), %rsi     # 0x4a489
movl $0x3, %edx
movq %rax, %rdi
callq 0xc320
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xc2a0
movsbl %al, %esi
movq %r14, %rdi
callq 0xc030
movq %rax, %rdi
callq 0xc1a0
leaq 0x28bb5(%rip), %rsi     # 0x482f6
movl $0xe, %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
leaq 0x28b89(%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
popq %rbx
popq %r14
popq %rbp
jmp 0xc1a0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: void bal::CnfGexfStreamWriter_write_edge_dynamic<true>(std::ostream&, bal::edge_dynamic_data_t<true> const&)
void CnfGexfStreamWriter_write_edge_dynamic<true>(std::ostream& stream, const edge_dynamic_data_t<true>& edge) {
        if (edge.start != TIMESTAMP_MIN) {
            stream << " start=\"" << edge.start << "\"";
        };
        if (edge.end != TIMESTAMP_MAX) {
            stream << " end=\"" << edge.end << "\"";
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0x1f7fb
leaq 0x28b3f(%rip), %rsi     # 0x4830d
movl $0x8, %edx
movq %rbx, %rdi
callq 0xc320
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0xc190
leaq 0x2d2ec(%rip), %rsi     # 0x4cada
movl $0x1, %edx
movq %rax, %rdi
callq 0xc320
cmpl $-0x1, 0x8(%r14)
je 0x1f83a
leaq 0x28b0d(%rip), %rsi     # 0x48316
movl $0x6, %edx
movq %rbx, %rdi
callq 0xc320
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0xc190
leaq 0x2d2b1(%rip), %rsi     # 0x4cada
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc320
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: print_statistics(bal::Anf const&)
void print_statistics(const bal::Anf& anf) {
    if (anf.equations_size() == 0) {
        std::cout << MSG_FORMULA_IS_SATISFIABLE << std::endl;
    } else {
        std::cout << "ANF: " << std::dec;
        std::cout << anf.variables_size() << " variables, ";
        std::cout << anf.equations_size() << " equations" << std::endl;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xb0(%rdi), %rax
cmpq 0xa8(%rdi), %rax
je 0x1fc02
movq %rdi, %rbx
movq 0x3f426(%rip), %r14     # 0x5efa8
leaq 0x2882d(%rip), %rsi     # 0x483b6
movl $0x5, %edx
movq %r14, %rdi
callq 0xc320
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0xc190
leaq 0x287f5(%rip), %rsi     # 0x483bc
movl $0xc, %edx
movq %rax, %rdi
callq 0xc320
movq 0xb0(%rbx), %rsi
subq 0xa8(%rbx), %rsi
sarq $0x2, %rsi
movq %r14, %rdi
callq 0xc190
movq %rax, %rbx
leaq 0x287d1(%rip), %rsi     # 0x483c9
movl $0xa, %edx
movq %rax, %rdi
jmp 0x1fc18
movq 0x3f39f(%rip), %rbx     # 0x5efa8
leaq 0x28746(%rip), %rsi     # 0x48356
movl $0x1a, %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
popq %rbx
popq %r14
popq %rbp
jmp 0xc1a0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: save(bal::Cnf&, char const*, CGenOutputFormat)
void save(bal::Cnf& cnf, const char* const file_name, const CGenOutputFormat output_format) {
    save_append_parameters(cnf);
    switch (output_format) {
        case ofCnfDimacs:
            save_impl<bal::Cnf, bal::DimacsStreamWriter>(cnf, file_name);
            break;
        case ofCnfVIGGraphML:
            save_impl<bal::Cnf, bal::CnfGraphMLStreamWriter<false>>(cnf, file_name);
            break;
        case ofCnfWeightedVIGGraphML:
            save_impl<bal::Cnf, bal::CnfGraphMLStreamWriter<true>>(cnf, file_name);
            break;
        case ofCnfVIGGEXF:
            save_impl<bal::Cnf, bal::CnfGexfStreamWriter<false, false>>(cnf, file_name);
            break;
        default:
            throw std::invalid_argument(ERROR_OUTPUT_FORMAT_UNSUPPORTED);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1fc48
decl %r15d
cmpl $0x3, %r15d
ja 0x1ff3e
leaq 0x2837f(%rip), %rax     # 0x48260
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x226c0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x229c8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22b4e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22842
movl $0x10, %edi
callq 0xc130
movq %rax, %rbx
leaq 0x284c0(%rip), %rsi     # 0x48412
movq %rax, %rdi
callq 0xc520
movq 0x3f06f(%rip), %rsi     # 0x5efd0
movq 0x3f050(%rip), %rdx     # 0x5efb8
movq %rbx, %rdi
callq 0xc4b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xc1e0
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: save(bal::Anf&, char const*, CGenOutputFormat)
void save(bal::Anf& anf, const char* const file_name, const CGenOutputFormat output_format) {
    save_append_parameters(anf);
    switch (output_format) {
        case ofAnfPolybori:
            save_impl<bal::Anf, bal::PolyBoRiStreamWriter>(anf, file_name);
            break;
        default:
            throw std::invalid_argument(ERROR_OUTPUT_FORMAT_UNSUPPORTED);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1fc48
testl %r15d, %r15d
jne 0x1ffb5
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22cd4
movl $0x10, %edi
callq 0xc130
movq %rax, %rbx
leaq 0x28449(%rip), %rsi     # 0x48412
movq %rax, %rdi
callq 0xc520
movq 0x3eff8(%rip), %rsi     # 0x5efd0
movq 0x3efd9(%rip), %rdx     # 0x5efb8
movq %rbx, %rdi
callq 0xc4b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xc1e0
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: get_formula_named_variable(bal::Formula const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const bal::VariablesArray* const get_formula_named_variable(const bal::Formula& formula, const std::string& name) {
    auto vn_it = formula.get_named_variables().find(name);
    if (vn_it == formula.get_named_variables().end()) {
        throw std::invalid_argument(std::string("\"") + name + std::string("\" ") +
                                    std::string(ERROR_UNKNOWN_VARIABLE_NAME));
    };
    
    return &(vn_it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x3ce9e
movq %rax, %rdi
movq %r14, %rsi
callq 0x2deda
movq %rax, %rbx
movq %r15, %rdi
callq 0x3ce9e
addq $0x8, %rax
cmpq %rax, %rbx
je 0x20051
addq $0x40, %rbx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xc130
movq %rax, %rbx
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x2ca6d(%rip), %rsi     # 0x4cada
leaq 0x2ca67(%rip), %rdx     # 0x4cadb
leaq -0x88(%rbp), %rdi
callq 0x1f29e
leaq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movq %r14, %rdx
callq 0x22f08
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x283a4(%rip), %rsi     # 0x4844a
leaq 0x2839f(%rip), %rdx     # 0x4844c
leaq -0x68(%rbp), %rdi
callq 0x1f29e
leaq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x22e56
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x28371(%rip), %rsi     # 0x4844d
leaq 0x2839a(%rip), %rdx     # 0x4847d
leaq -0x48(%rbp), %rdi
callq 0x1f29e
leaq -0xe8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x22e56
movb $0x1, %r13b
leaq -0xe8(%rbp), %rsi
movq %rbx, %rdi
callq 0xc4d0
xorl %r13d, %r13d
movq 0x3eeb1(%rip), %rsi     # 0x5efd0
movq 0x3ee92(%rip), %rdx     # 0x5efb8
movq %rbx, %rdi
callq 0xc4b0
movq %rax, %r14
leaq -0xd8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2014e
callq 0xc280
jmp 0x2014e
movq %rax, %r14
movb $0x1, %r13b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x20168
callq 0xc280
jmp 0x20168
movq %rax, %r14
movb $0x1, %r13b
leaq -0xb8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20185
callq 0xc280
jmp 0x20185
movq %rax, %r14
movb $0x1, %r13b
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x2019b
callq 0xc280
jmp 0x2019b
movq %rax, %r14
movb $0x1, %r13b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x201b8
callq 0xc280
jmp 0x201b8
movq %rax, %r14
movb $0x1, %r13b
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x201d1
callq 0xc280
jmp 0x201d1
movq %rax, %r14
movb $0x1, %r13b
testb %r13b, %r13b
je 0x201de
movq %rbx, %rdi
callq 0xc1e0
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: variable_define_random(CGenVariableInfo&, bal::VariablesArray const&)
void variable_define_random(CGenVariableInfo& value, const bal::VariablesArray& definition) {
    _assert_level_0(value.mode == vmRandom);
    
    std::random_device rd;
    std::uniform_int_distribution<unsigned int> value_distribution(0, 1);
    
    value.data = definition;
    bal::literalid_t* const data = value.data.data();
    
    for (auto i = 0; i < value.data.size(); i++) {
        if (!literal_t__is_constant(data[i])) {
            data[i] = literal_t__constant(value_distribution(rd));
        };
    };
    
    // the value has been generated now
    // change the entry type to avoid generating a different value again
    value.mode = vmValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1398, %rsp           # imm = 0x1398
cmpl $0x1, (%rdi)
jne 0x2029d
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x13b8(%rbp), %rdi
callq 0x22f6c
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, -0x30(%rbp)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xfa68
movl 0x1c(%r14), %eax
movl %eax, 0x34(%rbx)
cmpl $0x0, 0x20(%rbx)
je 0x20279
movq 0x18(%rbx), %r12
xorl %r13d, %r13d
leaq -0x13b8(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpl $0x2, (%r12,%r13,4)
jb 0x2026e
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2df78
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, (%r12,%r13,4)
incq %r13
movl 0x20(%rbx), %eax
cmpq %rax, %r13
jb 0x2024e
movl $0x0, (%rbx)
leaq -0x13b8(%rbp), %rdi
callq 0xc270
addq $0x1398, %rsp           # imm = 0x1398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x281da(%rip), %rdi     # 0x4847e
leaq 0x281ea(%rip), %rsi     # 0x48495
leaq 0x281f0(%rip), %rcx     # 0x484a2
movl $0xa0, %edx
callq 0xc180
jmp 0x202d7
jmp 0x202c0
movq %rax, %rbx
leaq -0x13b8(%rbp), %rdi
callq 0xc270
movq %rbx, %rdi
callq 0xc4e0
movq %rax, %rdi
callq 0x1f0db
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: variable_get_template(bal::Formula const&, char const*)
const bal::VariablesArray variable_get_template(const bal::Formula& formula, const char* const variable_name) {
    if (is_binary_variable_name(variable_name)) {
        const bal::literalid_t literal_id = bal::literal_t__from_cstr(variable_name);
        if (literal_t__variable_id(literal_id) >= formula.variables_size()) {
            throw std::invalid_argument("Variable number out of bounds: " + std::string(variable_name));
        };
        bal::VariablesArray result(1, 1);
        *result.data() = literal_id;
        return result;
    } else {
        return *get_formula_named_variable(formula, variable_name);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
leaq -0x70(%rbp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xc0f0
cmpq $0x0, 0x8(%r12)
je 0x20327
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
setb %r13b
jmp 0x2032a
xorl %r13d, %r13d
leaq -0x40(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x2033d
callq 0xc280
testb %r13b, %r13b
je 0x20391
movq %r14, %rdi
callq 0xc420
leal (%rax,%rax), %ecx
negl %ecx
testl %eax, %eax
leal 0x1(%rax,%rax), %r12d
cmovlel %ecx, %r12d
movl %r12d, %r13d
shrl %r13d
decl %r13d
movq (%r15), %rax
movq %r15, %rdi
callq *0x58(%rax)
cmpl %eax, %r13d
jae 0x203f9
movq %rbx, %rdi
movl $0x1, %esi
callq 0xfa02
movl $0x1, 0x1c(%rbx)
movq (%rbx), %rax
movl %r12d, (%rax)
jmp 0x203e7
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
movq %r14, %rsi
callq 0xc0f0
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
callq 0x1fffa
movq %rax, %r14
movq $0x0, (%rbx)
xorl %eax, %eax
movl %eax, 0x8(%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movl %eax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfa68
movl 0x1c(%r14), %eax
movl %eax, 0x1c(%rbx)
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x203e7
callq 0xc280
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xc130
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r14, %rsi
callq 0xc0f0
leaq 0x280d2(%rip), %rsi     # 0x484ef
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x22fdb
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xc4d0
xorl %r15d, %r15d
movq 0x3eb8d(%rip), %rsi     # 0x5efd0
movq 0x3eb6e(%rip), %rdx     # 0x5efb8
movq %rbx, %rdi
callq 0xc4b0
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x2046f
callq 0xc280
jmp 0x2046f
movq %rax, %r14
movb $0x1, %r15b
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20489
callq 0xc280
jmp 0x20489
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x204ae
movq %rbx, %rdi
callq 0xc1e0
jmp 0x204ae
movq %rax, %r14
jmp 0x204ae
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x204ae
callq 0xc280
movq %r14, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: variables_reset_assigned_values(bal::Formula const&, bal::VariablesArray const&, bal::VariablesArray&)
void variables_reset_assigned_values(const bal::Formula& formula,
                                     const bal::VariablesArray& variable_template,
                                     bal::VariablesArray& variable_value) {
    const bal::literalid_t* const template_data = variable_template.data();
    bal::literalid_t* const value_data = variable_value.data();
    
    for (auto i = 0; i < variable_value.size(); i++) {
        if (literal_t__is_variable(template_data[i]) && literal_t__is_constant(value_data[i])) {
            const bal::literalid_t value = formula.get_variable_value(literal_t__variable_id(template_data[i]));
            if (value == literal_t__substitute_literal(template_data[i], value_data[i])) {
                // reset binary variable value since it is already assigned within the formula
                value_data[i] = template_data[i];
            };
        };
    };
}

// Assembly:
cmpl $0x0, 0x8(%rdx)
je 0x20913
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq (%rdx), %r12
xorl %r13d, %r13d
movl (%r15,%r13,4), %esi
leal 0x1(%rsi), %eax
cmpl $0x3, %eax
jae 0x208d7
incq %r13
movl 0x8(%rbx), %eax
cmpq %rax, %r13
jb 0x208be
jmp 0x20905
cmpl $0x1, (%r12,%r13,4)
ja 0x208ca
shrl %esi
decl %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movl (%r15,%r13,4), %ecx
movl %ecx, %edx
andl $0x1, %edx
xorl (%r12,%r13,4), %eax
xorl %edx, %eax
cmpl $0x1, %eax
jne 0x208ca
movl %ecx, (%r12,%r13,4)
jmp 0x208ca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: variables_require_computing(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CGenVariableInfo, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, CGenVariableInfo>>> const&)
bool variables_require_computing(const CGenVariablesMap& variables_map) {
    for (auto it = variables_map.begin(); it != variables_map.end(); it++ ) {
        if (it->second.mode == vmCompute) {
            return true;
        };
    };
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
setne %cl
je 0x210bf
cmpl $0x2, 0x40(%rax)
je 0x210bf
movq %rax, %rdi
callq 0xc330
jmp 0x210a7
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commands.cpp
// Function: void save_impl<bal::Cnf, bal::CnfGraphMLStreamWriter<false>>(bal::Cnf const&, char const*)
void save_impl(const Formula& formula, const char* const file_name) {
    std::cout << "Output file: " << file_name << std::endl;
    
    std::ofstream file(file_name);
    if (file.is_open()) {
        Writer writer(file);
        writer.write(formula);
        file.close();
    }
    else {
        throw std::invalid_argument(ERROR_FAILED_OPENING_OUTPUT_FILE);
    };
    
    print_statistics(formula);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3c749(%rip), %r15     # 0x5efa8
leaq 0x277d7(%rip), %rsi     # 0x4a03d
movl $0xd, %edx
movq %r15, %rdi
callq 0xc320
testq %r14, %r14
je 0x22894
movq %r14, %rdi
callq 0xc110
movq 0x3c721(%rip), %rdi     # 0x5efa8
movq %r14, %rsi
movq %rax, %rdx
callq 0xc320
jmp 0x228ac
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xc4a0
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
leaq -0x230(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0xc300
leaq -0x1c0(%rbp), %rdi
callq 0xc080
testb %al, %al
je 0x22970
leaq -0x30(%rbp), %rdi
movq %r15, 0x8(%rdi)
leaq 0x3aeff(%rip), %rax     # 0x5d808
movq %rax, (%rdi)
movq %r15, 0x10(%rdi)
movq %rbx, %rsi
callq 0x2ab3a
leaq -0x230(%rbp), %rdi
callq 0xc3a0
movq %rbx, %rdi
callq 0x1f912
movq 0x3c65d(%rip), %rax     # 0x5ef90
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x228(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x230(%rbp,%rcx)
callq 0xc240
leaq -0x138(%rbp), %rdi
callq 0xc0d0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xc130
movq %rax, %r14
leaq 0x276c7(%rip), %rsi     # 0x4a04b
movq %rax, %rdi
callq 0xc520
movq 0x3c63d(%rip), %rsi     # 0x5efd0
movq 0x3c61e(%rip), %rdx     # 0x5efb8
movq %r14, %rdi
callq 0xc4b0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1e0
jmp 0x229b4
jmp 0x229b1
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0xc3e0
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::start(bal::Cnf const&)
void start(const Cnf& cnf) override {
            _assert_level_0(p_cnf_ == nullptr);
            _assert_level_2(offsets_.empty() && clauses_.empty());
            p_cnf_ = &cnf;
            level_next();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x20(%rdi)
jne 0x27d15
movq 0x40(%rdi), %rax
cmpq 0x48(%rdi), %rax
jne 0x27cf6
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x27cf6
movq %rsi, 0x20(%rdi)
movq (%rdi), %rax
popq %rbp
jmpq *0x20(%rax)
leaq 0x20f7f(%rip), %rdi     # 0x48c7c
leaq 0x20f1d(%rip), %rsi     # 0x48c21
leaq 0x20f3b(%rip), %rcx     # 0x48c46
movl $0x50, %edx
callq 0xc180
leaq 0x20ef3(%rip), %rdi     # 0x48c0f
leaq 0x20efe(%rip), %rsi     # 0x48c21
leaq 0x20f1c(%rip), %rcx     # 0x48c46
movl $0x4f, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::update_variables(bal::VariablesArray const&)
void update_variables(const VariablesArray& variables) override {
            if (options_ & TRACE_VARIABLE_MAP_FINAL) {
                for (variables_size_t i = 0; i < variables.size(); i++) {
                    if (i != literal_t__variable_id(variables.data()[i])) {
                        stream << "v: " << i + 1 << " -> " << literal_t(variables.data()[i]) << std::endl;
                    };
                };
            };
        }

// Assembly:
testb $0x4, 0x18(%rdi)
je 0x28017
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x0, 0x8(%rsi)
je 0x28009
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x2c(%rbp), %r13
movq (%rbx), %rax
movl (%rax,%r12,4), %eax
shrl %eax
decl %eax
cmpq %rax, %r12
je 0x27ffa
movq 0x10(%r14), %r15
movl $0x3, %edx
movq %r15, %rdi
leaq 0x1c918(%rip), %rsi     # 0x448aa
callq 0xc320
leaq 0x1(%r12), %rsi
movq %r15, %rdi
callq 0xc190
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
leaq 0x1be9f(%rip), %rsi     # 0x43e55
callq 0xc320
movq (%rbx), %rax
movl (%rax,%r12,4), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x10712
movq %rax, %r15
movq (%rax), %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
incq %r12
movl 0x8(%rbx), %eax
cmpq %rax, %r12
jb 0x27f6f
addq $0x8, %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/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::merge_clause(unsigned int const*, unsigned int)
void merge_clause(const uint32_t* const p_clause, const container_offset_t offset) override {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(is_current_clause(p_clause, CONTAINER_END));
                _assert_level_0(offset != CONTAINER_END);
                write_action('m', 1);
                write_clause(p_cnf_->get_clause_data(offset));
                stream << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testb $0x2, 0x18(%rdi)
je 0x285ec
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x285ec
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %r13
cmpq %r13, %rcx
je 0x285fb
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x285fb
testq %rsi, %rsi
je 0x2861a
cmpq %rsi, -0x8(%rax)
jne 0x2861a
movl %edx, %r14d
cmpl $-0x1, %edx
je 0x28639
movq 0x10(%rbx), %r15
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %r12
cmpb $0x0, 0xe1(%r15,%rax)
jne 0x28535
movq %r12, %rdi
movl $0x20, %esi
movq %rcx, -0x38(%rbp)
callq 0xc2a0
movq -0x38(%rbp), %rcx
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
subq %rcx, %r13
movb $0x2e, 0xe0(%r12)
movq (%r15), %rax
movq -0x18(%rax), %rax
shlq $0x1e, %r13
movabsq $0x200000000, %rcx      # imm = 0x200000000
addq %r13, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%r15,%rax)
leaq -0x29(%rbp), %rsi
movb $0x6d, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0xc320
movq 0x20(%rbx), %rax
cmpl %r14d, 0x88(%rax)
jbe 0x28658
movq 0x80(%rax), %rax
movl %r14d, %ecx
leaq (%rax,%rcx,4), %r14
addq $0xc, %r14
movq 0x10(%rbx), %rdi
leaq -0x2a(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0xc320
movq 0x10(%rbx), %rdi
leaq 0x197b9(%rip), %rdx     # 0x41d72
movq %r14, %rsi
callq 0x1057f
movq 0x10(%rbx), %rbx
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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20781(%rip), %rdi     # 0x48d83
leaq 0x20618(%rip), %rsi     # 0x48c21
leaq 0x2079a(%rip), %rcx     # 0x48daa
movl $0x45, %edx
callq 0xc180
leaq 0x208cf(%rip), %rdi     # 0x48ef0
leaq 0x205f9(%rip), %rsi     # 0x48c21
leaq 0x208ec(%rip), %rcx     # 0x48f1b
movl $0x9a, %edx
callq 0xc180
leaq 0x1b265(%rip), %rdi     # 0x438a5
leaq 0x205da(%rip), %rsi     # 0x48c21
leaq 0x208cd(%rip), %rcx     # 0x48f1b
movl $0x9b, %edx
callq 0xc180
leaq 0x1b2ed(%rip), %rdi     # 0x4394c
leaq 0x1ab5c(%rip), %rsi     # 0x431c2
leaq 0x2090f(%rip), %rcx     # 0x48f7c
movl $0x3c, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::remove_clause(unsigned int)
void remove_clause(const container_offset_t offset) override {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(offset != CONTAINER_END);
                if (is_current_clause(nullptr, offset)) {
                    write_current_clause_action('x',  clauses_.back());
                    set_current_clause(clauses_.back(), CONTAINER_END);
                } else {
                    write_current_clause_action('x', p_cnf_->get_clause_data(offset));
                };
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testb $0x2, 0x18(%rdi)
je 0x28702
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x28702
cmpl $-0x1, %esi
je 0x28758
movq 0x48(%rbx), %rcx
cmpq %rcx, 0x40(%rbx)
je 0x28739
movq 0x28(%rbx), %rdx
cmpq 0x30(%rbx), %rdx
je 0x28739
cmpl %esi, -0x4(%rcx)
jne 0x28709
movq 0x30(%rbx), %rax
movq -0x8(%rax), %rdx
movq %rbx, %rdi
movl $0x78, %esi
callq 0x2894c
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
je 0x28777
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x28777
movq 0x30(%rbx), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, -0x8(%rax)
movq 0x48(%rbx), %rax
movl $0xffffffff, -0x4(%rax) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl %esi, 0x88(%rax)
jbe 0x28796
movq 0x80(%rax), %rax
movl %esi, %ecx
leaq (%rax,%rcx,4), %rdx
addq $0xc, %rdx
movq %rbx, %rdi
movl $0x78, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2894c
leaq 0x20643(%rip), %rdi     # 0x48d83
leaq 0x204da(%rip), %rsi     # 0x48c21
leaq 0x2065c(%rip), %rcx     # 0x48daa
movl $0x45, %edx
callq 0xc180
leaq 0x1b146(%rip), %rdi     # 0x438a5
leaq 0x204bb(%rip), %rsi     # 0x48c21
leaq 0x2085f(%rip), %rcx     # 0x48fcc
movl $0xa4, %edx
callq 0xc180
leaq 0x20605(%rip), %rdi     # 0x48d83
leaq 0x2049c(%rip), %rsi     # 0x48c21
leaq 0x2067c(%rip), %rcx     # 0x48e08
movl $0x3d, %edx
callq 0xc180
leaq 0x1b1af(%rip), %rdi     # 0x4394c
leaq 0x1aa1e(%rip), %rsi     # 0x431c2
leaq 0x207d1(%rip), %rcx     # 0x48f7c
movl $0x3c, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::write_current_clause_action(char, unsigned int const*)
inline void write_current_clause_action(const char action, const uint32_t* const p_clause) {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(p_clause != nullptr);
                write_action(action, 1);
                if (!is_current_clause(p_clause, CONTAINER_END)) {
                    write_clause(p_clause);
                };
                stream << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testb $0x2, 0x18(%rdi)
je 0x28a7e
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x28a7e
movq %rdx, -0x38(%rbp)
testq %rdx, %rdx
je 0x28aac
movl %esi, %r8d
movq 0x48(%rbx), %r15
movq 0x10(%rbx), %r12
movq 0x40(%rbx), %r14
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %r13
cmpb $0x0, 0xe1(%r12,%rax)
jne 0x289cc
movq %r13, %rdi
movl $0x20, %esi
movl %r8d, -0x30(%rbp)
callq 0xc2a0
movl -0x30(%rbp), %r8d
movb %al, 0xe0(%r13)
movb $0x1, 0xe1(%r13)
subq %r14, %r15
movb $0x2e, 0xe0(%r13)
movq (%r12), %rax
movq -0x18(%rax), %rax
shlq $0x1e, %r15
movabsq $0x200000000, %rcx      # imm = 0x200000000
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%r12,%rax)
leaq -0x29(%rbp), %rsi
movb %r8b, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0xc320
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
je 0x28a8d
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x28a8d
movq -0x38(%rbp), %r14
cmpq %r14, -0x8(%rax)
je 0x28a53
movq 0x10(%rbx), %rdi
leaq -0x2a(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0xc320
movq 0x10(%rbx), %rdi
leaq 0x19327(%rip), %rdx     # 0x41d72
movq %r14, %rsi
callq 0x1057f
movq 0x10(%rbx), %rbx
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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x202ef(%rip), %rdi     # 0x48d83
leaq 0x20186(%rip), %rsi     # 0x48c21
leaq 0x20308(%rip), %rcx     # 0x48daa
movl $0x45, %edx
callq 0xc180
leaq 0x2021a(%rip), %rdi     # 0x48ccd
leaq 0x20167(%rip), %rsi     # 0x48c21
leaq 0x203d5(%rip), %rcx     # 0x48e96
movl $0x32, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/cnf/cnf.hpp
// Function: bal::Cnf::get_variable_value(unsigned int) const
literalid_t get_variable_value(const variableid_t variableid) const override {
            uint32_t unit_clause[_clause_size_memory_size(1)] = _clause_c1_make(variable_t__literal_id(variableid));
            insertion_point_t insertion_point;
            __insertion_point_t_init(insertion_point);
            find(unit_clause, insertion_point);
            if (insertion_point.container_offset != CONTAINER_END) {
                return (_clauses_offset_flags(this->data_, insertion_point.container_offset) == 1) ? LITERAL_CONST_0 : LITERAL_CONST_1;
            } else {
                return LITERALID_UNASSIGNED;
            };
        }

// Assembly:
leal 0x3(,%rsi,2), %eax
movl %eax, %esi
shrl %esi
decl %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl 0xb0(%rdi), %esi
jae 0x28b79
movq 0xa8(%rdi), %rdx
movl %esi, %esi
movl (%rdx,%rsi,4), %edx
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $-0x1, %edx
je 0x28c36
movq 0x80(%rdi), %rsi
leaq 0x36759(%rip), %r8      # 0x5f2f4
movl (%r8), %r9d
incl %r9d
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movw $0x7fff, %r11w          # imm = 0x7FFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %edx, %ebx
movl %r9d, (%r8)
movzwl 0xc(%rsi,%rbx,4), %r14d
andw %r11w, %r14w
je 0x28bdc
leaq (%rsi,%rbx,4), %r15
addq $0xc, %r15
movzwl %r14w, %r14d
cmpl (%r15,%r14,4), %eax
jne 0x28bf2
decl %r14d
xorl %r12d, %r12d
jmp 0x28be1
movw $0x1, %r12w
xorl %r15d, %r15d
cmpw %r14w, %r12w
setne %r15b
cmovbl %r10d, %r15d
jmp 0x28bff
movl $0x0, %r15d
sbbl %r15d, %r15d
orl $0x1, %r15d
movl $0x4, %r14d
testl %r15d, %r15d
jle 0x28c1f
leaq (%rsi,%rbx,4), %rbx
movl (%rbx,%r14), %r14d
cmpl $-0x1, %r14d
setne %bl
cmovnel %r14d, %edx
jmp 0x28c25
js 0x28c2e
xorl %ebx, %ebx
movl %edx, %ecx
incl %r9d
testb %bl, %bl
jne 0x28bb1
jmp 0x28c36
movl $0x8, %r14d
jmp 0x28c0a
cmpl $-0x1, %ecx
jne 0x28c44
leaq 0x366ae(%rip), %rax     # 0x5f2f0
jmp 0x28c4b
leaq 0x366a1(%rip), %rax     # 0x5f2ec
incl (%rax)
cmpl $-0x1, %ecx
je 0x28c70
movq 0x80(%rdi), %rax
movl %ecx, %ecx
movzwl 0xe(%rax,%rcx,4), %ecx
shll $0x10, %ecx
xorl %eax, %eax
cmpl $0x10000, %ecx          # imm = 0x10000
setne %al
jmp 0x28c75
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/bal/binarytreeindex.hpp
// Function: bal::AvlTreesIndex<unsigned int, true, &int bal::compare_clauses<false>(unsigned int const*, unsigned int const*), &unsigned int bal::clause_index_variable_id<false>(unsigned int const*)>::insertion_point_is_valid(bal::avl_tree_insertion_point_t const&) const
bool insertion_point_is_valid(const insertion_point_t& insertion_point) const override {
            bool result = base_t::insertion_point_is_valid(insertion_point);
            if (!result && insertion_point.version_stamp != CONTAINER_END && insertion_point.kind == btipkCurrent) {
                _assert_level_0(insertion_point.offset < this->size_);
                const CONTAINER_DATA_T* const p_item = _bti_item(this->data_, insertion_point.offset);
                if (_bti_item_parent_offset(p_item) != CONTAINER_END) {
                    const CONTAINER_DATA_T* const p_parent = _bti_item(this->data_, _bti_item_parent_offset(p_item));
                    result = (_bti_item_left_offset(p_parent) == insertion_point.offset) ||
                                (_bti_item_right_offset(p_parent) == insertion_point.offset);
                } else if _bti_item_parent_offset(p_item) {
                    const container_offset_t instance_offset = instance_determiner(_bti_item_container_item(p_item));
                    _assert_level_0(instance_offset < this->instances_.size_);
                    result = this->instances_.data_[instance_offset] == insertion_point.offset;
                };
            };
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x5c(%rdi), %ecx
movl 0x4(%rsi), %edx
cmpl %ecx, %edx
sete %al
cmpl $-0x1, %edx
je 0x28f05
cmpl %ecx, %edx
je 0x28f05
cmpl $0x3, 0x8(%rsi)
jne 0x28f05
movl 0xc(%rsi), %ecx
cmpl 0x10(%rdi), %ecx
jae 0x28f07
movq 0x8(%rdi), %rdx
movl (%rdx,%rcx,4), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rsi
je 0x28edb
movb $0x1, %al
cmpl %ecx, 0x8(%rdx,%rsi,4)
je 0x28f05
leaq (%rdx,%rsi,4), %rax
addq $0x4, %rax
jmp 0x28f00
leaq (%rdx,%rcx,4), %rax
movl $0x7fff, %edx           # imm = 0x7FFF
andl 0xc(%rax), %edx
decl %edx
movl 0x10(%rax,%rdx,4), %eax
shrl %eax
decl %eax
cmpl 0x38(%rdi), %eax
jae 0x28f26
movl %eax, %eax
shlq $0x2, %rax
addq 0x30(%rdi), %rax
cmpl %ecx, (%rax)
sete %al
popq %rbp
retq
leaq 0x1aa2e(%rip), %rdi     # 0x4393c
leaq 0x1a828(%rip), %rsi     # 0x4373d
leaq 0x20403(%rip), %rcx     # 0x4931f
movl $0x1d4, %edx            # imm = 0x1D4
callq 0xc180
leaq 0x1ae04(%rip), %rdi     # 0x43d31
leaq 0x1a809(%rip), %rsi     # 0x4373d
leaq 0x203e4(%rip), %rcx     # 0x4931f
movl $0x1dc, %edx            # imm = 0x1DC
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<unsigned int, unsigned int, bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>, bal::avl_tree_insertion_point_t>::rollback(unsigned int, unsigned int, unsigned int)
virtual void rollback(const container_size_t size,
                              const container_size_t instances_size,
                              const container_size_t container_size) {
            assert(size != CONTAINER_END && this->size_ >= size);
            assert(instances_.size_ >= instances_size);
            this->size_ = size;
            instances_.size_ = instances_size;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, %esi
je 0x290df
cmpl %esi, 0x10(%rdi)
jb 0x290df
cmpl %edx, 0x38(%rdi)
jb 0x290fe
movl %esi, 0x10(%rdi)
movl %edx, 0x38(%rdi)
popq %rbp
retq
leaq 0x1ff48(%rip), %rdi     # 0x4902e
leaq 0x1a907(%rip), %rsi     # 0x439f4
leaq 0x1ff67(%rip), %rcx     # 0x4905b
movl $0x3f, %edx
callq 0xc180
leaq 0x20154(%rip), %rdi     # 0x49259
leaq 0x1a8e8(%rip), %rsi     # 0x439f4
leaq 0x1ff48(%rip), %rcx     # 0x4905b
movl $0x40, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>::is_constant() const
bool is_constant() const override {
            for (auto i = 0; i < N_; i++) {
                if (bits_[i] == nullptr || !bits_[i]->is_constant()) {
                    return false;
                };
            };
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x30(%rdi), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2951b
xorl %r15d, %r15d
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x2951b
cmpq $0x1f, %r15
setae %bl
je 0x2951b
movq 0x38(%r14,%r15,8), %rdi
incq %r15
testq %rdi, %rdi
jne 0x294fb
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: void bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>::assign_from<int, 0>(int)
void assign_from(const T value) {
            _assert_level_0(value >= 0);
            constexpr T T_MAX_SIZE = size_in_bits_(std::numeric_limits<T>::max());
            if (T_MAX_SIZE <= N_) {
                // assigning from a shorter type or a same sized type
                // first, assign all lower bits available from value
                // second, assume the remaining leading bits are all 0
                auto i = 0;
                T max_i = std::numeric_limits<T>::max();
                while (max_i > 0) {
                    bits_[i] = unsigned((value >> i) & 0b1);
                    max_i >>= 1;
                    i++;
                };
                while (i < N_) {
                    bits_[i] = 0b0;
                    i++;
                };
            } else {
                // assigning form a longer type
                // first, assign all lower bits
                // second, check that the remaining leading bits are all 0
                auto value_ = value;
                auto i = 0;
                while (i < N_) {
                    bits_[i] = unsigned(value_ & 0b1);
                    value_ >>= 1;
                };
                _assert_level_0(value_ == 0);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x29f4d
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r12
xorl %eax, %eax
btl %r13d, %r14d
setb %al
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x29f6c
incq %r13
addq $0x8, %r15
cmpq $0x1f, %r13
jne 0x29f01
leaq -0x30(%rbp), %rsi
movl $0x0, (%rsi)
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rdi
callq 0x29fce
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fb50(%rip), %rdi     # 0x49aa4
leaq 0x1fb54(%rip), %rsi     # 0x49aaf
leaq 0x1fb65(%rip), %rcx     # 0x49ac7
movl $0x35, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: int bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>::assign_to<int, 0>() const
T assign_to() const {
            T value = 0;
            constexpr T T_MAX_SIZE = size_in_bits_(std::numeric_limits<T>::max());
            if (T_MAX_SIZE < N_) {
                // assigning to a shorter type
                auto i = 0;
                T max_i = std::numeric_limits<T>::max();
                while (max_i > 0) {
                    if ((bool)bits_[i]) {
                        value |= 0b1 << i;
                    };
                    max_i >>= 1;
                    i++;
                };
                while (i < N_) {
                    _assert_level_0((bool)bits_[i] == false);
                    i++;
                };
            } else {
                // assigning to a longer type or a same sized type
                for (auto i = 0; i < N_; i++) {
                    if ((bool)bits_[i]) {
                        value |= 0b1 << i;
                    };
                };
            };
            return value;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x30(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1, %edx
movl %r15d, %ecx
shll %cl, %edx
testb %al, %al
cmovel %r12d, %edx
orl %edx, %ebx
incq %r15
cmpq $0x1f, %r15
jne 0x2a09c
movq 0x128(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
jne 0x2a0de
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fb9b(%rip), %rdi     # 0x49c80
leaq 0x1f9c3(%rip), %rsi     # 0x49aaf
leaq 0x1fba5(%rip), %rcx     # 0x49c98
movl $0x66, %edx
callq 0xc180
nop