LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rdi
movq 0x8(%rdi), %rax
addq 0x10(%rdi), %rax
movq %rax, -0x60(%rbp)
addq $0x18, %rdi
callq 0xd1f0
movq -0x60(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x51(%rbp)
jae 0x27f87
movq -0x50(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x27f90
jmp 0x27fa2
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x27f36
movq -0x50(%rbp), %rdi
movq 0x8(%rdi), %rax
addq 0x10(%rdi), %rax
movq %rax, -0x68(%rbp)
addq $0x18, %rdi
callq 0xd1f0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x27ffc
movq -0x50(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x27ffc
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x28070
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xd5b0
movq -0x70(%rbp), %rdx
leaq 0x39ef2(%rip), %rsi     # 0x61f06
leaq -0x30(%rbp), %rdi
callq 0xd440
jmp 0x2801f
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x262a0
jmp 0x2802e
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0x31(%rbp), %rdi
callq 0xd370
jmp 0x28070
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x28065
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0x31(%rbp), %rdi
callq 0xd370
jmp 0x28076
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xd5a0
nop
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::load_next_line()
inline void load_next_line() {
        if (!is_eof_()) {
            getline(current_line_);
            current_line_index_ += 1;
        } else {
            current_line_ = "";
        };
        current_token_pos_ = 0;
        current_token_len_ = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x284c0
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x18, %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
jmp 0x284d4
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
leaq 0x3feed(%rip), %rsi     # 0x683bc
callq 0xd430
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: vsklad[P]cgen/./bal/bal/container.hpp
// Function: bal::Container<unsigned int>::operator=(bal::Container<unsigned int>&&)
inline Container& operator = (Container&& other) noexcept {
            resize_(0);
            data_ = other.data_;
            allocated_size_ = other.allocated_size_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.allocated_size_ = 0;
            other.size_ = 0;
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
callq 0x113d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq $0x0, (%rcx)
movq -0x10(%rbp), %rcx
movl $0x0, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movl $0x0, 0x8(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_symbol()
inline char read_symbol() {
        load_next_token();
        if (current_token_len_ > 0) {
            const char value = current_line_[current_token_pos_];
            skip_symbol();
            return value;
        } else {
            parse_error("Cannot read symbol");
            return 0;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x272c0
movq -0x58(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x2868e
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
callq 0xd630
movq -0x58(%rbp), %rdi
movb (%rax), %al
movb %al, -0x11(%rbp)
callq 0x283f0
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x28706
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xd5b0
movq -0x60(%rbp), %rdx
leaq 0x399af(%rip), %rsi     # 0x62055
leaq -0x38(%rbp), %rdi
callq 0xd440
jmp 0x286b1
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x262a0
jmp 0x286c0
leaq -0x38(%rbp), %rdi
callq 0xd1b0
leaq -0x39(%rbp), %rdi
callq 0xd370
movb $0x0, -0x1(%rbp)
jmp 0x28706
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x286fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd1b0
leaq -0x39(%rbp), %rdi
callq 0xd370
jmp 0x2870f
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xd5a0
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x38ea1(%rip), %rsi     # 0x622bc
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0xd600
movq %rax, %rdi
leaq 0x3dc9b(%rip), %rsi     # 0x670d6
callq 0xd320
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x29507
movq -0x8(%rbp), %rdi
leaq 0x3b5ad(%rip), %rsi     # 0x64a05
callq 0xd320
movq %rax, %rdi
movq 0x59b19(%rip), %rsi     # 0x82f80
callq 0xd360
movq -0x8(%rbp), %rdi
leaq 0x38e4f(%rip), %rsi     # 0x622c6
callq 0xd320
movq %rax, %rdi
movq 0x59afa(%rip), %rsi     # 0x82f80
callq 0xd360
movq -0x8(%rbp), %rdi
leaq 0x38e3e(%rip), %rsi     # 0x622d4
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xd420
movq %rax, %rdi
leaq 0x3b3e9(%rip), %rsi     # 0x6489c
callq 0xd320
movq %rax, %rdi
movq 0x59abe(%rip), %rsi     # 0x82f80
callq 0xd360
movq -0x8(%rbp), %rdi
leaq 0x38e20(%rip), %rsi     # 0x622f2
callq 0xd320
movq %rax, %rdi
movq 0x59a9f(%rip), %rsi     # 0x82f80
callq 0xd360
movq -0x8(%rbp), %rdi
leaq 0x38e10(%rip), %rsi     # 0x62301
callq 0xd320
movq %rax, %rdi
movq 0x59a80(%rip), %rsi     # 0x82f80
callq 0xd360
jmp 0x29526
movq -0x8(%rbp), %rdi
leaq 0x3b38b(%rip), %rsi     # 0x6489d
callq 0xd320
movq %rax, %rdi
movq 0x59a5f(%rip), %rsi     # 0x82f80
callq 0xd360
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x29578
movq -0x8(%rbp), %rdi
leaq 0x38db4(%rip), %rsi     # 0x62309
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xd420
movq %rax, %rdi
leaq 0x3db63(%rip), %rsi     # 0x670d6
callq 0xd320
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x295b0
movq -0x8(%rbp), %rdi
leaq 0x38d85(%rip), %rsi     # 0x62312
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xd420
movq %rax, %rdi
leaq 0x3db2b(%rip), %rsi     # 0x670d6
callq 0xd320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2d650
cmpq $0x0, %rax
jne 0x298df
movq 0x596de(%rip), %rdi     # 0x82fa0
leaq 0x38a89(%rip), %rsi     # 0x62352
callq 0xd320
movq %rax, %rdi
movq 0x596a8(%rip), %rsi     # 0x82f80
callq 0xd360
jmp 0x2995e
movq 0x596ba(%rip), %rdi     # 0x82fa0
leaq 0x38ac5(%rip), %rsi     # 0x623b2
callq 0xd320
movq %rax, %rdi
leaq -0x1963c(%rip), %rsi    # 0x102c0
callq 0xd0f0
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, %esi
movq 0x5968c(%rip), %rdi     # 0x82fa0
callq 0xd420
movq %rax, %rdi
leaq 0x38a95(%rip), %rsi     # 0x623b8
callq 0xd320
movq -0x8(%rbp), %rdi
callq 0x2d650
movq %rax, %rsi
movq 0x59665(%rip), %rdi     # 0x82fa0
callq 0xd0a0
movq %rax, %rdi
leaq 0x38a7b(%rip), %rsi     # 0x623c5
callq 0xd320
movq %rax, %rdi
movq 0x59627(%rip), %rsi     # 0x82f80
callq 0xd360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29970
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
ja 0x29f2c
movq -0x30(%rbp), %rax
leaq 0x38391(%rip), %rcx     # 0x62278
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d680
jmp 0x29f7c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d7f0
jmp 0x29f7c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d960
jmp 0x29f7c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dad0
jmp 0x29f7c
movl $0x10, %edi
callq 0xd150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x384c7(%rip), %rsi     # 0x6240e
callq 0xd5f0
jmp 0x29f4e
movq -0x38(%rbp), %rdi
movq 0x5907f(%rip), %rsi     # 0x82fd8
movq 0x59060(%rip), %rdx     # 0x82fc0
callq 0xd570
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xd210
jmp 0x29f82
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd5a0
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29970
movl -0x14(%rbp), %eax
testl %eax, %eax
jne 0x29fc4
jmp 0x29fb5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dc40
jmp 0x2a014
movl $0x10, %edi
callq 0xd150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x3842f(%rip), %rsi     # 0x6240e
callq 0xd5f0
jmp 0x29fe6
movq -0x30(%rbp), %rdi
movq 0x58fe7(%rip), %rsi     # 0x82fd8
movq 0x58fc8(%rip), %rdx     # 0x82fc0
callq 0xd570
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xd210
jmp 0x2a01a
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x13e0, %rsp           # imm = 0x13E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2a2fe
jmp 0x2a31d
leaq 0x38175(%rip), %rdi     # 0x6247a
leaq 0x38185(%rip), %rsi     # 0x62491
movl $0xa0, %edx
leaq 0x38186(%rip), %rcx     # 0x6249e
callq 0xd1c0
leaq -0x1398(%rbp), %rdi
callq 0x2dec0
leaq -0x13a0(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2df60
jmp 0x2a33e
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x2df90
jmp 0x2a351
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x10310
movq %rax, -0x13c8(%rbp)
jmp 0x2a367
movq -0x13c8(%rbp), %rax
movq %rax, -0x13b8(%rbp)
movl $0x0, -0x13bc(%rbp)
movl -0x13bc(%rbp), %eax
movl %eax, -0x13d0(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x102f0
movl %eax, -0x13cc(%rbp)
jmp 0x2a3a0
movl -0x13d0(%rbp), %eax
movl -0x13cc(%rbp), %ecx
cmpl %ecx, %eax
jae 0x2a43f
movq -0x13b8(%rbp), %rax
movslq -0x13bc(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jbe 0x2a429
leaq -0x13a0(%rbp), %rdi
leaq -0x1398(%rbp), %rsi
callq 0x2dfd0
movl %eax, -0x13d4(%rbp)
jmp 0x2a3e3
movl -0x13d4(%rbp), %ecx
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
movq -0x13b8(%rbp), %rax
movslq -0x13bc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2a429
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13a8(%rbp)
movl %eax, -0x13ac(%rbp)
leaq -0x1398(%rbp), %rdi
callq 0x2e000
jmp 0x2a45e
jmp 0x2a42b
movl -0x13bc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x13bc(%rbp)
jmp 0x2a37f
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
leaq -0x1398(%rbp), %rdi
callq 0x2e000
addq $0x13e0, %rsp           # imm = 0x13E0
popq %rbp
retq
movq -0x13a8(%rbp), %rdi
callq 0xd5a0
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e180
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10310
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x102f0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jae 0x2afd4
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
xorl %eax, %eax
cmpl $0x1, (%rcx,%rdx,4)
movb %al, -0x35(%rbp)
jbe 0x2af46
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $-0x2, (%rax,%rcx,4)
setbe %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x2af4f
jmp 0x2afc4
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
ja 0x2afc4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
shrl %esi
subl $0x1, %esi
movq (%rdi), %rax
callq *0x60(%rax)
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movq -0x20(%rbp), %rdx
movslq -0x2c(%rbp), %rsi
movl (%rdx,%rsi,4), %edi
xorl $-0x1, %edi
andl $0x1, %edi
xorl %edx, %edx
movl $0x1, %esi
cmpl $0x0, %edi
cmovnel %esi, %edx
xorl %edx, %ecx
cmpl %ecx, %eax
jne 0x2afc2
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2afc4
jmp 0x2afc6
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2af05
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e300
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e360
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2e330
testb $0x1, %al
jne 0x2bed9
jmp 0x2bf01
leaq -0x18(%rbp), %rdi
callq 0x2e390
cmpl $0x2, 0x20(%rax)
jne 0x2beee
movb $0x1, -0x1(%rbp)
jmp 0x2bf05
jmp 0x2bef0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2e3c0
movq %rax, -0x28(%rbp)
jmp 0x2beb9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: vsklad[P]cgen/commands.cpp
// Function: void save_impl<bal::Cnf, bal::DimacsStreamWriter>(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
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x55906(%rip), %rdi     # 0x82fa0
leaq 0x36da2(%rip), %rsi     # 0x64443
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xd320
movq %rax, %rdi
movq 0x558c4(%rip), %rsi     # 0x82f80
callq 0xd360
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movq %rdi, -0x240(%rbp)
movl $0x10, %edx
callq 0xd380
movq -0x240(%rbp), %rdi
callq 0xd240
movb %al, -0x231(%rbp)
jmp 0x2d6f1
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x2d6fd
jmp 0x2d74b
leaq -0x230(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x3a100
jmp 0x2d712
movq -0x8(%rbp), %rsi
leaq -0x230(%rbp), %rdi
callq 0x3a140
jmp 0x2d724
leaq -0x210(%rbp), %rdi
callq 0xd470
jmp 0x2d732
jmp 0x2d7ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x2d7cc
movl $0x10, %edi
callq 0xd150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x248(%rbp)
leaq 0x36ce8(%rip), %rsi     # 0x64451
callq 0xd5f0
jmp 0x2d770
movq -0x248(%rbp), %rdi
movq 0x5585a(%rip), %rsi     # 0x82fd8
movq 0x5583b(%rip), %rdx     # 0x82fc0
callq 0xd570
jmp 0x2d7e4
movq -0x248(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
callq 0xd210
jmp 0x2d7cc
movq -0x8(%rbp), %rdi
callq 0x29660
jmp 0x2d7b7
leaq -0x210(%rbp), %rdi
callq 0xd4a0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0xd4a0
movq -0x218(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
nop
// File: vsklad[P]cgen/./bal/anf/anf.hpp
// Function: bal::normalize_variables(bal::Anf&, bool)
inline bool normalize_variables(Anf& anf, const bool b_reindex_variables) {
            assert(b_reindex_variables);
            for (auto vit = anf.get_named_variables_().begin(); vit != anf.get_named_variables_().end(); vit++) {
                anf.encode_negations_(vit->second);
            };
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x33edc
jmp 0x33efb
leaq 0x2f933(%rip), %rdi     # 0x63816
leaq 0x2f940(%rip), %rsi     # 0x6382a
movl $0x81, %edx
leaq 0x2f946(%rip), %rcx     # 0x6383c
callq 0xd1c0
movq -0x8(%rbp), %rdi
callq 0x377a0
movq %rax, %rdi
callq 0x17250
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x377a0
movq %rax, %rdi
callq 0x172b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17280
testb $0x1, %al
jne 0x33f38
jmp 0x33f6a
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x172e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xf7e0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x17310
movq %rax, -0x28(%rbp)
jmp 0x33f10
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0x35361
jmp 0x35380
leaq 0x2d8a3(%rip), %rdi     # 0x62c0b
leaq 0x2d8ae(%rip), %rsi     # 0x62c1d
movl $0x4f, %edx
leaq 0x2d8c7(%rip), %rcx     # 0x62c42
callq 0xd1c0
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x360b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x3539b
jmp 0x353ab
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x360f0
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x353b4
jmp 0x353b6
jmp 0x353d5
leaq 0x2d8bb(%rip), %rdi     # 0x62c78
leaq 0x2d859(%rip), %rsi     # 0x62c1d
movl $0x50, %edx
leaq 0x2d872(%rip), %rcx     # 0x62c42
callq 0xd1c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x20(%rdi)
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x356ba
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102f0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jae 0x356b8
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e180
movq %rax, %rcx
movl -0x28(%rbp), %eax
movl -0x14(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shrl %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x356a8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x29378(%rip), %rsi     # 0x5e9c6
callq 0xd320
movq %rax, %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0xd420
movq %rax, %rdi
leaq 0x28906(%rip), %rsi     # 0x5df71
callq 0xd320
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e180
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %esi
leaq -0x18(%rbp), %rdi
callq 0x12e30
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12d50
movq %rax, %rdi
movq 0x4d8dd(%rip), %rsi     # 0x82f80
callq 0xd360
jmp 0x356aa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x355ff
jmp 0x356ba
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x35add
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x35add
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x36b20
testb $0x1, %al
jne 0x35a52
jmp 0x35a54
jmp 0x35a73
leaq 0x2d491(%rip), %rdi     # 0x62eec
leaq 0x2d1bb(%rip), %rsi     # 0x62c1d
movl $0x9a, %edx
leaq 0x2d4a9(%rip), %rcx     # 0x62f17
callq 0xd1c0
cmpl $-0x1, -0x14(%rbp)
je 0x35a7b
jmp 0x35a9a
leaq 0x27e34(%rip), %rdi     # 0x5d8b6
leaq 0x2d194(%rip), %rsi     # 0x62c1d
movl $0x9b, %edx
leaq 0x2d482(%rip), %rcx     # 0x62f17
callq 0xd1c0
movq -0x20(%rbp), %rdi
movl $0x6d, %esi
movl $0x1, %edx
callq 0x36a90
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x36f50
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x36d70
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x4d4a8(%rip), %rsi     # 0x82f80
callq 0xd360
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x35bc4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x35bc4
cmpl $-0x1, -0xc(%rbp)
je 0x35b2e
jmp 0x35b4d
leaq 0x27d81(%rip), %rdi     # 0x5d8b6
leaq 0x2d0e1(%rip), %rsi     # 0x62c1d
movl $0xa4, %edx
leaq 0x2d480(%rip), %rcx     # 0x62fc8
callq 0xd1c0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x36b20
testb $0x1, %al
jne 0x35b63
jmp 0x35ba1
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x36e00
movq -0x18(%rbp), %rdi
movq (%rax), %rdx
movl $0x78, %esi
callq 0x36ea0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x36e00
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x36c60
jmp 0x35bc2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x36f50
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movl $0x78, %esi
callq 0x36ea0
jmp 0x35bc4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::is_current_clause(unsigned int const*, unsigned int)
inline bool is_current_clause(const uint32_t* const p_clause, const container_offset_t offset) {
            _assert_level_0(!offsets_.empty() && !clauses_.empty());
            if (p_clause == nullptr || clauses_.back() == nullptr || p_clause != clauses_.back()) {
                return (offset != CONTAINER_END && offset == offsets_.back());
            } else {
                return (offset == CONTAINER_END || offsets_.back() == CONTAINER_END || offset == offsets_.back());
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x40, %rdi
callq 0x360b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1d(%rbp)
jne 0x36b62
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x360f0
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x36b6b
jmp 0x36b6d
jmp 0x36b8c
leaq 0x2c20b(%rip), %rdi     # 0x62d7f
leaq 0x2c0a2(%rip), %rsi     # 0x62c1d
movl $0x45, %edx
leaq 0x2c21f(%rip), %rcx     # 0x62da6
callq 0xd1c0
cmpq $0x0, -0x18(%rbp)
je 0x36bc7
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x36e00
cmpq $0x0, (%rax)
je 0x36bc7
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x36e00
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq (%rcx), %rax
je 0x36bfd
xorl %eax, %eax
cmpl $-0x1, -0x1c(%rbp)
movb %al, -0x31(%rbp)
je 0x36bf3
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
addq $0x40, %rdi
callq 0x36dc0
movq %rax, %rcx
movl -0x38(%rbp), %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x36c4b
movb $0x1, %al
cmpl $-0x1, -0x1c(%rbp)
movb %al, -0x39(%rbp)
je 0x36c43
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0x36dc0
movq %rax, %rcx
movb $0x1, %al
cmpl $-0x1, (%rcx)
movb %al, -0x39(%rbp)
je 0x36c43
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
addq $0x40, %rdi
callq 0x36dc0
movq %rax, %rcx
movl -0x40(%rbp), %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::set_current_clause(unsigned int const*, unsigned int)
inline void set_current_clause(const uint32_t* const p_clause, const container_offset_t offset) {
            _assert_level_0(!offsets_.empty() && !clauses_.empty());
            _assert_level_0(p_clause != nullptr || offset == CONTAINER_END);
            clauses_.back() = p_clause;
            offsets_.back() = offset;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x40, %rdi
callq 0x360b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x36ca2
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x360f0
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x36cab
jmp 0x36cad
jmp 0x36ccc
leaq 0x2c0cb(%rip), %rdi     # 0x62d7f
leaq 0x2bf62(%rip), %rsi     # 0x62c1d
movl $0x3d, %edx
leaq 0x2c13d(%rip), %rcx     # 0x62e04
callq 0xd1c0
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
jne 0x36ce2
cmpl $-0x1, -0x14(%rbp)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x36ceb
jmp 0x36ced
jmp 0x36d0c
leaq 0x2c16f(%rip), %rdi     # 0x62e63
leaq 0x2bf22(%rip), %rsi     # 0x62c1d
movl $0x3e, %edx
leaq 0x2c0fd(%rip), %rcx     # 0x62e04
callq 0xd1c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x36e00
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x40, %rdi
callq 0x36dc0
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x36f46
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x36f46
cmpq $0x0, -0x18(%rbp)
je 0x36ede
jmp 0x36efd
leaq 0x2bde4(%rip), %rdi     # 0x62cc9
leaq 0x2bd31(%rip), %rsi     # 0x62c1d
movl $0x32, %edx
leaq 0x2bf9a(%rip), %rcx     # 0x62e92
callq 0xd1c0
movq -0x20(%rbp), %rdi
movl $0x1, %edx
movsbl -0x9(%rbp), %esi
callq 0x36a90
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x36b20
testb $0x1, %al
jne 0x36f32
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36d70
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x4c03f(%rip), %rsi     # 0x82f80
callq 0xd360
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x14(%rbp), %edx
addl $0x1, %edx
shll %edx
orl $0x1, %edx
andl $0x1, %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
shll $0x10, %eax
orl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
shll %eax
orl $0x1, %eax
orl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
addq $0x78, %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x15190
cmpl $-0x1, -0x2c(%rbp)
je 0x37147
movq -0x38(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x2c(%rbp), %ecx
movl 0xc(%rax,%rcx,4), %eax
shrl $0x10, %eax
movzwl %ax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3714e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vsklad[P]cgen/./bal/cnf/cnf/cnfclausescontainer.hpp
// Function: bal::CnfClausesIndexedContainer<false>::rollback(unsigned int, unsigned int, unsigned int)
void rollback(const container_size_t size,
                      const container_size_t instances_size,
                      const container_size_t container_size) override {
            base_t::rollback(0, 0, container_size);
            this->instances_.append(CONTAINER_END, instances_size);
            container_offset_t container_offset = 0;
            while (container_offset < container_size) {
                uint32_t* const p_clause = _clauses_offset_clause(this->p_container_->data_, container_offset);
                _clause_include(p_clause);
                insertion_point_t insertion_point;
                this->find(p_clause, insertion_point);
                _assert_level_1(insertion_point.container_offset == CONTAINER_END);
                base_t::_update(container_offset, insertion_point);
                _clauses_offset_next(container_offset, p_clause);
                this->size_ = container_offset; // "commits" the clause
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x14(%rbp), %ecx
xorl %edx, %edx
movl %edx, %esi
callq 0x37510
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movl -0x10(%rbp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15a70
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x37247
movq -0x38(%rbp), %rdi
movq 0x28(%rdi), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xffff7fff, %ecx       # imm = 0xFFFF7FFF
movl %ecx, (%rax)
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x15190
cmpl $-0x1, -0x30(%rbp)
jne 0x371f1
jmp 0x37210
leaq 0x26723(%rip), %rdi     # 0x5d91b
leaq 0x2609e(%rip), %rsi     # 0x5d29d
movl $0x69, %edx
leaq 0x2c246(%rip), %rcx     # 0x63451
callq 0xd1c0
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x15230
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
addl $0x1, %ecx
addl $0x3, %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x371a5
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<unsigned int, unsigned int, bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>, bal::avl_tree_insertion_point_t>::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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
je 0x37548
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
setae %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x37551
jmp 0x37553
jmp 0x37572
leaq 0x2bca9(%rip), %rdi     # 0x63203
leaq 0x264a4(%rip), %rsi     # 0x5da05
movl $0x3f, %edx
leaq 0x2bcc3(%rip), %rcx     # 0x63230
callq 0xd1c0
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
cmpl -0x10(%rbp), %eax
jb 0x37580
jmp 0x3759f
leaq 0x2bea7(%rip), %rdi     # 0x6342e
leaq 0x26477(%rip), %rsi     # 0x5da05
movl $0x40, %edx
leaq 0x2bc96(%rip), %rcx     # 0x63230
callq 0xd1c0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x20, %rax
jae 0x3871b
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x38dc0
cmpq $0x0, %rax
je 0x38708
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x39290
movq %rax, %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x3870e
movb $0x0, -0x1(%rbp)
jmp 0x3871f
jmp 0x38710
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x386bb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x38b7f
jmp 0x38b9e
leaq 0x2b0f3(%rip), %rdi     # 0x63c79
leaq 0x2b0f7(%rip), %rsi     # 0x63c84
movl $0x35, %edx
leaq 0x2b103(%rip), %rcx     # 0x63c9c
callq 0xd1c0
movl $0x1f, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x38c40
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x38bf7
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movl %eax, -0x1c(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x38c50
movl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38bb4
jmp 0x38bf9
movslq -0x14(%rbp), %rax
cmpq $0x20, %rax
jae 0x38c31
movq -0x28(%rbp), %rdi
movl $0x0, -0x20(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x38c90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38bf9
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Literal<bal::Cnf>* bal::Literal<bal::Cnf>::static_assign<unsigned int, 0>(bal::Literal<bal::Cnf>*, unsigned int const&)
static Literal* static_assign(Literal* instance, const value_t& value) {
            if (value == LITERALID_UNASSIGNED) {
                return unassigned_;
            } else {
                return GF2Element<Literal<FORMULA_T>>::static_assign(instance, value);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x38d2b
leaq 0x4a6a0(%rip), %rdi     # 0x833c0
callq 0x38dc0
movq %rax, -0x8(%rbp)
jmp 0x38d3c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38de0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1f, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x38c40
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x38fc8
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x39030
testb $0x1, %al
jne 0x38fa5
jmp 0x38fb5
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38f81
jmp 0x38fca
movslq -0x14(%rbp), %rax
cmpq $0x20, %rax
jae 0x39022
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x39030
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x38ff8
jmp 0x39017
leaq 0x2ae56(%rip), %rdi     # 0x63e55
leaq 0x2ac7e(%rip), %rsi     # 0x63c84
movl $0x66, %edx
leaq 0x2ae5b(%rip), %rcx     # 0x63e6d
callq 0xd1c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38fca
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)