LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::shr<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, int)
Ref<GF2NElement<N, GF2E>> shr(GF2NElement<N, GF2E>* const r,
                                  const GF2NElement<N, GF2E>* const value, const int n) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            if ((0 <= (i + n)) && ((i + n) < N))
                (*result)[i] = (*value)[i + n];
            else
                (*result)[i] = 0b0;
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x10(%rbp), %rsi
callq 0x44a60
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x20, %rax
jae 0x48d4a
movl -0x24(%rbp), %ecx
addl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x48cf7
movl -0x24(%rbp), %eax
addl -0x1c(%rbp), %eax
cltq
cmpq $0x20, %rax
jae 0x48cf7
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rsi
callq 0x44ae0
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x42220
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0x42240
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x430c0
jmp 0x48d3a
movq -0x48(%rbp), %rdi
movl $0x0, -0x28(%rbp)
callq 0x42220
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0x42240
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x42af0
jmp 0x48d21
jmp 0x48d3a
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x40b20
jmp 0x48d67
jmp 0x48d3c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x48c96
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x48d5d
movq -0x48(%rbp), %rdi
callq 0x40b20
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xd5a0
// File: vsklad[P]cgen/./bal/cnf/tracer/cnfgexftracer.hpp
// Function: bal::CnfGexfTracer::start(bal::Cnf const&)
void start(const Cnf& cnf) override {
            _assert_level_0(p_cnf_ == nullptr);
            _assert_level_0(edges_.size() == 0);
            next_edge_id_ = 0;
            timestamp_ = TIMESTAMP_MIN;
            p_cnf_ = &cnf;
            writer::write_header(cnf);
            writer::compute_edges(cnf, timestamp_, edges_, next_edge_id_);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x30(%rax)
jne 0x48f21
jmp 0x48f40
leaq 0x19ce3(%rip), %rdi     # 0x62c0b
leaq 0x1d49e(%rip), %rsi     # 0x663cd
movl $0x2f, %edx
leaq 0x1d4b5(%rip), %rcx     # 0x663f0
callq 0xd1c0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x4a750
cmpq $0x0, %rax
jne 0x48f55
jmp 0x48f74
leaq 0x1d4c8(%rip), %rdi     # 0x66424
leaq 0x1d46a(%rip), %rsi     # 0x663cd
movl $0x30, %edx
leaq 0x1d481(%rip), %rcx     # 0x663f0
callq 0xd1c0
movq -0x18(%rbp), %rdi
movl $0x0, 0x68(%rdi)
movl $0x0, 0x6c(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x30(%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x49230
movq -0x18(%rbp), %r8
movq %r8, %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl 0x6c(%r8), %edx
movq %r8, %rcx
addq $0x38, %rcx
addq $0x68, %r8
callq 0x49c30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: vsklad[P]cgen/./bal/cnf/tracer/cnfgexftracer.hpp
// Function: bal::CnfGexfTracer::finish()
void finish() override {
            _assert_level_0(p_cnf_ != nullptr);
            write_nodes(*p_cnf_, edges_);
            write_edges(*p_cnf_, edges_);
            writer::write_footer(*p_cnf_);
            p_cnf_ = nullptr;
            edges_.clear();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x30(%rax)
je 0x48fed
jmp 0x4900c
leaq 0x1d443(%rip), %rdi     # 0x66437
leaq 0x1d3d2(%rip), %rsi     # 0x663cd
movl $0x39, %edx
leaq 0x1d442(%rip), %rcx     # 0x66449
callq 0xd1c0
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x30(%rax), %rsi
movq %rax, %rdx
addq $0x38, %rdx
movq 0x18(%rax), %rax
callq *0x30(%rax)
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x30(%rax), %rsi
movq %rax, %rdx
addq $0x38, %rdx
movq 0x18(%rax), %rax
callq *0x40(%rax)
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x30(%rax), %rsi
callq 0x49480
movq -0x10(%rbp), %rdi
movq $0x0, 0x30(%rdi)
addq $0x38, %rdi
callq 0x4a790
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::edge_dynamic_data_t<true>::update(unsigned int, bal::edge_action_t, unsigned int)
void update(const uint32_t clause_header, const edge_action_t action, const timestamp_t timestamp) {
            switch(action) {
                case eaInsert:
                    clauses_count = 1;
                    start = timestamp;
                    end = TIMESTAMP_MAX;
                    break;
                case eaUpdate:
                    clauses_count++;
                    break;
                case eaRemove:
                    _assert_level_0(timestamp >= start);
                    _assert_level_0(clauses_count > 0);
                    clauses_count--;
                    if (clauses_count == 0) {
                        end = timestamp;
                    };
                    break;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
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)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x4ad70
jmp 0x4ad59
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x4ad8c
jmp 0x4ad63
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x4ad99
jmp 0x4ae0c
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0x4ae0c
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4ae0c
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x4(%rcx), %eax
jb 0x4ada7
jmp 0x4adc6
leaq 0x1b6c5(%rip), %rdi     # 0x66473
leaq 0x19b0d(%rip), %rsi     # 0x648c2
movl $0x31, %edx
leaq 0x1b6c5(%rip), %rcx     # 0x66486
callq 0xd1c0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jbe 0x4add1
jmp 0x4adf0
leaq 0x1b712(%rip), %rdi     # 0x664ea
leaq 0x19ae3(%rip), %rsi     # 0x648c2
movl $0x32, %edx
leaq 0x1b69b(%rip), %rcx     # 0x66486
callq 0xd1c0
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jne 0x4ae0a
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0x4ae0c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>> bal::add2<32ul>(bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Cnf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Cnf>> const*)
Ref<GF2NElement<N, Literal<Cnf>>> add2(GF2NElement<N, Literal<Cnf>>* const r,
                                            const GF2NElement<N, Literal<Cnf>>* const x,
                                            const GF2NElement<N, Literal<Cnf>>* const y) {
        Ref<GF2NElement<N, Literal<Cnf>>> result = new_instance_if_unassigned(r);
        const GF2NElement<N, Literal<Cnf>>* args[2] = { x, y };
        literal_word_add<N, Literal<Cnf>, add>(result, args, 2);
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4d520
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4ca80
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
movl $0x2, %edx
callq 0x4ee10
jmp 0x506fc
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x50728
jmp 0x5071f
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x2d470
jmp 0x50732
movq -0x58(%rbp), %rdi
callq 0x2d470
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xd5a0
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: operator<<(std::ostream&, TextReaderException const&)
std::ostream& operator << (std::ostream& stream, const TextReaderException &e) {
        stream << e.message_;
        if (e.line_index_ > 0) {
            stream << ", line: " << e.line_index_ << ", pos: " << e.pos_ << ", \"" << e.line_ << "\"";
        };
        return stream;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0xd290
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x53337
movq -0x8(%rbp), %rdi
leaq 0x13ded(%rip), %rsi     # 0x670c3
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xd0a0
movq %rax, %rdi
leaq 0x13dd8(%rip), %rsi     # 0x670cc
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xd0a0
movq %rax, %rdi
leaq 0x13dc1(%rip), %rsi     # 0x670d4
callq 0xd320
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xd290
movq %rax, %rdi
leaq 0x13da4(%rip), %rsi     # 0x670d6
callq 0xd320
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::skip_space()
inline void skip_space() {
        while (current_token_pos_ < current_line_.size()) {
            if (current_line_[current_token_pos_] != ' ')
                break;
            current_token_pos_++;
            if (current_token_len_ > 0) {
                reset_token();
            };
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0xd1f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x53665
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x53643
jmp 0x53665
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x10(%rax)
jbe 0x53663
movq -0x10(%rbp), %rdi
callq 0x28430
jmp 0x53604
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/anf/anfpolybori.hpp
// Function: bal::PolyBoRiStreamReader::read_named_variable(bal::Anf&)
void read_named_variable(Anf& anf) {
            std::string name = read_literal();
            skip_space();
            read_symbol('=');
            skip_space();
            VariablesArray value = read_variable_value();
            skip_space();
            read_eol();
            anf.add_named_variable(name.data(), value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
addq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x26190
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x53930
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x3d, %esi
callq 0x26430
jmp 0x5394a
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x5395f
movq -0x68(%rbp), %rsi
movq (%rsi), %rax
movq -0x28(%rax), %rax
addq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x597d0
jmp 0x53978
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x5398d
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x26710
jmp 0x539a2
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd400
movq -0x70(%rbp), %rdi
movq %rax, %rsi
leaq -0x60(%rbp), %rdx
callq 0x54e20
jmp 0x539c5
leaq -0x60(%rbp), %rdi
callq 0x10850
leaq -0x30(%rbp), %rdi
callq 0xd1b0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x53a00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x10850
leaq -0x30(%rbp), %rdi
callq 0xd1b0
movq -0x38(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/anf/anfpolybori.hpp
// Function: bal::PolyBoRiStreamReader::read_parameter(bal::Anf&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void read_parameter(Anf& anf, const std::string key) {
            const std::string name = read_literal();
            skip_space();
            read_symbol(':');
            skip_space();
            if (is_token(ttDec)) {
                anf.add_parameter(key, name, read_uint32());
            } else {
                anf.add_parameter(key, name, read_quoted());
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
addq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x26190
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x53b0b
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x3a, %esi
callq 0x26430
jmp 0x53b25
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x53b3a
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x25bb0
movb %al, -0x79(%rbp)
jmp 0x53b57
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x53b60
jmp 0x53bb3
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x25c30
movl %eax, -0x80(%rbp)
jmp 0x53b8a
movl -0x80(%rbp), %ecx
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x55940
jmp 0x53ba3
jmp 0x53c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x53c2b
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
addq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x53c40
jmp 0x53bd7
movq -0x78(%rbp), %rsi
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movl $0x1, %r8d
callq 0x55620
jmp 0x53bf7
leaq -0x68(%rbp), %rdi
callq 0xd1b0
jmp 0x53c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xd1b0
jmp 0x53c2b
leaq -0x38(%rbp), %rdi
callq 0xd1b0
addq $0x90, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xd1b0
movq -0x40(%rbp), %rdi
callq 0xd5a0
nopl (%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_quoted[abi:cxx11]()
std::string read_quoted() {
        load_next_token();
        if (current_token_type_ == ttQuoted) {
            std::string result = current_line_.substr(current_token_pos_ + 1, current_token_len_ - 2);
            skip_token();
            return result;
        } else {
            parse_error("Expect a quoted value");
            return std::string();
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x272c0
movq -0x58(%rbp), %rax
cmpl $0x7, 0x40(%rax)
jne 0x53cb8
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rdi
movb $0x0, -0x11(%rbp)
movq %rax, %rsi
addq $0x18, %rsi
movq 0x8(%rax), %rdx
addq $0x1, %rdx
movq 0x10(%rax), %rcx
subq $0x2, %rcx
callq 0xd340
movq -0x58(%rbp), %rdi
callq 0x26900
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x53cb6
movq -0x68(%rbp), %rdi
callq 0xd1b0
jmp 0x53d35
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xd5b0
movq -0x70(%rbp), %rdx
leaq 0x133c6(%rip), %rsi     # 0x67096
leaq -0x38(%rbp), %rdi
callq 0xd440
jmp 0x53cdb
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x262a0
jmp 0x53cea
leaq -0x38(%rbp), %rdi
callq 0xd1b0
leaq -0x39(%rbp), %rdi
callq 0xd370
movq -0x68(%rbp), %rdi
callq 0xd450
jmp 0x53d35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x53d2a
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 0x53d3f
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xd5a0
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamReader::read_named_variable(bal::Cnf&)
void read_named_variable(Cnf& cnf) {
            std::string name = read_literal();
            skip_space();
            read_symbol('=');
            skip_space();
            VariablesArray value = read_variable_value();
            skip_space();
            read_eol();
            cnf.add_named_variable(name.data(), value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
addq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x26190
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x54700
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x3d, %esi
callq 0x26430
jmp 0x5471a
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x5472f
movq -0x68(%rbp), %rsi
movq (%rsi), %rax
movq -0x28(%rax), %rax
addq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x597d0
jmp 0x54748
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x5475d
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x26710
jmp 0x54772
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd400
movq -0x70(%rbp), %rdi
movq %rax, %rsi
leaq -0x60(%rbp), %rdx
callq 0x54e20
jmp 0x54795
leaq -0x60(%rbp), %rdi
callq 0x10850
leaq -0x30(%rbp), %rdi
callq 0xd1b0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x547d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x10850
leaq -0x30(%rbp), %rdi
callq 0xd1b0
movq -0x38(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamReader::read_header(bal::Cnf&)
void read_header(Cnf& cnf) {
            read_token("p");
            skip_space();
            read_token("cnf");
            skip_space();
            variables_size_t variables_size = read_uint32();
            skip_space();
            clauses_size_t clauses_size = read_uint32();
            skip_space();
            read_eol();
            cnf.resize(variables_size, clauses_size);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
leaq 0xcf1f(%rip), %rsi      # 0x61735
callq 0x54b50
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
leaq 0x13bc6(%rip), %rsi     # 0x68403
callq 0x54b50
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x25c30
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x25c30
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x26710
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x376c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_sint32()
inline int32_t read_sint32() {
        bool is_negative = is_symbol('-');
        if (is_negative) {
            skip_symbol();
        };
        int64_t result = read_uint32();
        if (is_negative) result = -result;
        
        if (result > INT32_MAX || result < INT32_MIN) {
            parse_error("The signed int 32 bit value is out of bounds");
        };
        return (int32_t)result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x2d, %esi
callq 0x263d0
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x54902
movq -0x58(%rbp), %rdi
callq 0x283f0
movq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x25c30
movl %eax, %eax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x54928
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jg 0x5493c
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jge 0x549b0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xd5b0
movq -0x60(%rbp), %rdx
leaq 0x1280c(%rip), %rsi     # 0x67160
leaq -0x38(%rbp), %rdi
callq 0xd440
jmp 0x5495f
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x262a0
jmp 0x5496e
leaq -0x38(%rbp), %rdi
callq 0xd1b0
leaq -0x39(%rbp), %rdi
callq 0xd370
jmp 0x549b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x549a5
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 0x549ba
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamReader::read_parameter(bal::Cnf&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void read_parameter(Cnf& cnf, const std::string key) {
            const std::string name = read_literal();
            skip_space();
            read_symbol(':');
            skip_space();
            if (is_token(ttDec)) {
                cnf.add_parameter(key, name, read_uint32());
            } else {
                cnf.add_parameter(key, name, read_quoted());
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
addq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x26190
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x54a1b
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x3a, %esi
callq 0x26430
jmp 0x54a35
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x535f0
jmp 0x54a4a
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x25bb0
movb %al, -0x79(%rbp)
jmp 0x54a67
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x54a70
jmp 0x54ac3
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x25c30
movl %eax, -0x80(%rbp)
jmp 0x54a9a
movl -0x80(%rbp), %ecx
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x55940
jmp 0x54ab3
jmp 0x54b29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x54b3b
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
addq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x53c40
jmp 0x54ae7
movq -0x78(%rbp), %rsi
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movl $0x1, %r8d
callq 0x55620
jmp 0x54b07
leaq -0x68(%rbp), %rdi
callq 0xd1b0
jmp 0x54b29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xd1b0
jmp 0x54b3b
leaq -0x38(%rbp), %rdi
callq 0xd1b0
addq $0x90, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xd1b0
movq -0x40(%rbp), %rdi
callq 0xd5a0
nopl (%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_token(char const*)
inline void read_token(const char* value) {
        if (is_token(value))
            skip_token();
        else
            parse_error(std::string("Expect \"") + std::string(value) + std::string("\" token"));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26810
testb $0x1, %al
jne 0x54b7d
jmp 0x54b8e
movq -0xe0(%rbp), %rdi
callq 0x26900
jmp 0x54d74
leaq -0x71(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xd5b0
movq -0xe8(%rbp), %rdx
leaq 0xd46c(%rip), %rsi      # 0x62018
leaq -0x70(%rbp), %rdi
callq 0xd440
jmp 0x54bb7
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xd5b0
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0xd440
jmp 0x54bf1
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x28080
jmp 0x54c07
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xd5b0
movq -0x100(%rbp), %rdx
leaq 0x12530(%rip), %rsi     # 0x67158
leaq -0xd0(%rbp), %rdi
callq 0xd440
jmp 0x54c36
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0x28080
jmp 0x54c4c
movq -0xe0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x262a0
jmp 0x54c5e
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0xd0(%rbp), %rdi
callq 0xd1b0
leaq -0xd1(%rbp), %rdi
callq 0xd370
leaq -0x50(%rbp), %rdi
callq 0xd1b0
leaq -0xa8(%rbp), %rdi
callq 0xd1b0
leaq -0xa9(%rbp), %rdi
callq 0xd370
leaq -0x70(%rbp), %rdi
callq 0xd1b0
leaq -0x71(%rbp), %rdi
callq 0xd370
jmp 0x54d74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x54d69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x54d54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x54d48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x54d33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x54d27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0xd0(%rbp), %rdi
callq 0xd1b0
leaq -0xd1(%rbp), %rdi
callq 0xd370
leaq -0x50(%rbp), %rdi
callq 0xd1b0
leaq -0xa8(%rbp), %rdi
callq 0xd1b0
leaq -0xa9(%rbp), %rdi
callq 0xd370
leaq -0x70(%rbp), %rdi
callq 0xd1b0
leaq -0x71(%rbp), %rdi
callq 0xd370
jmp 0x54d7d
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
// File: vsklad[P]cgen/./bal/formula/formula.cpp
// Function: bal::Formula::initialize()
void Formula::initialize() {
        VariableGenerator::reset(0);
        named_variables_.clear();
        parameters_.clear();
        
        add_max_args_ = 0; // 0 means default value
        xor_max_args_ = 0; // 0 means default value
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
callq 0xfcf0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x55a40
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x55a60
movq -0x10(%rbp), %rax
movl $0x0, 0x70(%rax)
movl $0x0, 0x74(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/formula/formula.cpp
// Function: bal::Formula::add_named_variable(char const*, bal::VariablesArray const&)
void Formula::add_named_variable(const char* const name, const VariablesArray& value) {
        // a copy of value is made here; overwrites any previous value
        auto it = named_variables_.find(name);
        if (it == named_variables_.end()) {
            named_variables_.insert({name, value});
        } else {
            it->second = value;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
addq $0x40, %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xd5b0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xd440
jmp 0x54e81
movq -0xc8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x55a80
movq %rax, -0xd8(%rbp)
jmp 0x54e9a
movq -0xd8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd1b0
leaq -0x41(%rbp), %rdi
callq 0xd370
movq -0xd0(%rbp), %rdi
addq $0x40, %rdi
callq 0x172b0
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x55ab0
testb $0x1, %al
jne 0x54ee1
jmp 0x54fa0
movq -0xd0(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xf8(%rbp)
movq -0x18(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x55b20
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x55ae0
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x54f30
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movb %al, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x34dd0
jmp 0x54fc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x54f7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd1b0
leaq -0x41(%rbp), %rdi
callq 0xd370
jmp 0x54fd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x34dd0
jmp 0x54fd0
movq -0x18(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x172e0
movq -0x100(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2df90
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xd5a0
nopl (%rax)
// File: vsklad[P]cgen/./bal/formula/formula.cpp
// Function: bal::Formula::add_named_variable(char const*, bal::VariablesArray const&, unsigned int)
void Formula::add_named_variable(const char* const name, const VariablesArray& value, const variables_size_t index) {
        auto it = named_variables_.find(name);
        if (it == named_variables_.end()) {
            VariablesArray variable_value(0, value.size());
            variable_value.expand_append_element(index, value);
            named_variables_.insert({name, variable_value});
        } else {
            it->second.expand_append_element(index, value);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
addq $0x40, %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xd5b0
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0xd440
jmp 0x55044
movq -0xf0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x55a80
movq %rax, -0x100(%rbp)
jmp 0x5505d
movq -0x100(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xd1b0
leaq -0x49(%rbp), %rdi
callq 0xd370
movq -0xf8(%rbp), %rdi
addq $0x40, %rdi
callq 0x172b0
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x55ab0
testb $0x1, %al
jne 0x550a4
jmp 0x551bc
movq -0x18(%rbp), %rdi
callq 0x102f0
movl %eax, %edx
leaq -0x88(%rbp), %rdi
movq %rdi, -0x108(%rbp)
xorl %esi, %esi
callq 0x10330
movq -0x108(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x55bd0
jmp 0x550d9
movq -0xf8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x110(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x55c90
jmp 0x55104
movq -0x110(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x55ae0
movb %dl, -0x119(%rbp)
movq %rax, -0x118(%rbp)
jmp 0x55126
movb -0x119(%rbp), %al
movq -0x118(%rbp), %rcx
movq %rcx, -0xd8(%rbp)
movb %al, -0xd0(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x34dd0
leaq -0x88(%rbp), %rdi
callq 0x10850
jmp 0x551d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5517d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xd1b0
leaq -0x49(%rbp), %rdi
callq 0xd370
jmp 0x551e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x551ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x34dd0
leaq -0x88(%rbp), %rdi
callq 0x10850
jmp 0x551e1
leaq -0x28(%rbp), %rdi
callq 0x172e0
movq %rax, %rdi
addq $0x20, %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x55bd0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xd5a0
nopw (%rax,%rax)
// File: vsklad[P]cgen/./bal/formula/formula.cpp
// Function: bal::Formula::is_variable_named(unsigned int) const
bool Formula::is_variable_named(const variableid_t variable_id) const {
        for (auto vit = named_variables_.begin(); vit != named_variables_.end(); vit++) {
            if (vit->second.contains(variable_id)) {
                return true;
            };
        };
        return false;
    }

// 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)
addq $0x40, %rdi
callq 0x3b1c0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0x2de10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b1f0
testb $0x1, %al
jne 0x55238
jmp 0x5526f
leaq -0x20(%rbp), %rdi
callq 0x2de90
movq %rax, %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x55d40
testb $0x1, %al
jne 0x55256
jmp 0x5525c
movb $0x1, -0x1(%rbp)
jmp 0x55273
jmp 0x5525e
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x55da0
movq %rax, -0x30(%rbp)
jmp 0x55214
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: vsklad[P]cgen/./bal/formula/formula.cpp
// Function: bal::Formula::named_variable_update_unassigned(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bal::VariablesArray const&)
variables_size_t Formula::named_variable_update_unassigned(const std::string& name, const VariablesArray& source) {
        auto it = named_variables_.find(name);
        if (it != named_variables_.end()) {
            _assert_level_1(source.size() == it->second.size());
            const bal::literalid_t* const p_src = source.data();
            bal::literalid_t* const p_dst = it->second.data();
            variables_size_t changes_count = 0;
            
            for (auto i = 0; i < source.size(); i++) {
                if (literal_t__is_unassigned(p_dst[i]) && !literal_t__is_unassigned(p_src[i])) {
                    p_dst[i] = p_src[i];
                    changes_count++;
                };
            };
            
            return changes_count;
        } else {
            return VARIABLEID_ERROR;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x55a80
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x40, %rdi
callq 0x172b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17280
testb $0x1, %al
jne 0x55374
jmp 0x5545b
movq -0x20(%rbp), %rdi
callq 0x102f0
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x172e0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x102f0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jne 0x553a0
jmp 0x553bf
leaq 0x12a28(%rip), %rdi     # 0x67dcf
leaq 0x12a44(%rip), %rsi     # 0x67df2
movl $0x44, %edx
leaq 0x12a52(%rip), %rcx     # 0x67e0c
callq 0xd1c0
movq -0x20(%rbp), %rdi
callq 0x2e180
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x172e0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x10310
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0x102f0
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jae 0x55453
movq -0x40(%rbp), %rax
movslq -0x48(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x55446
movq -0x38(%rbp), %rax
movslq -0x48(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x55446
movq -0x38(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x40(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x55448
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x553f3
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x55462
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/formula/formula.cpp
// Function: bal::Formula::named_variables_assign_negations(bal::VariablesArray&) const
void Formula::named_variables_assign_negations(VariablesArray& destination) const {
        literalid_t* data = destination.data();
        // this assigns any negations into variables_
        for (auto vit = named_variables_.begin(); vit != named_variables_.end(); vit++) {
            const literalid_t* const template_ = vit->second.data();
            for (auto j = 0; j < vit->second.size(); j++) {
                if (literal_t__is_variable(template_[j])) {
                    const variableid_t variable_id = literal_t__variable_id(template_[j]);
                    assert(variable_id < destination.size());
                    data[variable_id] = template_[j];
                };
            };
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10310
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x40, %rdi
callq 0x3b1c0
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
callq 0x2de10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b1f0
testb $0x1, %al
jne 0x554cd
jmp 0x555ca
leaq -0x20(%rbp), %rdi
callq 0x2de90
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2e180
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2de90
movq %rax, %rdi
addq $0x20, %rdi
callq 0x102f0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jae 0x555b4
movq -0x30(%rbp), %rcx
movslq -0x34(%rbp), %rdx
xorl %eax, %eax
cmpl $0x1, (%rcx,%rdx,4)
movb %al, -0x4d(%rbp)
jbe 0x5553a
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpl $-0x2, (%rax,%rcx,4)
setbe %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0x55543
jmp 0x555a4
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102f0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jae 0x55570
jmp 0x5558f
leaq 0x12902(%rip), %rdi     # 0x67e79
leaq 0x12874(%rip), %rsi     # 0x67df2
movl $0x61, %edx
leaq 0x12910(%rip), %rcx     # 0x67e9a
callq 0xd1c0
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x555a6
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x554ed
jmp 0x555b6
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x55da0
movq %rax, -0x40(%rbp)
jmp 0x554a6
addq $0x60, %rsp
popq %rbp
retq
// File: vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray::expand_append_element(unsigned int, bal::VariablesArray const&)
inline void expand_append_element(const variables_size_t index, const VariablesArray& value) {
            assert(value.size_ == element_size_);
            if ((index + 1) * element_size_ > size_) {
                // fill in the missing elements with unassigned literals
                append(LITERALID_UNASSIGNED, (index + 1) * element_size_ - size_);
            };
            std::copy(value.data_, value.data_ + value.size_, data_ + (index * element_size_));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl 0x1c(%rcx), %eax
jne 0x55bf9
jmp 0x55c18
leaq 0x122ea(%rip), %rdi     # 0x67eea
leaq 0x5b25(%rip), %rsi      # 0x5b72c
movl $0x6d, %edx
leaq 0x122f4(%rip), %rcx     # 0x67f07
callq 0xd1c0
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $0x1, %eax
imull 0x1c(%rcx), %eax
cmpl 0x8(%rcx), %eax
jbe 0x55c46
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x1, %edx
imull 0x1c(%rdi), %edx
subl 0x8(%rdi), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15a70
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
shlq $0x2, %rax
addq %rax, %rsi
movq (%rcx), %rdx
movl -0xc(%rbp), %eax
imull 0x1c(%rcx), %eax
movl %eax, %eax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x115c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray::contains(unsigned int) const
inline bool contains(const variableid_t variable_id) const {
            for (container_size_t i = 0; i < size_; i++) {
                if (literal_t__variable_id(data_[i]) == variable_id) {
                    return true;
                };
            };
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x55d90
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl %eax
subl $0x1, %eax
cmpl -0x14(%rbp), %eax
jne 0x55d83
movb $0x1, -0x1(%rbp)
jmp 0x55d94
jmp 0x55d85
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x55d5a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: vsklad[P]cgen/main.cpp
// Function: print_help()
void print_help() {
    print_version();
    std::cout << APP_DESCRIPTION << std::endl;
    std::cout << APP_USAGE_SHORT;
    std::cout << APP_USAGE_LONG;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x57620
movq 0x2b920(%rip), %rdi     # 0x82fa0
leaq 0x10923(%rip), %rsi     # 0x67faa
callq 0xd320
movq %rax, %rdi
movq 0x2b8ea(%rip), %rsi     # 0x82f80
callq 0xd360
movq 0x2b8fe(%rip), %rdi     # 0x82fa0
leaq 0x10967(%rip), %rsi     # 0x68010
callq 0xd320
movq 0x2b8eb(%rip), %rdi     # 0x82fa0
leaq 0x10a5a(%rip), %rsi     # 0x68116
callq 0xd320
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: vsklad[P]cgen/./shared.hpp
// Function: get_formula_type_title(CGenFormulaType)
inline const char* const get_formula_type_title(const CGenFormulaType value) {
    switch(value) {
        case ftCnf:
            return "CNF";
        case ftAnf:
            return "ANF";
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x589dd
jmp 0x589d3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x589ea
jmp 0x589f7
leaq 0x8f1e(%rip), %rax      # 0x61902
movq %rax, -0x8(%rbp)
jmp 0x589f9
leaq 0x8f0d(%rip), %rax      # 0x618fe
movq %rax, -0x8(%rbp)
jmp 0x589f9
ud2
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: vsklad[P]cgen/./bal/variables/variablesio.cpp
// Function: bal::write_sequence_parameters_(std::ostream&, unsigned long, int)
void write_sequence_parameters_(std::ostream& stream,
                                    const size_t sequence_size, const int sequence_step) {
        if (sequence_size > 1) {
            stream << "/" << std::dec << sequence_size;
            if (sequence_step != 0) {
                stream << "/" << std::dec << sequence_step;
            };
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x1, -0x10(%rbp)
jbe 0x58fc7
movq -0x8(%rbp), %rdi
leaq 0x2de9(%rip), %rsi      # 0x5bd5e
callq 0xd320
movq %rax, %rdi
leaq -0x48cc4(%rip), %rsi    # 0x102c0
callq 0xd0f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xd0a0
cmpl $0x0, -0x14(%rbp)
je 0x58fc5
movq -0x8(%rbp), %rdi
leaq 0x2db8(%rip), %rsi      # 0x5bd5e
callq 0xd320
movq %rax, %rdi
leaq -0x48cf5(%rip), %rsi    # 0x102c0
callq 0xd0f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0xd580
jmp 0x58fc7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/variables/variablesio.cpp
// Function: bal::VariableTextReader::read_variable_element_sequence_(unsigned int&, int&)
inline void VariableTextReader::read_variable_element_sequence_(unsigned int& sequence_size, signed int& step_size) {
        sequence_size = 1;
        step_size = 0;
        
        skip_space();
        if (is_symbol('/')) {
            skip_symbol();
            skip_space();
            sequence_size = read_uint32(1);
            skip_space();
            if (is_symbol('/')) {
                skip_symbol();
                skip_space();
                step_size = read_sint32();
                skip_space();
            };
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2f, %esi
callq 0x263d0
testb $0x1, %al
jne 0x5a9ea
jmp 0x5aaa1
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x283f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x25c30
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2f, %esi
callq 0x263d0
testb $0x1, %al
jne 0x5aa57
jmp 0x5aa9f
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x283f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x548d0
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x535f0
jmp 0x5aaa1
addq $0x20, %rsp
popq %rbp
retq