LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::is_eol()
inline bool is_eol() {
        load_first_line();
        // skip \r symbol at the end if exists
        if (current_token_pos_ == current_line_.size() - 1 && current_line_[current_token_pos_] == '\r') {
            current_token_pos_++;
        };
        return current_token_pos_ >= current_line_.size();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x197d4
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rdx, %rax
jne 0x18c2e
movq 0x18(%rbx), %rdx
cmpb $0xd, (%rdx,%rax)
jne 0x18c2e
incq %rax
movq %rax, 0x8(%rbx)
cmpq %rcx, %rax
setae %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::is_token(char const*)
inline bool is_token(const char* value) {
        load_next_token();
        if (current_token_len_ > 0) {
            auto index = 0;
            while (index < current_token_len_ && value[index] != 0) {
                if (current_line_[current_token_pos_ + index] != value[index])
                    return false;
                index++;
            };
            if (value[index] != 0) {
                index++;
            };
            return (index == current_token_len_);
        };
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x19176
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x18d16
movq 0x18(%r14), %rsi
addq 0x8(%r14), %rsi
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x18d1a
movb (%rbx,%rdx), %dil
testb %dil, %dil
je 0x18d26
cmpb %dil, (%rsi,%rdx)
jne 0x18d16
incq %rdx
jmp 0x18cfd
xorl %eax, %eax
jmp 0x18d2e
xorl %ecx, %ecx
cmpb $0x0, (%rbx,%rax)
setne %cl
movq %rax, %rdx
addl %edx, %ecx
cmpq %rcx, %rax
sete %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_until_eol[abi:cxx11]()
inline const std::string read_until_eol() {
        std::string result = get_current_token();
        current_token_pos_ = current_line_.size();
        reset_token();
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
addq 0x8(%rbx), %rsi
leaq -0x11(%rbp), %rdx
callq 0xc0e0
movq 0x20(%rbx), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
andl $0x0, 0x40(%rbx)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray& bal::VariablesArray::operator=<char, std::char_traits<char>>(char const*)
inline VariablesArray& operator = (const charT* const s) {
            static constexpr std::size_t charT_size_bits = sizeof(charT) << 3;
            
            const std::size_t size_char = charT_traits::length(s);
            const std::size_t size_bits = size_char * charT_size_bits;
            
            _assert_level_0(size_bits <= VARIABLEID_MAX);
            _assert_level_1(size_bits % element_size_ == 0);
            resize((container_size_t)size_bits);
            
            // encode bit by bit for each byte
            bal::literalid_t* p_value = data_;
            for (auto i = 0; i < size_char; i++) {
                for (auto j = 0; j < charT_size_bits; j++) {
                    *p_value = literal_t__constant(s[i] & (1 << (charT_size_bits - 1 - j)));
                    p_value++;
                };
            };
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc100
leaq (,%rax,8), %rsi
cmpq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
jae 0x18df4
movq %rax, %r15
movl %esi, %eax
xorl %edx, %edx
divl 0x1c(%rbx)
testl %edx, %edx
jne 0x18e0d
movq %rbx, %rdi
callq 0xdfb0
movq (%rbx), %rax
xorl %ecx, %ecx
pushq $0x7
popq %rdx
cmpq %r15, %rcx
je 0x18de6
movl %edx, %esi
cmpl $-0x1, %esi
je 0x18de1
movsbl (%r14,%rcx), %edi
xorl %r8d, %r8d
btl %esi, %edi
setb %r8b
movl %r8d, (%rax)
addq $0x4, %rax
decl %esi
jmp 0x18dc2
incq %rcx
jmp 0x18dbb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f21f(%rip), %rdi     # 0x3801a
leaq 0x1892a(%rip), %rsi     # 0x3172c
leaq 0x1f22d(%rip), %rcx     # 0x38036
pushq $0x44
jmp 0x18e24
leaq 0x1f29b(%rip), %rdi     # 0x380af
leaq 0x18911(%rip), %rsi     # 0x3172c
leaq 0x1f214(%rip), %rcx     # 0x38036
pushq $0x45
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./acl/sha.hpp
// Function: acl::SHA<32ul, 16u, bal::Literal<bal::Cnf>>::pad_message(unsigned int const*, unsigned int)
static VariablesArray pad_message(const literalid_t* const message, const variables_size_t message_size) {
            constexpr auto block_bits_size = MESSAGE_BLOCK_SIZE * WORD_SIZE;
            variables_size_t number_of_blocks = message_size / block_bits_size + 1;
            if ((message_size % block_bits_size) > 447) {
                number_of_blocks++;
            };
            
            const variables_size_t padded_words_size = number_of_blocks * MESSAGE_BLOCK_SIZE;
            const variables_size_t padded_bits_size = padded_words_size * WORD_SIZE;
            VariablesArray padded_message(padded_words_size, WORD_SIZE);
            literalid_t* data = padded_message.data();

            // copy the message
            std::copy(message, message + message_size, data);
            // append 1 bit
            data[message_size] = literal_t__constant(1);
            // append the rest with zeros except for the last 64 bits
            std::fill(data + message_size + 1, data + padded_bits_size - 64, literal_t__constant(0));
            // the last 64 bits is the message size in bits
            uint64_t message_size_ = message_size;
            for (auto i = 0; i < 64; i++) {
                data[padded_bits_size - i - 1] = message_size_ & 1;
                message_size_ >>= 1;
            };

            return padded_message;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movl %edx, %r13d
shrl $0x9, %r13d
movl %edx, %eax
notl %eax
andl $0x1c0, %eax            # imm = 0x1C0
cmpl $0x1, %eax
adcl $0x1, %r13d
movl %edx, %r12d
movl %r13d, %esi
shll $0x4, %esi
shll $0x9, %r13d
pushq $0x20
popq %rdx
callq 0xdbc2
movq (%r14), %r15
testl %ebx, %ebx
je 0x18f00
leaq (,%r12,4), %rdx
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0xc440
movl $0x1, (%r15,%r12,4)
movl %r13d, %eax
leaq -0x104(,%rax,4), %rax
shlq $0x2, %r12
cmpq %r12, %rax
je 0x18f28
andl $0x0, 0x4(%r15,%r12)
addq $0x4, %r12
jmp 0x18f17
addl $0xfffffe00, %r13d      # imm = 0xFFFFFE00
leaq (%r15,%r13,4), %rax
addq $0x7fc, %rax            # imm = 0x7FC
xorl %ecx, %ecx
cmpq $-0x40, %rcx
je 0x18f50
movl %ebx, %edx
andl $0x1, %edx
movl %edx, (%rax,%rcx,4)
shrl %ebx
decq %rcx
jmp 0x18f3b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_hex()
inline void parse_hex() {
        current_token_len_++;
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_hex_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_HEX_INVALID_SYMBOL);
        } else if (current_token_len_ == 2) {
            parse_error(ERROR_MISSING_HEX_VALUE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
addq $0x2, %rax
movq 0x20(%rdi), %rdx
movq 0x18(%rdi), %rsi
addq %rcx, %rsi
movq %rax, 0x10(%rbx)
leaq (%rcx,%rax), %rdi
cmpq %rdx, %rdi
jae 0x1931c
movb (%rsi,%rax), %dil
cmpb $0x30, %dil
jl 0x1931c
cmpb $0x3a, %dil
jb 0x192d7
cmpb $0x41, %dil
jb 0x1931c
cmpb $0x47, %dil
setb %r8b
leal -0x61(%rdi), %r9d
cmpb $0x6, %r9b
setb %r9b
orb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x192dc
incq %rax
jmp 0x19297
cmpb $0x5b, %dil
jae 0x19308
leaq 0x1ea9d(%rip), %rsi     # 0x37d86
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xc0e0
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x189ce
leaq -0x50(%rbp), %rdi
jmp 0x19346
cmpb $0x61, %dil
jb 0x19316
cmpb $0x7b, %dil
jb 0x192e2
jmp 0x1931c
cmpb $0x5f, %dil
je 0x192e2
cmpq $0x2, %rax
jne 0x1934b
leaq 0x1ea81(%rip), %rsi     # 0x37daa
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xc0e0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x189ce
leaq -0x30(%rbp), %rdi
callq 0xc110
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x19364
jmp 0x1936b
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xc110
jmp 0x1936e
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_bin()
inline void parse_bin() {
        current_token_len_++;
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_bin_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_BIN_INVALID_SYMBOL);
        } else if (current_token_len_ == 2) {
            parse_error(ERROR_MISSING_BIN_VALUE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
addq $0x2, %rax
movq 0x20(%rdi), %rsi
movq 0x18(%rdi), %rdi
addq %rdx, %rdi
movq %rax, 0x10(%rbx)
leaq (%rdx,%rax), %rcx
cmpq %rsi, %rcx
jae 0x19406
movb (%rdi,%rax), %cl
movl %ecx, %r8d
andb $-0x2, %r8b
cmpb $0x30, %r8b
jne 0x193bb
incq %rax
jmp 0x19399
cmpb $0x30, %cl
jl 0x19406
cmpb $0x3a, %cl
jae 0x193eb
leaq 0x1ea13(%rip), %rsi     # 0x37ddf
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xc0e0
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x189ce
leaq -0x50(%rbp), %rdi
jmp 0x19430
cmpb $0x41, %cl
jb 0x19406
cmpb $0x5b, %cl
jb 0x193c5
cmpb $0x61, %cl
jb 0x19401
cmpb $0x7b, %cl
jb 0x193c5
jmp 0x19406
cmpb $0x5f, %cl
je 0x193c5
cmpq $0x2, %rax
jne 0x19435
leaq 0x1e9eb(%rip), %rsi     # 0x37dfe
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xc0e0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x189ce
leaq -0x30(%rbp), %rdi
callq 0xc110
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x1944e
jmp 0x19455
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xc110
jmp 0x19458
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_dec()
inline void parse_dec() {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_dec_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_DEC_INVALID_SYMBOL);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x20(%rdi), %rdx
movq 0x18(%rdi), %rdi
addq %rax, %rdi
incq %rcx
movq %rcx, 0x10(%rbx)
leaq (%rax,%rcx), %rsi
cmpq %rdx, %rsi
jae 0x194d9
movb (%rdi,%rcx), %sil
leal -0x30(%rsi), %r8d
incq %rcx
cmpb $0xa, %r8b
jb 0x19484
cmpb $0x41, %sil
jl 0x194d9
cmpb $0x5b, %sil
jae 0x194e2
leaq 0x1e979(%rip), %rsi     # 0x37e2e
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0xc0e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x189ce
leaq -0x38(%rbp), %rdi
callq 0xc110
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x61, %sil
jb 0x194f0
cmpb $0x7b, %sil
jb 0x194ae
jmp 0x194d9
cmpb $0x5f, %sil
je 0x194ae
jmp 0x194d9
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_literal()
inline void parse_literal() {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x20(%rdi), %rdx
movq 0x18(%rdi), %rsi
addq %rax, %rsi
incq %rcx
movq %rcx, 0x10(%rdi)
leaq (%rax,%rcx), %r8
cmpq %rdx, %r8
jae 0x19563
movb (%rsi,%rcx), %r8b
cmpb $0x30, %r8b
jl 0x19563
cmpb $0x3a, %r8b
jb 0x19523
cmpb $0x41, %r8b
jb 0x19563
cmpb $0x5b, %r8b
jb 0x19523
cmpb $0x61, %r8b
jb 0x1955d
cmpb $0x7a, %r8b
jbe 0x19523
jmp 0x19563
cmpb $0x5f, %r8b
je 0x19523
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_quoted(char)
inline void parse_quoted(const char quote_symbol) {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
            (current_line_[current_token_pos_ + current_token_len_] != quote_symbol)) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            (current_line_[current_token_pos_ + current_token_len_] == quote_symbol)) {
            current_token_len_++;
        } else {
            parse_error(ERROR_MISSING_CLOSING_QUOTE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
incq %rdx
movq 0x18(%rdi), %rdi
addq %rax, %rdi
movq %rdx, 0x10(%rbx)
leaq (%rax,%rdx), %r8
cmpq %rcx, %r8
jae 0x195aa
leaq 0x1(%rdx), %r8
cmpb %sil, (%rdi,%rdx)
movq %r8, %rdx
jne 0x1958a
movq %r8, 0x10(%rbx)
jmp 0x195d5
leaq 0x1e89d(%rip), %rsi     # 0x37e4e
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0xc0e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x189ce
leaq -0x38(%rbp), %rdi
callq 0xc110
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
leaq 0x18(%rbx), %rcx
testb %al, %al
je 0x1980f
leaq 0x246df(%rip), %rsi     # 0x3dee4
movq %rcx, %rdi
callq 0xc500
jmp 0x1981f
movq (%rbx), %rax
movq %rbx, %rdi
movq %rcx, %rsi
callq *0x8(%rax)
incq 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0xdfd0
movq (%rbx), %rax
movq %rax, (%r14)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r14)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
andq $0x0, (%rbx)
andl $0x0, 0x18(%rbx)
andl $0x0, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x19176
cmpq $0x0, 0x10(%rbx)
je 0x198ea
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movb (%rcx,%rax), %r14b
movq %rbx, %rdi
callq 0x197ba
jmp 0x19918
leaq 0x1e6ac(%rip), %rsi     # 0x37f9d
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0xc0e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x189ce
leaq -0x38(%rbp), %rdi
callq 0xc110
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: void bal::CnfGexfStreamWriter_write_edge_weighted<true>(std::ostream&, bal::edge_weight_data_t<true> const&)
void CnfGexfStreamWriter_write_edge_weighted<true>(std::ostream& stream, const edge_weight_data_t<true>& edge) {
        stream << " weight=\"" << edge.weight << "\"";
        if (edge.cardinality != 1) {
            stream << ">" << std::endl;
            stream << "  <attvalues>" << std::endl;
            stream << "    <attvalue for=\"0\" value=\"" << edge.cardinality << "\"/>" << std::endl;
            stream << "  </attvalues>" << std::endl;
            stream << "</edge>" << std::endl;
        } else {
            stream << "/>" << std::endl;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1e560(%rip), %rsi     # 0x38210
callq 0xc290
movsd 0x8(%r14), %xmm0
movq %rax, %rdi
callq 0xc430
leaq 0x22f19(%rip), %rsi     # 0x3cbe3
movq %rax, %rdi
callq 0xc290
cmpl $0x1, (%r14)
jne 0x19ce1
leaq 0x20969(%rip), %rsi     # 0x3a648
jmp 0x19d5e
leaq 0x20ac8(%rip), %rsi     # 0x3a7b0
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
leaq 0x1e51b(%rip), %rsi     # 0x3821a
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
leaq 0x1e512(%rip), %rsi     # 0x38228
movq %rbx, %rdi
callq 0xc290
movl (%r14), %esi
movq %rax, %rdi
callq 0xc190
leaq 0x20917(%rip), %rsi     # 0x3a647
movq %rax, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
leaq 0x1e4ff(%rip), %rsi     # 0x38246
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
leaq 0x1e4f7(%rip), %rsi     # 0x38255
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc120
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: void bal::CnfGexfStreamWriter_write_edge_dynamic<true>(std::ostream&, bal::edge_dynamic_data_t<true> const&)
void CnfGexfStreamWriter_write_edge_dynamic<true>(std::ostream& stream, const edge_dynamic_data_t<true>& edge) {
        if (edge.start != TIMESTAMP_MIN) {
            stream << " start=\"" << edge.start << "\"";
        };
        if (edge.end != TIMESTAMP_MAX) {
            stream << " end=\"" << edge.end << "\"";
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x4(%rsi)
je 0x19dae
leaq 0x1e4d1(%rip), %rsi     # 0x3825d
movq %r14, %rdi
callq 0xc290
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0xc190
leaq 0x22e3d(%rip), %rsi     # 0x3cbe3
movq %rax, %rdi
callq 0xc290
cmpl $-0x1, 0x8(%rbx)
je 0x19de1
leaq 0x1e4ab(%rip), %rsi     # 0x38266
movq %r14, %rdi
callq 0xc290
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0xc190
leaq 0x22e0e(%rip), %rsi     # 0x3cbe3
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc290
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: print_statistics(bal::Anf const&)
void print_statistics(const bal::Anf& anf) {
    if (anf.equations_size() == 0) {
        std::cout << MSG_FORMULA_IS_SATISFIABLE << std::endl;
    } else {
        std::cout << "ANF: " << std::dec;
        std::cout << anf.variables_size() << " variables, ";
        std::cout << anf.equations_size() << " equations" << std::endl;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xb0(%rdi), %rax
cmpq 0xa8(%rdi), %rax
je 0x1a0e3
movq %rdi, %rbx
movq 0x36f39(%rip), %r14     # 0x50fb0
leaq 0x1e288(%rip), %rsi     # 0x38306
movq %r14, %rdi
callq 0xc290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0xc190
leaq 0x1e257(%rip), %rsi     # 0x3830c
movq %rax, %rdi
callq 0xc290
movq 0xb0(%rbx), %rsi
subq 0xa8(%rbx), %rsi
sarq $0x2, %rsi
movq %r14, %rdi
callq 0xc190
leaq 0x1e23b(%rip), %rsi     # 0x38319
movq %rax, %rdi
jmp 0x1a0f1
movq 0x36ec6(%rip), %rdi     # 0x50fb0
leaq 0x1e1b5(%rip), %rsi     # 0x382a6
callq 0xc290
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc120
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: save_append_parameters(bal::Formula&)
void save_append_parameters(bal::Formula& formula) {
    formula.clear_parameters("application");
    formula.add_parameter("application", "name", APP_TITLE);
    formula.add_parameter("application", "version", APP_VERSION);
    formula.add_parameter("application", "url", APP_URL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x1e20f(%rip), %rsi     # 0x38324
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0xc0e0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e640
leaq -0x30(%rbp), %rdi
callq 0xc110
leaq 0x1e1e6(%rip), %rsi     # 0x38324
leaq -0x30(%rbp), %rdi
leaq -0xb(%rbp), %rdx
callq 0xc0e0
leaq 0x1d301(%rip), %rsi     # 0x37453
leaq -0x50(%rbp), %rdi
leaq -0xa(%rbp), %rdx
callq 0xc0e0
leaq 0x1e1ca(%rip), %rsi     # 0x38330
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xc0e0
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
callq 0x2e47c
leaq -0x70(%rbp), %rdi
callq 0xc110
leaq -0x50(%rbp), %rdi
callq 0xc110
leaq -0x30(%rbp), %rdi
callq 0xc110
leaq 0x1e177(%rip), %rsi     # 0x38324
leaq -0x30(%rbp), %rdi
leaq -0xb(%rbp), %rdx
callq 0xc0e0
leaq 0x1de26(%rip), %rsi     # 0x37fe7
leaq -0x50(%rbp), %rdi
leaq -0xa(%rbp), %rdx
callq 0xc0e0
leaq 0x1e160(%rip), %rsi     # 0x38335
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xc0e0
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
callq 0x2e47c
leaq -0x70(%rbp), %rdi
callq 0xc110
leaq -0x50(%rbp), %rdi
callq 0xc110
leaq -0x30(%rbp), %rdi
callq 0xc110
leaq 0x1e108(%rip), %rsi     # 0x38324
leaq -0x30(%rbp), %rdi
leaq -0xb(%rbp), %rdx
callq 0xc0e0
leaq 0x1e10b(%rip), %rsi     # 0x3833b
leaq -0x50(%rbp), %rdi
leaq -0xa(%rbp), %rdx
callq 0xc0e0
leaq 0x1e0fb(%rip), %rsi     # 0x3833f
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0xc0e0
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
callq 0x2e47c
leaq -0x70(%rbp), %rdi
callq 0xc110
leaq -0x50(%rbp), %rdi
callq 0xc110
leaq -0x30(%rbp), %rdi
callq 0xc110
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1a29b
jmp 0x1a2a9
jmp 0x1a2bb
jmp 0x1a2c9
jmp 0x1a29b
jmp 0x1a2a9
jmp 0x1a2bb
jmp 0x1a2c9
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xc110
jmp 0x1a2ac
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc110
jmp 0x1a2be
jmp 0x1a2bb
jmp 0x1a2c9
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xc110
jmp 0x1a2cc
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: save(bal::Cnf&, char const*, CGenOutputFormat)
void save(bal::Cnf& cnf, const char* const file_name, const CGenOutputFormat output_format) {
    save_append_parameters(cnf);
    switch (output_format) {
        case ofCnfDimacs:
            save_impl<bal::Cnf, bal::DimacsStreamWriter>(cnf, file_name);
            break;
        case ofCnfVIGGraphML:
            save_impl<bal::Cnf, bal::CnfGraphMLStreamWriter<false>>(cnf, file_name);
            break;
        case ofCnfWeightedVIGGraphML:
            save_impl<bal::Cnf, bal::CnfGraphMLStreamWriter<true>>(cnf, file_name);
            break;
        case ofCnfVIGGEXF:
            save_impl<bal::Cnf, bal::CnfGexfStreamWriter<false, false>>(cnf, file_name);
            break;
        default:
            throw std::invalid_argument(ERROR_OUTPUT_FORMAT_UNSUPPORTED);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a102
decl %r15d
cmpl $0x3, %r15d
ja 0x1a359
leaq 0x1deb4(%rip), %rax     # 0x381b0
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1be9e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1c0a0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1c1a3
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1bf9d
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %rbx
leaq 0x1dff7(%rip), %rsi     # 0x38362
movq %rax, %rdi
callq 0xc4e0
movq 0x36c5e(%rip), %rsi     # 0x50fd8
movq 0x36c3f(%rip), %rdx     # 0x50fc0
movq %rbx, %rdi
callq 0xc490
movq %rax, %r14
movq %rbx, %rdi
callq 0xc1d0
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: save(bal::Anf&, char const*, CGenOutputFormat)
void save(bal::Anf& anf, const char* const file_name, const CGenOutputFormat output_format) {
    save_append_parameters(anf);
    switch (output_format) {
        case ofAnfPolybori:
            save_impl<bal::Anf, bal::PolyBoRiStreamWriter>(anf, file_name);
            break;
        default:
            throw std::invalid_argument(ERROR_OUTPUT_FORMAT_UNSUPPORTED);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a102
testl %r15d, %r15d
jne 0x1a3ce
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1c2a6
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %rbx
leaq 0x1df82(%rip), %rsi     # 0x38362
movq %rax, %rdi
callq 0xc4e0
movq 0x36be9(%rip), %rsi     # 0x50fd8
movq 0x36bca(%rip), %rdx     # 0x50fc0
movq %rbx, %rdi
callq 0xc490
movq %rax, %r14
movq %rbx, %rdi
callq 0xc1d0
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: get_formula_named_variable(bal::Formula const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const bal::VariablesArray* const get_formula_named_variable(const bal::Formula& formula, const std::string& name) {
    auto vn_it = formula.get_named_variables().find(name);
    if (vn_it == formula.get_named_variables().end()) {
        throw std::invalid_argument(std::string("\"") + name + std::string("\" ") +
                                    std::string(ERROR_UNKNOWN_VARIABLE_NAME));
    };
    
    return &(vn_it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x2e0f8
movq %rax, %rdi
movq %r14, %rsi
callq 0x237da
movq %rax, %rbx
movq %r15, %rdi
callq 0x2e0f8
addq $0x8, %rax
cmpq %rax, %rbx
je 0x1a460
addq $0x40, %rbx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %rbx
leaq 0x22771(%rip), %rsi     # 0x3cbe3
leaq -0x80(%rbp), %rdi
leaq -0x1b(%rbp), %rdx
callq 0xc0e0
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %r14, %rdx
callq 0x1c3a5
leaq 0x1df01(%rip), %rsi     # 0x3839a
leaq -0x60(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0xc0e0
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x195f2
leaq 0x1ded9(%rip), %rsi     # 0x3839d
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xc0e0
leaq -0xe0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x195f2
movb $0x1, %r15b
leaq -0xe0(%rbp), %rsi
movq %rbx, %rdi
callq 0xc4b0
xorl %r15d, %r15d
movq 0x36ad4(%rip), %rsi     # 0x50fd8
movq 0x36ab5(%rip), %rdx     # 0x50fc0
movq %rbx, %rdi
callq 0xc490
movq %rax, %r14
leaq -0xe0(%rbp), %rdi
callq 0xc110
jmp 0x1a52a
movq %rax, %r14
movb $0x1, %r15b
leaq -0x40(%rbp), %rdi
callq 0xc110
jmp 0x1a53b
movq %rax, %r14
movb $0x1, %r15b
leaq -0xc0(%rbp), %rdi
callq 0xc110
jmp 0x1a54f
movq %rax, %r14
movb $0x1, %r15b
leaq -0x60(%rbp), %rdi
callq 0xc110
jmp 0x1a560
movq %rax, %r14
movb $0x1, %r15b
leaq -0xa0(%rbp), %rdi
callq 0xc110
jmp 0x1a574
movq %rax, %r14
movb $0x1, %r15b
leaq -0x80(%rbp), %rdi
callq 0xc110
testb %r15b, %r15b
jne 0x1a587
jmp 0x1a58f
movq %rax, %r14
movq %rbx, %rdi
callq 0xc1d0
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: variable_define_random(CGenVariableInfo&, bal::VariablesArray const&)
void variable_define_random(CGenVariableInfo& value, const bal::VariablesArray& definition) {
    _assert_level_0(value.mode == vmRandom);
    
    std::random_device rd;
    std::uniform_int_distribution<unsigned int> value_distribution(0, 1);
    
    value.data = definition;
    bal::literalid_t* const data = value.data.data();
    
    for (auto i = 0; i < value.data.size(); i++) {
        if (!literal_t__is_constant(data[i])) {
            data[i] = literal_t__constant(value_distribution(rd));
        };
    };
    
    // the value has been generated now
    // change the entry type to avoid generating a different value again
    value.mode = vmValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1398, %rsp           # imm = 0x1398
cmpl $0x1, (%rdi)
jne 0x1a63d
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x13b8(%rbp), %rdi
callq 0x1c3ce
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, -0x30(%rbp)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1c424
movq 0x18(%rbx), %r12
xorl %r13d, %r13d
leaq -0x30(%rbp), %r14
leaq -0x13b8(%rbp), %r15
movl 0x20(%rbx), %eax
cmpq %rax, %r13
jae 0x1a61c
cmpl $0x2, (%r12,%r13,4)
jb 0x1a617
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c446
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, (%r12,%r13,4)
incq %r13
jmp 0x1a5f2
andl $0x0, (%rbx)
leaq -0x13b8(%rbp), %rdi
callq 0x1c454
addq $0x1398, %rsp           # imm = 0x1398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1dd8a(%rip), %rdi     # 0x383ce
leaq 0x1dd9a(%rip), %rsi     # 0x383e5
leaq 0x1dda0(%rip), %rcx     # 0x383f2
movl $0xa0, %edx
callq 0xc180
jmp 0x1a65e
movq %rax, %rbx
leaq -0x13b8(%rbp), %rdi
callq 0x1c454
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: variable_get_template(bal::Formula const&, char const*)
const bal::VariablesArray variable_get_template(const bal::Formula& formula, const char* const variable_name) {
    if (is_binary_variable_name(variable_name)) {
        const bal::literalid_t literal_id = bal::literal_t__from_cstr(variable_name);
        if (literal_t__variable_id(literal_id) >= formula.variables_size()) {
            throw std::invalid_argument("Variable number out of bounds: " + std::string(variable_name));
        };
        bal::VariablesArray result(1, 1);
        *result.data() = literal_id;
        return result;
    } else {
        return *get_formula_named_variable(formula, variable_name);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
leaq -0x70(%rbp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xc0e0
cmpq $0x0, 0x8(%r12)
je 0x1a700
leaq -0x50(%rbp), %rdi
movq (%rdi), %rax
movsbl (%rax), %r12d
addl $-0x30, %r12d
callq 0xc110
cmpl $0x9, %r12d
ja 0x1a709
movq %r14, %rdi
callq 0x1c467
movl %eax, %r12d
movl %eax, %r13d
shrl %r13d
decl %r13d
movq (%r15), %rax
movq %r15, %rdi
callq *0x58(%rax)
cmpl %eax, %r13d
jae 0x1a74b
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xdf92
movl $0x1, 0x1c(%rbx)
movq (%rbx), %rax
movl %r12d, (%rax)
jmp 0x1a739
leaq -0x50(%rbp), %rdi
callq 0xc110
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
movq %r14, %rsi
callq 0xc0e0
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
callq 0x1a411
movq %rbx, %rdi
movq %rax, %rsi
callq 0xdda2
leaq -0x50(%rbp), %rdi
callq 0xc110
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r14, %rsi
callq 0xc0e0
leaq 0x1dcd2(%rip), %rsi     # 0x3843f
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x1c480
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xc4b0
xorl %r15d, %r15d
movq 0x36845(%rip), %rsi     # 0x50fd8
movq 0x36826(%rip), %rdx     # 0x50fc0
movq %rbx, %rdi
callq 0xc490
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xc110
jmp 0x1a7b6
movq %rax, %r14
movb $0x1, %r15b
leaq -0x70(%rbp), %rdi
callq 0xc110
testb %r15b, %r15b
jne 0x1a7c9
jmp 0x1a7e4
movq %rax, %r14
movq %rbx, %rdi
callq 0xc1d0
jmp 0x1a7e4
movq %rax, %r14
jmp 0x1a7e4
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xc110
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq (%rdx), %r12
xorl %r13d, %r13d
movl 0x8(%rbx), %eax
cmpq %rax, %r13
jae 0x1ab83
movl (%r15,%r13,4), %esi
leal 0x1(%rsi), %eax
cmpl $0x3, %eax
jae 0x1ab55
incq %r13
jmp 0x1ab3c
cmpl $0x1, (%r12,%r13,4)
ja 0x1ab50
shrl %esi
decl %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movl (%r15,%r13,4), %ecx
movl %ecx, %edx
andl $0x1, %edx
xorl (%r12,%r13,4), %eax
xorl %edx, %eax
cmpl $0x1, %eax
jne 0x1ab50
movl %ecx, (%r12,%r13,4)
jmp 0x1ab50
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: variables_require_computing(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CGenVariableInfo, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, CGenVariableInfo>>> const&)
bool variables_require_computing(const CGenVariablesMap& variables_map) {
    for (auto it = variables_map.begin(); it != variables_map.end(); it++ ) {
        if (it->second.mode == vmCompute) {
            return true;
        };
    };
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1b20d
cmpl $0x2, 0x40(%rax)
je 0x1b20d
movq %rax, %rdi
callq 0xc2e0
jmp 0x1b1f8
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: variables_store_computed(bal::Formula const&, bal::VariablesArray const&, 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>>>&)
void variables_store_computed(const bal::Formula& formula,
                              const bal::VariablesArray& variables,
                              CGenVariablesMap& variables_map) {
    assert(formula.variables_size() == variables.size());
    for (auto it = variables_map.begin(); it != variables_map.end(); it++ ) {
        if (it->second.mode == vmCompute) {
            const bal::VariablesArray template_ = variable_get_template(formula, it->first.c_str());
            it->second.data.assign_from_template(variables, template_,
                                                 it->second.compute_mode == vcmComplete ? bal::VariablesArray::aftmComplete :
                                                 it->second.compute_mode == vcmConstant ? bal::VariablesArray::aftmConstant :
                                                 bal::VariablesArray::aftmDifference);
            
            std::cout << it->first << " = " << it->second.data << std::endl;
            it->second.mode = vmValue; // the value has now been computed
        };
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x58(%rax)
movq %r14, -0x30(%rbp)
cmpl 0x8(%r14), %eax
jne 0x1b51c
movq 0x18(%rbx), %r12
addq $0x8, %rbx
leaq -0x50(%rbp), %r13
cmpq %rbx, %r12
je 0x1b50d
cmpl $0x2, 0x40(%r12)
jne 0x1b4fd
movq 0x20(%r12), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x1a675
leaq 0x58(%r12), %r14
movl 0x44(%r12), %eax
xorl %ecx, %ecx
cmpl $0x2, %eax
setne %cl
incl %ecx
testl %eax, %eax
cmovel %eax, %ecx
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
callq 0x1c510
leaq 0x20(%r12), %rsi
movq 0x35ae8(%rip), %rdi     # 0x50fb0
callq 0xc230
movq %rax, %rdi
leaq 0x168bf(%rip), %rsi     # 0x31d96
callq 0xc290
movq %rax, %rdi
movq %r14, %rsi
callq 0x2fd93
movq %rax, %rdi
callq 0xc120
andl $0x0, 0x40(%r12)
movq %r13, %rdi
callq 0xde58
movq %r12, %rdi
callq 0xc1b0
movq %rax, %r12
jmp 0x1b473
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d1a4(%rip), %rdi     # 0x386c7
leaq 0x1cebb(%rip), %rsi     # 0x383e5
leaq 0x1d2a4(%rip), %rcx     # 0x387d5
movl $0x192, %edx            # imm = 0x192
callq 0xc180
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xde58
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: process_anf(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>>>&, char const*, char const*, CGenOutputFormat, CGenTraceFormat, bool, bool, bal::FormulaProcessingMode)
void process_anf(CGenVariablesMap& variables_map,
             const char* const input_file_name, const char* const output_file_name,
             const CGenOutputFormat output_format, const CGenTraceFormat trace_format,
             const bool b_reindex_variables, const bool b_normalize_variables,
             const bal::FormulaProcessingMode mode) {
    bal::Anf anf;
    load_impl<bal::Anf, bal::PolyBoRiStreamReader>(anf, input_file_name);
    variables_define(anf, variables_map);
    
    bool is_valid = true;
    
    is_valid = process_impl(anf, variables_map, b_reindex_variables, mode);
    
    if (is_valid && b_normalize_variables) {
        is_valid = normalize_variables(anf, b_reindex_variables);
    };
    
    if (is_valid) {
        if (std::strlen(output_file_name) != 0) {
            save(anf, output_file_name, output_format);
        };
    } else {
        throw std::invalid_argument("Processing failed");
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, %r15d
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
leaq -0xf0(%rbp), %rbx
movq %rbx, %rdi
callq 0x1c5f0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1eb04
leaq -0xf0(%rbp), %rdi
movq %r12, %rsi
callq 0x1a7ec
movl 0x18(%rbp), %ecx
movzbl %r15b, %r15d
leaq -0xf0(%rbp), %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x1ed16
movb 0x10(%rbp), %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1bba4
leaq -0xf0(%rbp), %rdi
movl %r15d, %esi
callq 0x1ee67
testb %al, %al
je 0x1bbde
cmpb $0x0, (%r14)
je 0x1bbc0
leaq -0xf0(%rbp), %rdi
movq %r14, %rsi
movl -0x2c(%rbp), %edx
callq 0x1a39c
leaq -0xf0(%rbp), %rdi
callq 0x1d7d0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %r14
leaq 0x1ce99(%rip), %rsi     # 0x38a89
movq %rax, %rdi
callq 0xc4e0
movq 0x353d9(%rip), %rsi     # 0x50fd8
movq 0x353ba(%rip), %rdx     # 0x50fc0
movq %r14, %rdi
callq 0xc490
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1d0
jmp 0x1bc20
jmp 0x1bc1d
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x1d7d0
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: process_cnf(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>>>&, char const*, char const*, CGenOutputFormat, CGenTraceFormat, bool, bool, bal::FormulaProcessingMode)
void process_cnf(CGenVariablesMap& variables_map,
            const char* const input_file_name, const char* const output_file_name,
            const CGenOutputFormat output_format, const CGenTraceFormat trace_format,
            const bool b_reindex_variables, const bool b_normalize_variables,
            const bal::FormulaProcessingMode mode) {
    bal::Cnf cnf;
    load_impl<bal::Cnf, bal::DimacsStreamReader>(cnf, input_file_name);
    variables_define(cnf, variables_map);
    
    bool is_valid = true;
    
    __CNF_TRACE_INITIALIZE(trace_format, output_file_name);
    is_valid = process_impl(cnf, variables_map, b_reindex_variables, mode);
    __CNF_TRACE_FINIALIZE;
    
    if (is_valid && b_normalize_variables) {
        is_valid = normalize_variables(cnf, b_reindex_variables);
    };
    
    if (is_valid) {
        if (std::strlen(output_file_name) != 0) {
            save(cnf, output_file_name, output_format);
        };
    } else {
        throw std::invalid_argument("Processing failed");
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, %r13d
movl %ecx, -0x2c(%rbp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq -0x110(%rbp), %r14
movq %r14, %rdi
callq 0x1d906
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1eeca
leaq -0x110(%rbp), %rdi
movq %r12, %rsi
callq 0x1a7ec
movl %r13d, %edi
movq %r15, %r14
movq %r15, %rsi
callq 0x1b66b
movl 0x18(%rbp), %ecx
movzbl -0x30(%rbp), %r15d
leaq -0x110(%rbp), %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x1f0dc
movl %eax, %r12d
leaq -0x38(%rbp), %rdi
andq $0x0, (%rdi)
callq 0x10250
movb 0x10(%rbp), %bl
leaq -0x38(%rbp), %rdi
callq 0x10620
andb %r12b, %bl
cmpb $0x1, %bl
jne 0x1bce2
leaq -0x110(%rbp), %rdi
movl %r15d, %esi
callq 0x1f272
movl %eax, %r12d
testb %r12b, %r12b
je 0x1bd1d
cmpb $0x0, (%r14)
je 0x1bcff
leaq -0x110(%rbp), %rdi
movq %r14, %rsi
movl -0x2c(%rbp), %edx
callq 0x1a2d4
leaq -0x110(%rbp), %rdi
callq 0x1eae4
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %r14
leaq 0x1cd5a(%rip), %rsi     # 0x38a89
movq %rax, %rdi
callq 0xc4e0
movq 0x3529a(%rip), %rsi     # 0x50fd8
movq 0x3527b(%rip), %rdx     # 0x50fc0
movq %r14, %rdi
callq 0xc490
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1d0
jmp 0x1bd6d
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x10620
jmp 0x1bd6d
jmp 0x1bd6a
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x1eae4
movq %rbx, %rdi
callq 0xc4c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: void save_impl<bal::Cnf, bal::CnfGraphMLStreamWriter<false>>(bal::Cnf const&, char const*)
void save_impl(const Formula& formula, const char* const file_name) {
    std::cout << "Output file: " << file_name << std::endl;
    
    std::ofstream file(file_name);
    if (file.is_open()) {
        Writer writer(file);
        writer.write(formula);
        file.close();
    }
    else {
        throw std::invalid_argument(ERROR_FAILED_OPENING_OUTPUT_FILE);
    };
    
    print_statistics(formula);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r15
movq %rdi, %rbx
movq 0x34ff6(%rip), %rdi     # 0x50fb0
leaq 0x1e23a(%rip), %rsi     # 0x3a1fb
callq 0xc290
movq %rax, %rdi
movq %r15, %rsi
callq 0xc290
movq %rax, %rdi
callq 0xc120
leaq -0x230(%rbp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xc2d0
leaq -0x1c0(%rbp), %rdi
callq 0xc080
testb %al, %al
je 0x1c04a
leaq -0x30(%rbp), %rdi
movq %r14, 0x8(%rdi)
leaq 0x33b5b(%rip), %rax     # 0x4fb68
movq %rax, (%rdi)
movq %r14, 0x10(%rdi)
movq %rbx, %rsi
callq 0x2198e
leaq -0x230(%rbp), %rdi
callq 0xc380
movq %rbx, %rdi
callq 0x19e5f
leaq -0x230(%rbp), %rdi
callq 0xc3c0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %r14
leaq 0x1e1ad(%rip), %rsi     # 0x3a209
movq %rax, %rdi
callq 0xc4e0
movq 0x34f6d(%rip), %rsi     # 0x50fd8
movq 0x34f4e(%rip), %rdx     # 0x50fc0
movq %r14, %rdi
callq 0xc490
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1d0
jmp 0x1c08c
jmp 0x1c089
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0xc3c0
movq %rbx, %rdi
callq 0xc4c0