LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/bal/referenceable.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>>::set_value(bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>*) const
T* set_value(T* value) const {
            if (value_ != value) {
                if (value_ != nullptr)
                    value_->release();
                if (value != nullptr)
                    value->add_ref();
                value_ = value;
            };
            return value;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x27a08
movq %rdi, %r14
testq %rax, %rax
je 0x279f5
movq (%rax), %rcx
movq -0x20(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x8(%rax,%rcx), %eax
cmpl $0x1, %eax
ja 0x279f0
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x279f5
decl %eax
movl %eax, 0x8(%rdi)
testq %rbx, %rbx
je 0x27a05
movq (%rbx), %rax
movq -0x20(%rax), %rax
incl 0x8(%rbx,%rax)
movq %rbx, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/commandline.cpp
// Function: is_file_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_file_extension(const std::string& file_name, const std::string& value) {
    const std::string::size_type idx = file_name.find_last_of(".");
    if (idx != std::string::npos) {
        std::string file_extension = file_name.substr(idx + 1);
        std::transform(file_extension.begin(), file_extension.end(), file_extension.begin(),
                       [](unsigned char c){ return std::tolower(c); });
        std::string value_lc = value;
        std::transform(value_lc.begin(), value_lc.end(), value_lc.begin(),
                       [](unsigned char c){ return std::tolower(c); });
        return file_extension.compare(value_lc) == 0;
    } else {
        return false;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2f8d7(%rip), %rsi     # 0x480d8
movl $0x1, %ecx
movq $-0x1, %rdx
callq 0xb540
cmpq $-0x1, %rax
je 0x188a9
incq %rax
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xb2e0
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x1885e
movq -0x60(%rbp), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0xb3b0
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x18848
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x1da14
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r14
testq %r14, %r14
je 0x188ae
xorl %r12d, %r12d
movzbl (%rbx,%r12), %edi
callq 0xb3b0
movb %al, (%rbx,%r12)
incq %r12
cmpq %r12, %r14
jne 0x18889
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r14
jmp 0x188b1
xorl %r14d, %r14d
jmp 0x188ff
xorl %r14d, %r14d
movq -0x58(%rbp), %r12
cmpq %r12, %r14
movq %r12, %rdx
cmovbq %r14, %rdx
testq %rdx, %rdx
je 0x188d9
movq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0xb2d0
testl %eax, %eax
je 0x188d9
xorl %r14d, %r14d
jmp 0x188e0
cmpq %r14, %r12
sete %r14b
cmpq %r15, %rbx
je 0x188ed
movq %rbx, %rdi
callq 0xb280
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x188ff
callq 0xb280
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18924
callq 0xb280
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/commandline.cpp
// Function: validate_file_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CGenCommandInfo&, CGenFormulaType, CGenOutputFormat, char const*)
void validate_file_extension(const std::string& file_name, const std::string& value, CGenCommandInfo& info,
                             const CGenFormulaType formula_type, const CGenOutputFormat output_format,
                             const char* const error_message) {
    if (is_file_extension(file_name, value)) {
        if (!info.b_formula_type_specified) {
            info.formula_type = formula_type;
            info.output_format = output_format;
            info.b_formula_type_specified = true;
        } else if (info.formula_type != formula_type) {
            throw std::invalid_argument(error_message);
        };
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r14
callq 0x187e5
testb %al, %al
je 0x1899a
cmpb $0x0, 0x98(%r14)
je 0x1898a
cmpl %r12d, 0x8(%r14)
je 0x1899a
movl $0x10, %edi
callq 0xb130
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb520
movq 0x4365d(%rip), %rsi     # 0x5bfd8
movq 0x4363e(%rip), %rdx     # 0x5bfc0
movq %r14, %rdi
callq 0xb4b0
movl %r12d, 0x8(%r14)
movl %r15d, 0xc(%r14)
movb $0x1, 0x98(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xb1e0
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/commandline.cpp
// Function: CGenCommandLineReader::parse_variable_replace(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>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CGenCommandLineReader::parse_variable_replace(CGenVariablesMap& variables_map, const std::string& variable_name) {
    if (variable_name.empty()) {
        parse_error(ERROR_REPLACE_MUST_FOLLOW_DEFINITION);
    };
    if (is_binary_variable_name(variable_name)) {
        parse_error(ERROR_BINARY_VARIABLE_REPLACE_INCOMPATIBLE);
    };
    
    CGenVariableInfo& variable_value = variables_map.find(variable_name)->second;
    
    if (variable_value.except_count > 0 || variable_value.except_range_size > 0) {
        parse_error(ERROR_EXCEPT_REPLACE_INCOMPATIBLE);
    };

    variable_value.replace_existing = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
jne 0x19a5b
movq (%rbx), %rax
leaq -0x58(%rbp), %rcx
movq -0x18(%rax), %r12
addq %rbx, %r12
movq %rcx, -0x10(%rcx)
leaq 0x2be13(%rip), %rsi     # 0x45837
leaq 0x2be4b(%rip), %rdx     # 0x45876
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x1dab2
movq %r12, %rdi
movq %r13, %rsi
callq 0x1c690
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x19a54
callq 0xb280
cmpq $0x0, 0x8(%r14)
je 0x19ab2
movq (%r14), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x19ab2
movq (%rbx), %rax
leaq -0x38(%rbp), %rcx
movq -0x18(%rax), %r12
addq %rbx, %r12
movq %rcx, -0x10(%rcx)
leaq 0x2bdf5(%rip), %rsi     # 0x45877
leaq 0x2be21(%rip), %rdx     # 0x458aa
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0x1dab2
movq %r12, %rdi
movq %r13, %rsi
callq 0x1c690
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x19ab2
callq 0xb280
movq %r15, %rdi
movq %r14, %rsi
callq 0x1dd7e
movq %rax, %r14
cmpl $0x0, 0x48(%rax)
jne 0x19acd
cmpl $0x0, 0x50(%r14)
je 0x19b16
movq (%rbx), %rax
leaq -0x78(%rbp), %r12
addq -0x18(%rax), %rbx
movq %r12, -0x10(%r12)
leaq 0x2bb17(%rip), %rsi     # 0x455fb
leaq 0x2bb4a(%rip), %rdx     # 0x45635
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0x1dab2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c690
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x19b16
callq 0xb280
movb $0x1, 0x78(%r14)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
jmp 0x19b42
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
jne 0x19b58
jmp 0x19b5d
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x19b5d
callq 0xb280
movq %rbx, %rdi
callq 0xb4e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/commandline.cpp
// Function: CGenCommandLineReader::parse_variable_compute_mode(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>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CGenVariableComputeMode)
void CGenCommandLineReader::parse_variable_compute_mode(CGenVariablesMap& variables_map,
                                                        const std::string& variable_name,
                                                        const CGenVariableComputeMode compute_mode) {
    CGenVariableInfo& variable_value = variables_map.find(variable_name)->second;
    
    if (variable_value.mode != vmCompute) {
        parse_error(ERROR_COMPUTE_MODE_CONTEXT);
    };

    variable_value.compute_mode = compute_mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1dd7e
movq %rax, %r14
cmpl $0x2, 0x40(%rax)
je 0x19bd2
movq (%r15), %rax
leaq -0x38(%rbp), %r13
addq -0x18(%rax), %r15
movq %r13, -0x10(%r13)
leaq 0x2bd05(%rip), %rsi     # 0x458ab
leaq 0x2bd38(%rip), %rdx     # 0x458e5
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x1dab2
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c690
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19bd2
callq 0xb280
movl %ebx, 0x44(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x19bf6
callq 0xb280
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d33a
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1ccd0
movq 0x18(%r14), %rsi
addq 0x8(%r14), %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movb (%rbx,%rdx), %dil
testb %dil, %dil
je 0x1ccc6
cmpb %dil, (%rsi,%rdx)
jne 0x1ccd0
incq %rdx
cmpq %rdx, %rax
jne 0x1cca3
xorl %ecx, %ecx
cmpb $0x0, (%rbx,%rax)
setne %cl
movq %rax, %rdx
addl %edx, %ecx
cmpq %rcx, %rax
sete %al
jmp 0x1ccd2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb110
leaq (,%rax,8), %r12
cmpq $0x7fffffff, %r12       # imm = 0x7FFFFFFF
jae 0x1cdf0
movq %rax, %r15
movl %r12d, %eax
xorl %edx, %edx
divl 0x1c(%rbx)
testl %edx, %edx
jne 0x1ce0f
cmpl %r12d, 0x8(%rbx)
je 0x1cdb4
cmpl %r12d, 0x18(%rbx)
je 0x1cdb0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1cd6a
testq %r12, %r12
je 0x1cda2
movq %r15, %rsi
shlq $0x5, %rsi
callq 0xb470
testq %rax, %rax
jne 0x1cda9
leaq 0x24525(%rip), %rdi     # 0x41277
leaq 0x22a4a(%rip), %rsi     # 0x3f7a3
leaq 0x22a5b(%rip), %rcx     # 0x3f7bb
movl $0x33, %edx
callq 0xb180
testq %r12, %r12
je 0x1cdac
movq %r15, %rdi
shlq $0x5, %rdi
callq 0xb380
movq %rax, (%rbx)
testq %rax, %rax
jne 0x1cdac
leaq 0x22a87(%rip), %rdi     # 0x3f811
leaq 0x22a12(%rip), %rsi     # 0x3f7a3
leaq 0x22a23(%rip), %rcx     # 0x3f7bb
movl $0x38, %edx
callq 0xb180
callq 0xb350
xorl %eax, %eax
movq %rax, (%rbx)
movl %r12d, 0x18(%rbx)
movl %r12d, 0x8(%rbx)
testq %r15, %r15
je 0x1cde4
movq (%rbx), %rax
xorl %ecx, %ecx
movl $0x7, %edx
movsbl (%r14,%rcx), %esi
xorl %edi, %edi
btl %edx, %esi
setb %dil
movl %edi, (%rax)
addq $0x4, %rax
addl $-0x1, %edx
jb 0x1cdc3
incq %rcx
cmpq %r15, %rcx
jne 0x1cdbe
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x292e0(%rip), %rdi     # 0x460d7
leaq 0x2292e(%rip), %rsi     # 0x3f72c
leaq 0x292ee(%rip), %rcx     # 0x460f3
movl $0x44, %edx
callq 0xb180
leaq 0x29356(%rip), %rdi     # 0x4616c
leaq 0x2290f(%rip), %rsi     # 0x3f72c
leaq 0x292cf(%rip), %rcx     # 0x460f3
movl $0x45, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x20, %edx
callq 0xe5fc
movq (%r14), %r15
testl %ebx, %ebx
je 0x1cf52
leaq (,%r12,4), %rdx
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0xb450
leaq (%r15,%r12,4), %rdi
addq $0x4, %rdi
movl $0x1, -0x4(%rdi)
movl %r13d, %edx
leaq (%r15,%rdx,4), %rax
addq $-0x100, %rax
cmpq %rax, %rdi
je 0x1cf8c
shlq $0x2, %rdx
shlq $0x2, %r12
subq %r12, %rdx
addq $-0x104, %rdx           # imm = 0xFEFC
xorl %esi, %esi
callq 0xb160
addl $0xfffffe00, %r13d      # imm = 0xFFFFFE00
leaq (%r15,%r13,4), %rax
addq $0x7fc, %rax            # imm = 0x7FC
xorl %ecx, %ecx
movl %ebx, %edx
andl $0x1, %edx
movl %edx, (%rax,%rcx,4)
shrl %ebx
decq %rcx
cmpq $-0x40, %rcx
jne 0x1cf9f
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_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rsi
leaq 0x2(%rsi), %rax
movq 0x20(%rdi), %rdx
movq %rax, 0x10(%rdi)
addq %rcx, %rsi
addq $0x2, %rsi
cmpq %rdx, %rsi
jae 0x1d57f
movq 0x18(%rbx), %rsi
addq %rcx, %rsi
movb (%rsi,%rax), %dil
cmpb $0x30, %dil
jl 0x1d57f
cmpb $0x3a, %dil
jb 0x1d566
cmpb $0x41, %dil
jb 0x1d57f
cmpb $0x47, %dil
setb %r8b
leal -0x61(%rdi), %r9d
cmpb $0x6, %r9b
setb %r9b
orb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x1d5ce
leaq 0x1(%rax), %r8
movq %r8, 0x10(%rbx)
leaq (%rcx,%rax), %rdi
incq %rdi
movq %r8, %rax
cmpq %rdx, %rdi
jb 0x1d533
jmp 0x1d582
movq %rax, %r8
cmpq $0x2, %r8
jne 0x1d5c3
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x288a6(%rip), %rsi     # 0x45e3d
leaq 0x288d3(%rip), %rdx     # 0x45e71
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1dab2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c690
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d5c3
callq 0xb280
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x5b, %dil
jae 0x1d607
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28836(%rip), %rsi     # 0x45e19
leaq 0x28852(%rip), %rdx     # 0x45e3c
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x1dab2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c690
movq -0x58(%rbp), %rdi
jmp 0x1d5b9
movq %rax, %r8
cmpb $0x61, %dil
jb 0x1d61c
cmpb $0x7b, %dil
jae 0x1d582
jmp 0x1d5d4
cmpb $0x5f, %dil
jne 0x1d582
jmp 0x1d5d4
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x1d638
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d642
callq 0xb280
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_bin()
inline void parse_bin() {
        current_token_len_++;
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_bin_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_BIN_INVALID_SYMBOL);
        } else if (current_token_len_ == 2) {
            parse_error(ERROR_MISSING_BIN_VALUE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
leaq 0x2(%rdx), %rax
movq 0x20(%rdi), %rsi
movq %rax, 0x10(%rdi)
addq %rcx, %rdx
addq $0x2, %rdx
cmpq %rsi, %rdx
jae 0x1d704
movq 0x18(%rbx), %r8
addq %rcx, %r8
movb (%r8,%rax), %dl
movl %edx, %edi
andb $-0x2, %dil
cmpb $0x30, %dil
jne 0x1d6ae
leaq 0x1(%rax), %rdi
movq %rdi, 0x10(%rbx)
leaq (%rcx,%rax), %rdx
incq %rdx
movq %rdi, %rax
cmpq %rsi, %rdx
jb 0x1d685
jmp 0x1d707
cmpb $0x30, %dl
jl 0x1d704
cmpb $0x3a, %dl
jae 0x1d6eb
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x287ab(%rip), %rsi     # 0x45e72
leaq 0x287c2(%rip), %rdx     # 0x45e90
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x1dab2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c690
movq -0x58(%rbp), %rdi
jmp 0x1d73e
cmpb $0x41, %dl
jb 0x1d704
cmpb $0x5b, %dl
jb 0x1d6b8
movq %rax, %rdi
cmpb $0x61, %dl
jb 0x1d753
cmpb $0x7b, %dl
jb 0x1d6b8
jmp 0x1d707
movq %rax, %rdi
cmpq $0x2, %rdi
jne 0x1d748
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28775(%rip), %rsi     # 0x45e91
leaq 0x2879d(%rip), %rdx     # 0x45ec0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1dab2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c690
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d748
callq 0xb280
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x5f, %dl
je 0x1d6b8
jmp 0x1d707
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x1d76e
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d778
callq 0xb280
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_dec()
inline void parse_dec() {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_dec_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_DEC_INVALID_SYMBOL);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 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 0x1d821
movb (%rdi,%rcx), %sil
leal -0x30(%rsi), %r8d
incq %rcx
cmpb $0xa, %r8b
jb 0x1d7a6
cmpb $0x41, %sil
jl 0x1d821
cmpb $0x5b, %sil
jae 0x1d80d
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x286e2(%rip), %rsi     # 0x45ec1
leaq 0x286fa(%rip), %rdx     # 0x45ee0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1dab2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c690
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d821
callq 0xb280
jmp 0x1d821
cmpb $0x61, %sil
jb 0x1d81b
cmpb $0x7b, %sil
jb 0x1d7d0
jmp 0x1d821
cmpb $0x5f, %sil
je 0x1d7d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d83d
callq 0xb280
movq %rbx, %rdi
callq 0xb4e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_quoted(char)
inline void parse_quoted(const char quote_symbol) {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
            (current_line_[current_token_pos_ + current_token_len_] != quote_symbol)) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            (current_line_[current_token_pos_ + current_token_len_] == quote_symbol)) {
            current_token_len_++;
        } else {
            parse_error(ERROR_MISSING_CLOSING_QUOTE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
incq %rdx
movq 0x18(%rdi), %rdi
addq %rax, %rdi
movq %rdx, 0x10(%rbx)
leaq (%rax,%rdx), %r8
cmpq %rcx, %r8
jae 0x1d88c
leaq 0x1(%rdx), %r8
cmpb %sil, (%rdi,%rdx)
movq %r8, %rdx
jne 0x1d86c
movq %r8, 0x10(%rbx)
jmp 0x1d8c7
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x28646(%rip), %rsi     # 0x45ee1
leaq 0x2865b(%rip), %rdx     # 0x45efd
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1dab2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c690
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d8c7
callq 0xb280
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d8e3
callq 0xb280
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x284a0(%rip), %rsi     # 0x462d0
movl $0x9, %edx
callq 0xb320
movsd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0xb440
leaq 0x2cb8d(%rip), %rsi     # 0x4a9dc
movl $0x1, %edx
movq %rax, %rdi
callq 0xb320
cmpl $0x1, (%r14)
jne 0x1de73
leaq 0x2a631(%rip), %rsi     # 0x4849a
movl $0x2, %edx
jmp 0x1df8d
leaq 0x2a788(%rip), %rsi     # 0x48602
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
leaq 0x28425(%rip), %rsi     # 0x462da
movl $0xd, %edx
movq %rbx, %rdi
callq 0xb320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
leaq 0x283f8(%rip), %rsi     # 0x462e8
movl $0x1d, %edx
movq %rbx, %rdi
callq 0xb320
movl (%r14), %esi
movq %rbx, %rdi
callq 0xb190
movq %rax, %r14
leaq 0x2a587(%rip), %rsi     # 0x48499
movl $0x3, %edx
movq %rax, %rdi
callq 0xb320
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
leaq 0x283b9(%rip), %rsi     # 0x46306
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
leaq 0x2838d(%rip), %rsi     # 0x46315
movl $0x7, %edx
movq %rbx, %rdi
callq 0xb320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb1a0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: void bal::CnfGexfStreamWriter_write_edge_dynamic<true>(std::ostream&, bal::edge_dynamic_data_t<true> const&)
void CnfGexfStreamWriter_write_edge_dynamic<true>(std::ostream& stream, const edge_dynamic_data_t<true>& edge) {
        if (edge.start != TIMESTAMP_MIN) {
            stream << " start=\"" << edge.start << "\"";
        };
        if (edge.end != TIMESTAMP_MAX) {
            stream << " end=\"" << edge.end << "\"";
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x4(%rsi)
je 0x1e007
leaq 0x28343(%rip), %rsi     # 0x4631d
movl $0x8, %edx
movq %rbx, %rdi
callq 0xb320
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0xb190
leaq 0x2c9e2(%rip), %rsi     # 0x4a9dc
movl $0x1, %edx
movq %rax, %rdi
callq 0xb320
cmpl $-0x1, 0x8(%r14)
je 0x1e046
leaq 0x28311(%rip), %rsi     # 0x46326
movl $0x6, %edx
movq %rbx, %rdi
callq 0xb320
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0xb190
leaq 0x2c9a7(%rip), %rsi     # 0x4a9dc
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb320
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e40e
movq %rdi, %rbx
movq 0x3dc22(%rip), %r14     # 0x5bfb0
leaq 0x28031(%rip), %rsi     # 0x463c6
movl $0x5, %edx
movq %r14, %rdi
callq 0xb320
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0xb190
leaq 0x27ff9(%rip), %rsi     # 0x463cc
movl $0xc, %edx
movq %rax, %rdi
callq 0xb320
movq 0xb0(%rbx), %rsi
subq 0xa8(%rbx), %rsi
sarq $0x2, %rsi
movq %r14, %rdi
callq 0xb190
movq %rax, %rbx
leaq 0x27fd5(%rip), %rsi     # 0x463d9
movl $0xa, %edx
movq %rax, %rdi
jmp 0x1e424
movq 0x3db9b(%rip), %rbx     # 0x5bfb0
leaq 0x27f4a(%rip), %rsi     # 0x46366
movl $0x1a, %edx
movq %rbx, %rdi
callq 0xb320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb1a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e454
decl %r15d
cmpl $0x3, %r15d
ja 0x1e74a
leaq 0x27b83(%rip), %rax     # 0x46270
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 0x20f5e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21266
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x213ec
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x210e0
movl $0x10, %edi
callq 0xb130
movq %rax, %rbx
leaq 0x27cc4(%rip), %rsi     # 0x46422
movq %rax, %rdi
callq 0xb520
movq 0x3d86b(%rip), %rsi     # 0x5bfd8
movq 0x3d84c(%rip), %rdx     # 0x5bfc0
movq %rbx, %rdi
callq 0xb4b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb1e0
movq %r14, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e454
testl %r15d, %r15d
jne 0x1e7c1
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21572
movl $0x10, %edi
callq 0xb130
movq %rax, %rbx
leaq 0x27c4d(%rip), %rsi     # 0x46422
movq %rax, %rdi
callq 0xb520
movq 0x3d7f4(%rip), %rsi     # 0x5bfd8
movq 0x3d7d5(%rip), %rdx     # 0x5bfc0
movq %rbx, %rdi
callq 0xb4b0
movq %rax, %r14
movq %rbx, %rdi
callq 0xb1e0
movq %r14, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/commands.cpp
// Function: get_formula_named_variable(bal::Formula const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const bal::VariablesArray* const get_formula_named_variable(const bal::Formula& formula, const std::string& name) {
    auto vn_it = formula.get_named_variables().find(name);
    if (vn_it == formula.get_named_variables().end()) {
        throw std::invalid_argument(std::string("\"") + name + std::string("\" ") +
                                    std::string(ERROR_UNKNOWN_VARIABLE_NAME));
    };
    
    return &(vn_it->second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x3af56
movq %rax, %rdi
movq %r14, %rsi
callq 0x2c4d0
movq %rax, %rbx
movq %r15, %rdi
callq 0x3af56
addq $0x8, %rax
cmpq %rax, %rbx
je 0x1e85d
addq $0x40, %rbx
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb130
movq %rax, %rbx
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c163(%rip), %rsi     # 0x4a9dc
leaq 0x2c15d(%rip), %rdx     # 0x4a9dd
leaq -0x68(%rbp), %rdi
callq 0x1dab2
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %r14, %rdx
callq 0x217a6
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x27bae(%rip), %rsi     # 0x4645a
leaq 0x27ba9(%rip), %rdx     # 0x4645c
leaq -0x88(%rbp), %rdi
callq 0x1dab2
leaq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x216f4
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x27b75(%rip), %rsi     # 0x4645d
leaq 0x27b9e(%rip), %rdx     # 0x4648d
leaq -0x48(%rbp), %rdi
callq 0x1dab2
leaq -0xe8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x216f4
movb $0x1, %r13b
leaq -0xe8(%rbp), %rsi
movq %rbx, %rdi
callq 0xb4d0
xorl %r13d, %r13d
movq 0x3d6ad(%rip), %rsi     # 0x5bfd8
movq 0x3d68e(%rip), %rdx     # 0x5bfc0
movq %rbx, %rdi
callq 0xb4b0
movq %rax, %r14
leaq -0xd8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e95a
callq 0xb280
jmp 0x1e95a
movq %rax, %r14
movb $0x1, %r13b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1e974
callq 0xb280
jmp 0x1e974
movq %rax, %r14
movb $0x1, %r13b
leaq -0xb8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e991
callq 0xb280
jmp 0x1e991
movq %rax, %r14
movb $0x1, %r13b
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x1e9aa
callq 0xb280
jmp 0x1e9aa
movq %rax, %r14
movb $0x1, %r13b
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e9bf
callq 0xb280
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x1e9cd
callq 0xb280
testb %r13b, %r13b
jne 0x1e9ea
jmp 0x1e9f2
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x1e9ea
callq 0xb280
jmp 0x1e9ea
movq %rax, %r14
movq %rbx, %rdi
callq 0xb1e0
movq %r14, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1eaad
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x13b8(%rbp), %rdi
callq 0x2180a
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, -0x30(%rbp)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x2187a
movl 0x20(%rbx), %eax
testl %eax, %eax
je 0x1ea89
movq 0x18(%rbx), %r12
xorl %r13d, %r13d
leaq -0x13b8(%rbp), %r14
leaq -0x30(%rbp), %r15
cmpl $0x2, (%r12,%r13,4)
jb 0x1ea7f
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2c56e
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, (%r12,%r13,4)
movl 0x20(%rbx), %eax
incq %r13
movl %eax, %ecx
cmpq %rcx, %r13
jb 0x1ea5c
movl $0x0, (%rbx)
leaq -0x13b8(%rbp), %rdi
callq 0xb270
addq $0x1398, %rsp           # imm = 0x1398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x279da(%rip), %rdi     # 0x4648e
leaq 0x279ea(%rip), %rsi     # 0x464a5
leaq 0x279f0(%rip), %rcx     # 0x464b2
movl $0xa0, %edx
callq 0xb180
jmp 0x1eae7
jmp 0x1ead0
movq %rax, %rbx
leaq -0x13b8(%rbp), %rdi
callq 0xb270
movq %rbx, %rdi
callq 0xb4e0
movq %rax, %rdi
callq 0x1d8eb
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb0f0
cmpq $0x0, 0x8(%r12)
movq (%r12), %rdi
je 0x1eb37
movsbl (%rdi), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
setb %r13b
jmp 0x1eb3a
xorl %r13d, %r13d
leaq -0x40(%rbp), %r12
cmpq %r12, %rdi
je 0x1eb48
callq 0xb280
testb %r13b, %r13b
je 0x1eb98
movq %r14, %rdi
callq 0xb420
leal (%rax,%rax), %ecx
negl %ecx
testl %eax, %eax
leal 0x1(%rax,%rax), %r12d
cmovlel %ecx, %r12d
movl %r12d, %r13d
shrl %r13d
decl %r13d
movq (%r15), %rax
movq %r15, %rdi
callq *0x58(%rax)
cmpl %eax, %r13d
jae 0x1ebe9
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe6e4
movl $0x1, 0x1c(%rbx)
movq (%rbx), %rax
movl %r12d, (%rax)
jmp 0x1ebd7
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
movq %r14, %rsi
callq 0xb0f0
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
callq 0x1e806
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe74a
movl 0x1c(%r14), %eax
movl %eax, 0x1c(%rbx)
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x1ebd7
callq 0xb280
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb130
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r14, %rsi
callq 0xb0f0
leaq 0x278f2(%rip), %rsi     # 0x464ff
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x21958
movb $0x1, %r15b
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xb4d0
xorl %r15d, %r15d
movq 0x3d3a5(%rip), %rsi     # 0x5bfd8
movq 0x3d386(%rip), %rdx     # 0x5bfc0
movq %rbx, %rdi
callq 0xb4b0
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1ec57
callq 0xb280
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ec69
callq 0xb280
testb %r15b, %r15b
jne 0x1ec8a
jmp 0x1ecaa
movq %rax, %r14
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ec8a
callq 0xb280
jmp 0x1ec8a
movq %rax, %r14
movq %rbx, %rdi
callq 0xb1e0
jmp 0x1ecaa
movq %rax, %r14
jmp 0x1ecaa
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x1ecaa
callq 0xb280
movq %r14, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/commands.cpp
// Function: variables_reset_assigned_values(bal::Formula const&, bal::VariablesArray const&, bal::VariablesArray&)
void variables_reset_assigned_values(const bal::Formula& formula,
                                     const bal::VariablesArray& variable_template,
                                     bal::VariablesArray& variable_value) {
    const bal::literalid_t* const template_data = variable_template.data();
    bal::literalid_t* const value_data = variable_value.data();
    
    for (auto i = 0; i < variable_value.size(); i++) {
        if (literal_t__is_variable(template_data[i]) && literal_t__is_constant(value_data[i])) {
            const bal::literalid_t value = formula.get_variable_value(literal_t__variable_id(template_data[i]));
            if (value == literal_t__substitute_literal(template_data[i], value_data[i])) {
                // reset binary variable value since it is already assigned within the formula
                value_data[i] = template_data[i];
            };
        };
    };
}

// Assembly:
cmpl $0x0, 0x8(%rdx)
je 0x1f10b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq (%rdx), %r12
xorl %r13d, %r13d
movl (%r15,%r13,4), %esi
leal 0x1(%rsi), %eax
cmpl $0x3, %eax
jae 0x1f0cf
incq %r13
movl 0x8(%rbx), %eax
cmpq %rax, %r13
jb 0x1f0b6
jmp 0x1f0fd
cmpl $0x1, (%r12,%r13,4)
ja 0x1f0c2
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 0x1f0c2
movl %ecx, (%r12,%r13,4)
jmp 0x1f0c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1f889
cmpl $0x2, 0x40(%rax)
sete %r14b
je 0x1f88c
movq %rax, %rdi
callq 0xb330
cmpq %rbx, %rax
jne 0x1f870
jmp 0x1f88c
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/commands.cpp
// Function: void save_impl<bal::Cnf, bal::CnfGraphMLStreamWriter<false>>(bal::Cnf const&, char const*)
void save_impl(const Formula& formula, const char* const file_name) {
    std::cout << "Output file: " << file_name << std::endl;
    
    std::ofstream file(file_name);
    if (file.is_open()) {
        Writer writer(file);
        writer.write(formula);
        file.close();
    }
    else {
        throw std::invalid_argument(ERROR_FAILED_OPENING_OUTPUT_FILE);
    };
    
    print_statistics(formula);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3aeb3(%rip), %r15     # 0x5bfb0
leaq 0x26f49(%rip), %rsi     # 0x4804d
movl $0xd, %edx
movq %r15, %rdi
callq 0xb320
testq %r14, %r14
je 0x21132
movq %r14, %rdi
callq 0xb110
movq 0x3ae8b(%rip), %rdi     # 0x5bfb0
movq %r14, %rsi
movq %rax, %rdx
callq 0xb320
jmp 0x2114a
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xb4a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
leaq -0x230(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0xb300
leaq -0x1c0(%rbp), %rdi
callq 0xb080
testb %al, %al
je 0x2120e
leaq -0x30(%rbp), %rdi
movq %r15, 0x8(%rdi)
leaq 0x39d99(%rip), %rax     # 0x5af40
movq %rax, (%rdi)
movq %r15, 0x10(%rdi)
movq %rbx, %rsi
callq 0x29172
leaq -0x230(%rbp), %rdi
callq 0xb3a0
movq %rbx, %rdi
callq 0x1e11e
movq 0x3adc7(%rip), %rax     # 0x5bf98
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x228(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x230(%rbp,%rcx)
callq 0xb240
leaq -0x138(%rbp), %rdi
callq 0xb0d0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0xb130
movq %rax, %r14
leaq 0x26e39(%rip), %rsi     # 0x4805b
movq %rax, %rdi
callq 0xb520
movq 0x3ada7(%rip), %rsi     # 0x5bfd8
movq 0x3ad88(%rip), %rdx     # 0x5bfc0
movq %r14, %rdi
callq 0xb4b0
movq %rax, %rbx
movq %r14, %rdi
callq 0xb1e0
jmp 0x21252
jmp 0x2124f
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0xb3e0
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::start(bal::Cnf const&)
void start(const Cnf& cnf) override {
            _assert_level_0(p_cnf_ == nullptr);
            _assert_level_2(offsets_.empty() && clauses_.empty());
            p_cnf_ = &cnf;
            level_next();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x20(%rdi)
jne 0x264ad
movq 0x40(%rdi), %rax
cmpq 0x48(%rdi), %rax
jne 0x2648e
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x2648e
movq %rsi, 0x20(%rdi)
movq (%rdi), %rax
popq %rbp
jmpq *0x20(%rax)
leaq 0x207f7(%rip), %rdi     # 0x46c8c
leaq 0x20795(%rip), %rsi     # 0x46c31
leaq 0x207b3(%rip), %rcx     # 0x46c56
movl $0x50, %edx
callq 0xb180
leaq 0x2076b(%rip), %rdi     # 0x46c1f
leaq 0x20776(%rip), %rsi     # 0x46c31
leaq 0x20794(%rip), %rcx     # 0x46c56
movl $0x4f, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::update_variables(bal::VariablesArray const&)
void update_variables(const VariablesArray& variables) override {
            if (options_ & TRACE_VARIABLE_MAP_FINAL) {
                for (variables_size_t i = 0; i < variables.size(); i++) {
                    if (i != literal_t__variable_id(variables.data()[i])) {
                        stream << "v: " << i + 1 << " -> " << literal_t(variables.data()[i]) << std::endl;
                    };
                };
            };
        }

// Assembly:
testb $0x4, 0x18(%rdi)
je 0x267b1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rsi), %eax
testl %eax, %eax
je 0x267a3
movq %rdi, %r14
xorl %r15d, %r15d
movq (%rbx), %rcx
movl (%rcx,%r15,4), %ecx
shrl %ecx
decl %ecx
cmpq %rcx, %r15
jne 0x26714
incq %r15
jmp 0x26798
movq 0x10(%r14), %r12
movl $0x3, %edx
movq %r12, %rdi
leaq 0x1c193(%rip), %rsi     # 0x428ba
callq 0xb320
leaq 0x1(%r15), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xb190
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
leaq 0x1b718(%rip), %rsi     # 0x41e65
callq 0xb320
movq (%rbx), %rax
movl (%rax,%r15,4), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
callq 0xf3a7
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r12, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
movl 0x8(%rbx), %eax
movq %r13, %r15
movl %eax, %ecx
cmpq %rcx, %r15
jb 0x266fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq