LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray::assign_from_template(bal::VariablesArray const&, bal::VariablesArray const&, bal::VariablesArray::assign_from_template_mode_t)
inline void assign_from_template(const VariablesArray& values, const VariablesArray& template_,
                                         const assign_from_template_mode_t mode) {
            // resize to match
            resize(template_.size_);
            element_size_ = template_.element_size_;
            
            if (mode == aftmComplete) {
                values.assign_template_into(template_, *this);
            } else {
                for (auto i = 0; i < size_; i++) {
                    literalid_t value = LITERALID_UNASSIGNED;
                    if (literal_t__is_variable(template_.data_[i])) {
                        assert(literal_t__variable_id(template_.data_[i]) < values.size_);
                        value = literal_t__lookup(values.data_, template_.data_[i]);
                    } else {
                        value = template_.data_[i];
                    };
                    
                    if ((mode == aftmConstant && literal_t__is_constant(value)) ||
                        (mode == aftmDifference && value != template_.data_[i])) {
                        data_[i] = value;
                    } else {
                        data_[i] = LITERALID_UNASSIGNED;
                    };
                };
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %esi
callq 0xdfb0
movl 0x1c(%r12), %eax
movl %eax, 0x1c(%rbx)
testl %r14d, %r14d
je 0x1c5bb
movq (%r12), %rax
movq (%r15), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
pushq $-0x1
popq %rdi
movl 0x8(%rbx), %r8d
cmpq %r8, %rsi
jae 0x1c5b2
movl (%rax,%rsi,4), %r8d
leal 0x1(%r8), %r10d
movl %r8d, %r9d
cmpl $0x3, %r10d
jb 0x1c586
movl %r8d, %r9d
shrl %r9d
decl %r9d
cmpl 0x8(%r15), %r9d
jae 0x1c5d1
movl %r9d, %r10d
movl %r8d, %r9d
andl $0x1, %r9d
xorl (%rcx,%r10,4), %r9d
xorl $0x1, %r9d
movl %edi, %r10d
cmpl %r8d, %r9d
je 0x1c591
movl %r9d, %r10d
cmpl $0x2, %r14d
cmovnel %edi, %r10d
cmpl $0x2, %r9d
cmovael %r10d, %r9d
cmpl $0x1, %r14d
cmovnel %r10d, %r9d
movl %r9d, (%rdx,%rsi,4)
incq %rsi
jmp 0x1c54b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xddc0
leaq 0x1c4cb(%rip), %rdi     # 0x38aa3
leaq 0x1514d(%rip), %rsi     # 0x3172c
leaq 0x1c4f7(%rip), %rcx     # 0x38add
movl $0xe2, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/commands.cpp
// Function: void load_impl<bal::Cnf, bal::DimacsStreamReader>(bal::Cnf&, char const*)
void load_impl(Formula& formula, const char* const file_name) {
    std::cout << "Input file: " << file_name << std::endl;
    
    if (std::strlen(file_name) == 0) {
        throw std::invalid_argument(ERROR_MISSING_INPUT_FILE_NAME);
    };
    
    std::ifstream file(file_name);
    if (file.is_open()) {
        try {
            Reader reader(file);
            reader.read(formula);
            file.close();
        }
        catch (TextReaderException e) {
            std::cout << "Parse error: " << e << std::endl;
            throw std::invalid_argument("Failed to load the input file");
        }
    }
    else {
        throw std::invalid_argument("Failed to open the input file");
    };
    print_statistics(formula);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rsi, %r14
movq %rdi, %rbx
movq 0x320cb(%rip), %rdi     # 0x50fb0
leaq 0x1dbfe(%rip), %rsi     # 0x3caea
callq 0xc290
movq %rax, %rdi
movq %r14, %rsi
callq 0xc290
movq %rax, %rdi
callq 0xc120
cmpb $0x0, (%r14)
je 0x1ef81
leaq -0x278(%rbp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0xc4d0
leaq -0x200(%rbp), %rdi
callq 0xc080
testb %al, %al
je 0x1efb1
leaq -0x70(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x2d72c
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x2d76c
leaq -0x278(%rbp), %rdi
callq 0xc070
leaq -0x58(%rbp), %rdi
callq 0x2d1e6
movq %rbx, %rdi
callq 0x19e5f
leaq -0x278(%rbp), %rdi
callq 0xc0a0
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %r14
leaq 0x18b4b(%rip), %rsi     # 0x37ade
movq %rax, %rdi
callq 0xc4e0
movq 0x32036(%rip), %rsi     # 0x50fd8
movq 0x32017(%rip), %rdx     # 0x50fc0
movq %r14, %rdi
callq 0xc490
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %r14
leaq 0x1db60(%rip), %rsi     # 0x3cb23
movq %rax, %rdi
callq 0xc4e0
movq 0x32006(%rip), %rsi     # 0x50fd8
movq 0x31fe7(%rip), %rdx     # 0x50fc0
movq %r14, %rdi
callq 0xc490
jmp 0x1f0a2
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1d0
jmp 0x1f0c0
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1d0
jmp 0x1f0cc
movq %rdx, %r14
movq %rax, %rbx
jmp 0x1f025
movq %rax, %rbx
jmp 0x1f0c0
movq %rdx, %r14
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2d1e6
cmpl $0x1, %r14d
jne 0x1f0c0
movq %rbx, %rdi
callq 0xc330
leaq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x2d0c6
movq %rbx, %rdi
callq 0xc0f0
movq 0x31f5e(%rip), %rdi     # 0x50fb0
leaq 0x1da9e(%rip), %rsi     # 0x3caf7
callq 0xc290
leaq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x2d11d
movq %rax, %rdi
callq 0xc120
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %r14
leaq 0x1da81(%rip), %rsi     # 0x3cb05
movq %rax, %rdi
callq 0xc4e0
movq 0x31f45(%rip), %rsi     # 0x50fd8
movq 0x31f26(%rip), %rdx     # 0x50fc0
movq %r14, %rdi
callq 0xc490
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1d0
jmp 0x1f0b2
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x19796
callq 0xc450
leaq -0x278(%rbp), %rdi
callq 0xc0a0
movq %rbx, %rdi
callq 0xc4c0
movq %rax, %rdi
callq 0x11f91
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/anf/anf.hpp
// Function: bal::normalize_variables(bal::Anf&, bool)
inline bool normalize_variables(Anf& anf, const bool b_reindex_variables) {
            assert(b_reindex_variables);
            for (auto vit = anf.get_named_variables_().begin(); vit != anf.get_named_variables_().end(); vit++) {
                anf.encode_negations_(vit->second);
            };
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x1eeab
movq %rdi, %rbx
movq 0x58(%rdi), %r14
leaq 0x48(%rdi), %r15
cmpq %r15, %r14
je 0x1ee9e
leaq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0xd762
movq %r14, %rdi
callq 0xc1b0
movq %rax, %r14
jmp 0x1ee80
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a8b8(%rip), %rdi     # 0x3976a
leaq 0x1a8c5(%rip), %rsi     # 0x3977e
leaq 0x1a8d0(%rip), %rcx     # 0x39790
movl $0x81, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f6cb
movq 0x40(%rdi), %rax
cmpq 0x48(%rdi), %rax
jne 0x1f6b2
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x1f6b2
movq %rsi, 0x20(%rdi)
movq (%rdi), %rax
popq %rbp
jmpq *0x20(%rax)
leaq 0x19513(%rip), %rdi     # 0x38bcc
leaq 0x194b1(%rip), %rsi     # 0x38b71
leaq 0x194cf(%rip), %rcx     # 0x38b96
pushq $0x50
jmp 0x1f6e2
leaq 0x1948d(%rip), %rdi     # 0x38b5f
leaq 0x19498(%rip), %rsi     # 0x38b71
leaq 0x194b6(%rip), %rcx     # 0x38b96
pushq $0x4f
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f896
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq -0x2c(%rbp), %r13
movl 0x8(%rbx), %eax
cmpq %rax, %r15
jae 0x1f888
movq (%rbx), %rax
movl (%rax,%r15,4), %eax
shrl %eax
decl %eax
cmpq %rax, %r15
jne 0x1f838
incq %r15
jmp 0x1f81b
movq 0x10(%r14), %rdi
leaq 0x15077(%rip), %rsi     # 0x348ba
callq 0xc290
leaq 0x1(%r15), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xc190
movq %rax, %rdi
leaq 0x14604(%rip), %rsi     # 0x33e65
callq 0xc290
movq (%rbx), %rcx
movl (%rcx,%r15,4), %ecx
movl %ecx, -0x2c(%rbp)
movq %rax, %rdi
movq %r13, %rsi
callq 0xeb12
movq %rax, %rdi
callq 0xc120
movq %r12, %r15
jmp 0x1f81b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::process_clause(unsigned int const*, unsigned int, bool)
void process_clause(const uint32_t* const p_clause, const container_offset_t offset, const bool is_resolvent) override {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                if (!is_current_clause(p_clause, offset)) {
                    set_current_clause(p_clause, offset);
                    const char action = (is_resolvent) ? 'r' :
                        (clauses_.size() > 1 && clauses_[clauses_.size() - 2] != nullptr) ? '+' : 'e';
                    write_action(action);
                    write_clause(p_clause);
                    stream << std::endl;
                } else if (offset == offsets_.back() && p_clause != clauses_.back()) {
                    // changing p_clause with the same offset is fine
                    _assert_level_0(p_clause != nullptr);
                    set_current_clause(p_clause, offset);
                } else {
                    _assert_level_0(clauses_.size() > 0 && clauses_.back() == p_clause);
                    set_current_clause(p_clause, offset);
                    write_action('u', 1);
                    write_clause(p_clause);
                    stream << std::endl;
                };
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testb $0x2, 0x18(%rdi)
je 0x1f8fb
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x1f8fb
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rbx, %rdi
callq 0x1fd8e
testb %al, %al
je 0x1f904
movq 0x30(%rbx), %rax
movq 0x48(%rbx), %rcx
cmpl %r15d, -0x4(%rcx)
jne 0x1f945
cmpq %r14, -0x8(%rax)
je 0x1f945
testq %r14, %r14
je 0x1f9a8
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1fdf6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x1fdf6
movb $0x72, %al
testb %r12b, %r12b
jne 0x1f93b
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rcx, %rdx
movb $0x65, %al
cmpq $0x9, %rdx
jb 0x1f93b
cmpq $0x0, -0x10(%rcx,%rdx)
pushq $0x65
popq %rcx
pushq $0x2b
popq %rax
cmovel %ecx, %eax
movzbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x1f968
cmpq 0x28(%rbx), %rax
je 0x1f989
cmpq %r14, -0x8(%rax)
jne 0x1f989
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x1fdf6
pushq $0x75
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1fd46
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fe64
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc120
leaq 0x19310(%rip), %rdi     # 0x38ca0
leaq 0x191da(%rip), %rsi     # 0x38b71
leaq 0x19293(%rip), %rcx     # 0x38c31
movl $0x8b, %edx
callq 0xc180
leaq 0x1926e(%rip), %rdi     # 0x38c1d
leaq 0x191bb(%rip), %rsi     # 0x38b71
leaq 0x19274(%rip), %rcx     # 0x38c31
movl $0x88, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::merge_clause(unsigned int const*, unsigned int)
void merge_clause(const uint32_t* const p_clause, const container_offset_t offset) override {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(is_current_clause(p_clause, CONTAINER_END));
                _assert_level_0(offset != CONTAINER_END);
                write_action('m', 1);
                write_clause(p_cnf_->get_clause_data(offset));
                stream << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testb $0x2, 0x18(%rdi)
je 0x1fab3
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x1fab3
movl %edx, %r14d
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x1fd8e
testb %al, %al
je 0x1fab8
cmpl $-0x1, %r14d
je 0x1fad7
pushq $0x6d
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1fd46
movq 0x20(%rbx), %rdi
movl %r14d, %esi
callq 0x1ff0e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1fe64
movq 0x10(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc120
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x19381(%rip), %rdi     # 0x38e40
leaq 0x190ab(%rip), %rsi     # 0x38b71
leaq 0x1939e(%rip), %rcx     # 0x38e6b
movl $0x9a, %edx
callq 0xc180
leaq 0x13db7(%rip), %rdi     # 0x33895
leaq 0x1908c(%rip), %rsi     # 0x38b71
leaq 0x1937f(%rip), %rcx     # 0x38e6b
movl $0x9b, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::remove_clause(unsigned int)
void remove_clause(const container_offset_t offset) override {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(offset != CONTAINER_END);
                if (is_current_clause(nullptr, offset)) {
                    write_current_clause_action('x',  clauses_.back());
                    set_current_clause(clauses_.back(), CONTAINER_END);
                } else {
                    write_current_clause_action('x', p_cnf_->get_clause_data(offset));
                };
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testb $0x2, 0x18(%rdi)
je 0x1fb50
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x1fb50
movl %esi, %r14d
cmpl $-0x1, %esi
je 0x1fb73
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x1fd8e
testb %al, %al
je 0x1fb55
movq 0x30(%rbx), %rax
movq -0x8(%rax), %rdx
pushq $0x78
popq %rsi
movq %rbx, %rdi
callq 0x1fe94
movq 0x30(%rbx), %rax
movq -0x8(%rax), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1fdf6
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%rbx), %rdi
movl %r14d, %esi
callq 0x1ff0e
pushq $0x78
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x1fe94
leaq 0x13d1b(%rip), %rdi     # 0x33895
leaq 0x18ff0(%rip), %rsi     # 0x38b71
leaq 0x19394(%rip), %rcx     # 0x38f1c
movl $0xa4, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::set_current_clause(unsigned int const*, unsigned int)
inline void set_current_clause(const uint32_t* const p_clause, const container_offset_t offset) {
            _assert_level_0(!offsets_.empty() && !clauses_.empty());
            _assert_level_0(p_clause != nullptr || offset == CONTAINER_END);
            clauses_.back() = p_clause;
            offsets_.back() = offset;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
cmpq 0x48(%rdi), %rax
je 0x1fe2d
movq 0x30(%rdi), %rax
cmpq %rax, 0x28(%rdi)
je 0x1fe2d
testq %rsi, %rsi
setne %cl
cmpl $-0x1, %edx
sete %r8b
orb %cl, %r8b
je 0x1fe46
movq %rsi, -0x8(%rax)
movq 0x48(%rdi), %rax
movl %edx, -0x4(%rax)
popq %rbp
retq
leaq 0x18e9f(%rip), %rdi     # 0x38cd3
leaq 0x18d36(%rip), %rsi     # 0x38b71
leaq 0x18f16(%rip), %rcx     # 0x38d58
pushq $0x3d
jmp 0x1fe5d
leaq 0x18f6a(%rip), %rdi     # 0x38db7
leaq 0x18d1d(%rip), %rsi     # 0x38b71
leaq 0x18efd(%rip), %rcx     # 0x38d58
pushq $0x3e
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::write_current_clause_action(char, unsigned int const*)
inline void write_current_clause_action(const char action, const uint32_t* const p_clause) {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(p_clause != nullptr);
                write_action(action, 1);
                if (!is_current_clause(p_clause, CONTAINER_END)) {
                    write_clause(p_clause);
                };
                stream << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testb $0x2, 0x18(%rdi)
je 0x1feec
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x1feec
movq %rdx, %r14
testq %rdx, %rdx
je 0x1fef1
movsbl %sil, %esi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1fd46
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fd8e
testb %al, %al
jne 0x1fedf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fe64
movq 0x10(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc120
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18d25(%rip), %rdi     # 0x38c1d
leaq 0x18c72(%rip), %rsi     # 0x38b71
leaq 0x18ee0(%rip), %rcx     # 0x38de6
pushq $0x32
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnf.hpp
// Function: bal::Cnf::get_variable_value(unsigned int) const
literalid_t get_variable_value(const variableid_t variableid) const override {
            uint32_t unit_clause[_clause_size_memory_size(1)] = _clause_c1_make(variable_t__literal_id(variableid));
            insertion_point_t insertion_point;
            __insertion_point_t_init(insertion_point);
            find(unit_clause, insertion_point);
            if (insertion_point.container_offset != CONTAINER_END) {
                return (_clauses_offset_flags(this->data_, insertion_point.container_offset) == 1) ? LITERAL_CONST_0 : LITERAL_CONST_1;
            } else {
                return LITERALID_UNASSIGNED;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leal 0x3(%rsi,%rsi), %eax
leaq -0x18(%rbp), %rsi
movl $0x20001, (%rsi)        # imm = 0x20001
movl %eax, 0x4(%rsi)
leaq -0x28(%rbp), %r14
orl $-0x1, 0x4(%r14)
addq $0x78, %rdi
movq %r14, %rdx
callq 0xfccc
movl (%r14), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x2003f
movq 0x80(%rbx), %rcx
movzwl 0xe(%rcx,%rax,4), %ecx
shll $0x10, %ecx
xorl %eax, %eax
cmpl $0x10000, %ecx          # imm = 0x10000
setne %al
jmp 0x20042
pushq $-0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclausescontainer.hpp
// Function: bal::CnfClausesIndexedContainer<false>::rollback(unsigned int, unsigned int, unsigned int)
void rollback(const container_size_t size,
                      const container_size_t instances_size,
                      const container_size_t container_size) override {
            base_t::rollback(0, 0, container_size);
            this->instances_.append(CONTAINER_END, instances_size);
            container_offset_t container_offset = 0;
            while (container_offset < container_size) {
                uint32_t* const p_clause = _clauses_offset_clause(this->p_container_->data_, container_offset);
                _clause_include(p_clause);
                insertion_point_t insertion_point;
                this->find(p_clause, insertion_point);
                _assert_level_1(insertion_point.container_offset == CONTAINER_END);
                base_t::_update(container_offset, insertion_point);
                _clauses_offset_next(container_offset, p_clause);
                this->size_ = container_offset; // "commits" the clause
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %r12d
movq %rdi, %r14
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2027e
leaq 0x30(%r14), %rdi
pushq $-0x1
popq %rsi
movl %r12d, %edx
callq 0x10204
leaq -0x38(%rbp), %r12
cmpl %ebx, %r15d
jae 0x200dd
movq 0x28(%r14), %rax
movq (%rax), %rax
movl %r15d, %ecx
leaq (%rax,%rcx,4), %r13
addq $0xc, %r13
andl $0xffff7fff, (%r13)     # imm = 0xFFFF7FFF
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xfccc
cmpl $-0x1, -0x38(%rbp)
jne 0x200ec
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0xfcf8
movl (%r13), %eax
movl $0x7fff, %ecx           # imm = 0x7FFF
andl %ecx, %eax
addl %eax, %r15d
addl $0x4, %r15d
movl %r15d, 0x10(%r14)
jmp 0x20084
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13807(%rip), %rdi     # 0x338fa
leaq 0x131a3(%rip), %rsi     # 0x3329d
leaq 0x192a4(%rip), %rcx     # 0x393a5
pushq $0x69
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/binarytreeindex.hpp
// Function: bal::AvlTreesIndex<unsigned int, true, &int bal::compare_clauses<false>(unsigned int const*, unsigned int const*), &unsigned int bal::clause_index_variable_id<false>(unsigned int const*)>::insertion_point_is_valid(bal::avl_tree_insertion_point_t const&) const
bool insertion_point_is_valid(const insertion_point_t& insertion_point) const override {
            bool result = base_t::insertion_point_is_valid(insertion_point);
            if (!result && insertion_point.version_stamp != CONTAINER_END && insertion_point.kind == btipkCurrent) {
                _assert_level_0(insertion_point.offset < this->size_);
                const CONTAINER_DATA_T* const p_item = _bti_item(this->data_, insertion_point.offset);
                if (_bti_item_parent_offset(p_item) != CONTAINER_END) {
                    const CONTAINER_DATA_T* const p_parent = _bti_item(this->data_, _bti_item_parent_offset(p_item));
                    result = (_bti_item_left_offset(p_parent) == insertion_point.offset) ||
                                (_bti_item_right_offset(p_parent) == insertion_point.offset);
                } else if _bti_item_parent_offset(p_item) {
                    const container_offset_t instance_offset = instance_determiner(_bti_item_container_item(p_item));
                    _assert_level_0(instance_offset < this->instances_.size_);
                    result = this->instances_.data_[instance_offset] == insertion_point.offset;
                };
            };
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x5c(%rdi), %ecx
movl 0x4(%rsi), %edx
cmpl %ecx, %edx
sete %al
cmpl $-0x1, %edx
je 0x2017d
cmpl %ecx, %edx
je 0x2017d
cmpl $0x3, 0x8(%rsi)
jne 0x2017d
movl 0xc(%rsi), %ecx
cmpl 0x10(%rdi), %ecx
jae 0x2017f
movq 0x8(%rdi), %rdx
movl (%rdx,%rcx,4), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rsi
je 0x20153
movb $0x1, %al
cmpl %ecx, 0x8(%rdx,%rsi,4)
je 0x2017d
leaq (%rdx,%rsi,4), %rax
addq $0x4, %rax
jmp 0x20178
leaq (%rdx,%rcx,4), %rax
movl $0x7fff, %edx           # imm = 0x7FFF
andl 0xc(%rax), %edx
decl %edx
movl 0x10(%rax,%rdx,4), %eax
shrl %eax
decl %eax
cmpl 0x38(%rdi), %eax
jae 0x2019e
movl %eax, %eax
shlq $0x2, %rax
addq 0x30(%rdi), %rax
cmpl %ecx, (%rax)
sete %al
popq %rbp
retq
leaq 0x137a6(%rip), %rdi     # 0x3392c
leaq 0x135a0(%rip), %rsi     # 0x3372d
leaq 0x192b4(%rip), %rcx     # 0x39448
movl $0x1d4, %edx            # imm = 0x1D4
callq 0xc180
leaq 0x13b7c(%rip), %rdi     # 0x33d21
leaq 0x13581(%rip), %rsi     # 0x3372d
leaq 0x19295(%rip), %rcx     # 0x39448
movl $0x1dc, %edx            # imm = 0x1DC
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<unsigned int, unsigned int, bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>, bal::avl_tree_insertion_point_t>::rollback(unsigned int, unsigned int, unsigned int)
virtual void rollback(const container_size_t size,
                              const container_size_t instances_size,
                              const container_size_t container_size) {
            assert(size != CONTAINER_END && this->size_ >= size);
            assert(instances_.size_ >= instances_size);
            this->size_ = size;
            instances_.size_ = instances_size;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, %esi
je 0x20299
cmpl %esi, 0x10(%rdi)
jb 0x20299
cmpl %edx, 0x38(%rdi)
jb 0x202b2
movl %esi, 0x10(%rdi)
movl %edx, 0x38(%rdi)
popq %rbp
retq
leaq 0x18eb7(%rip), %rdi     # 0x39157
leaq 0x1373d(%rip), %rsi     # 0x339e4
leaq 0x18ed6(%rip), %rcx     # 0x39184
pushq $0x3f
jmp 0x202c9
leaq 0x190c9(%rip), %rdi     # 0x39382
leaq 0x13724(%rip), %rsi     # 0x339e4
leaq 0x18ebd(%rip), %rcx     # 0x39184
pushq $0x40
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>::is_constant() const
bool is_constant() const override {
            for (auto i = 0; i < N_; i++) {
                if (bits_[i] == nullptr || !bits_[i]->is_constant()) {
                    return false;
                };
            };
            return true;
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x20b1c
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
cmpq $0x1f, %r13
je 0x20ae3
xorl %eax, %eax
btl %r13d, %r14d
setb %al
movl %eax, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x20b3a
incq %r13
addq $0x8, %r15
jmp 0x20abd
addq $0x128, %rbx            # imm = 0x128
xorl %r15d, %r15d
leaq -0x2c(%rbp), %r14
cmpq $0x8, %r15
je 0x20b0d
andl $0x0, -0x2c(%rbp)
leaq (%rbx,%r15), %rdi
movq %r14, %rsi
callq 0x20b60
addq $0x8, %r15
jmp 0x20af1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x190aa(%rip), %rdi     # 0x39bcd
leaq 0x190ae(%rip), %rsi     # 0x39bd8
leaq 0x190bf(%rip), %rcx     # 0x39bf0
pushq $0x35
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Literal<bal::Cnf>* bal::Literal<bal::Cnf>::static_assign<unsigned int, 0>(bal::Literal<bal::Cnf>*, unsigned int const&)
static Literal* static_assign(Literal* instance, const value_t& value) {
            if (value == LITERALID_UNASSIGNED) {
                return unassigned_;
            } else {
                return GF2Element<Literal<FORMULA_T>>::static_assign(instance, value);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, (%rsi)
je 0x20b95
popq %rbp
jmp 0x20be0
movq 0x30794(%rip), %rax     # 0x51330
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: int bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>::assign_to<int, 0>() const
T assign_to() const {
            T value = 0;
            constexpr T T_MAX_SIZE = size_in_bits_(std::numeric_limits<T>::max());
            if (T_MAX_SIZE < N_) {
                // assigning to a shorter type
                auto i = 0;
                T max_i = std::numeric_limits<T>::max();
                while (max_i > 0) {
                    if ((bool)bits_[i]) {
                        value |= 0b1 << i;
                    };
                    max_i >>= 1;
                    i++;
                };
                while (i < N_) {
                    _assert_level_0((bool)bits_[i] == false);
                    i++;
                };
            } else {
                // assigning to a longer type or a same sized type
                for (auto i = 0; i < N_; i++) {
                    if ((bool)bits_[i]) {
                        value |= 0b1 << i;
                    };
                };
            };
            return value;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x1
popq %r13
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq $0x1f, %r15
je 0x20ca9
movq 0x30(%rbx,%r15,8), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %r13d, %edx
movl %r15d, %ecx
shll %cl, %edx
testb %al, %al
cmovel %r12d, %edx
orl %edx, %r14d
incq %r15
jmp 0x20c82
xorl %r15d, %r15d
cmpq $0x1, %r15
je 0x20ce4
movq 0x128(%rbx,%r15,8), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
testb %al, %al
je 0x20cac
leaq 0x190db(%rip), %rdi     # 0x39da9
leaq 0x18f03(%rip), %rsi     # 0x39bd8
leaq 0x190e5(%rip), %rcx     # 0x39dc1
pushq $0x66
popq %rdx
callq 0xc180
movl %r14d, %eax
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/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamWriter::write(bal::Cnf const&)
void write(const Cnf& value) override {
            write_parameters(value);
            write_variables(value);
            write_header(value);
            write_clauses(value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2188a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21916
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamWriter::write_parameters(bal::Cnf const&)
virtual void write_parameters(const Cnf& value) {
            const formula_parameters_t parameters = value.get_parameters();
            for (auto it = parameters.begin(); it != parameters.end(); it++) {
                if (it->first.compare("writer") != 0) {
                    write_parameter(it->first, it->second);
                };
            };
            if (!value.is_empty()) {
                std::string writer_parameters = "is_sorted: 1, literals_order: \"ascending\", literals_compare_order: ";
                writer_parameters += (value.is_compare_left_right() ? "\"left-right\"" : "\"right-left\"");
                write_parameter("writer", writer_parameters);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq %rsi, -0x38(%rbp)
movq %rsi, %rdi
callq 0x2e464
leaq -0xa8(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x215a4
movq 0x18(%r15), %r12
leaq -0xa0(%rbp), %r14
leaq 0x18e4d(%rip), %r15     # 0x3a228
cmpq %r14, %r12
je 0x21411
leaq 0x20(%r12), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xc0c0
testl %eax, %eax
je 0x21404
leaq 0x40(%r12), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21546
movq %r12, %rdi
callq 0xc2e0
movq %rax, %r12
jmp 0x213db
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb %al, %al
jne 0x21479
leaq 0x18e09(%rip), %rsi     # 0x3a22f
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0xc0e0
leaq 0x18e39(%rip), %rsi     # 0x3a273
leaq -0x78(%rbp), %rdi
callq 0xc4f0
leaq 0x18dde(%rip), %rsi     # 0x3a228
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0xc0e0
leaq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdx
movq %rbx, %rdi
callq 0x21546
leaq -0x58(%rbp), %rdi
callq 0xc110
leaq -0x78(%rbp), %rdi
callq 0xc110
leaq -0xa8(%rbp), %rdi
callq 0x1f574
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc110
jmp 0x214aa
jmp 0x214a7
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xc110
jmp 0x214bc
jmp 0x214b9
jmp 0x214b9
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x1f574
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::CnfVigStreamWriter<false, false>::write(bal::Cnf const&)
void write(const Cnf& value) override {
            edges_data_t edges;
            unsigned next_edge_id = 0;
            compute_edges(value, TIMESTAMP_MIN, edges, next_edge_id);
            
            write_header(value);
            write_nodes(value, edges);
            write_edges(value, edges);
            write_footer(value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq -0x14(%rbp), %r8
andl $0x0, (%r8)
movq (%rdi), %rax
leaq -0x48(%rbp), %rcx
xorl %edx, %edx
callq *0x38(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq (%r14), %rax
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r14), %rax
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq -0x48(%rbp), %rdi
callq 0x223b6
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x223b6
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfgraphml.hpp
// Function: bal::CnfGraphMLStreamWriter<true>::write_header(bal::Cnf const&)
void write_header(const Cnf& value) override {
            stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
            stream << "<graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd\">" << std::endl;
            stream << "<graph id=\"CNF\" edgedefault=\"undirected\">" << std::endl;
            stream << "<key id=\"n_variable_name\" for=\"node\" attr.name=\"variable_name\" attr.type=\"string\"/>" << std::endl;
            stream << "<key id=\"n_variable_index\" for=\"node\" attr.name=\"variable_index\" attr.type=\"int\"/>" << std::endl;
            stream << "<key id=\"n_variable_id\" for=\"node\" attr.name=\"variable_id\" attr.type=\"int\"/>" << std::endl;
            stream << "<key id=\"n_label\" for=\"node\" attr.name=\"label\" attr.type=\"string\"/>" << std::endl;
            
            if (WEIGHTED) {
                stream << "<key id=\"e_cardinality\" for=\"edge\" attr.name=\"cardinality\" attr.type=\"int\"/>" << std::endl;
                stream << "<key id=\"e_weight\" for=\"edge\" attr.name=\"weight\" attr.type=\"double\"/>" << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x17de5(%rip), %rsi     # 0x3a2a1
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x17df4(%rip), %rsi     # 0x3a2c8
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x17ebb(%rip), %rsi     # 0x3a3a7
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x17ecd(%rip), %rsi     # 0x3a3d1
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x17f09(%rip), %rsi     # 0x3a425
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x17f44(%rip), %rsi     # 0x3a478
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x17f79(%rip), %rsi     # 0x3a4c5
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x18054(%rip), %rsi     # 0x3a5b8
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x18089(%rip), %rsi     # 0x3a605
callq 0xc290
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc120
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfgraphml.hpp
// Function: bal::CnfGraphMLStreamWriter<false>::write_node(unsigned int, char const*, unsigned int, unsigned int, unsigned int)
void write_node(const variableid_t id, const char* const name,
                        const unsigned index, const unsigned element_size, const timestamp_t end) override {
            stream << std::dec;
            stream << "<node id=\"v"  << literal_t(variable_t__literal_id(id)) << "\">" << std::endl;
            stream << "<data key=\"n_variable_id\">" << literal_t(variable_t__literal_id(id)) << "</data>" << std::endl;
            if (name != nullptr) {
                stream << "<data key=\"n_variable_name\">" << name << "</data>" << std::endl;
                stream << "<data key=\"n_variable_index\">" << index << "</data>" << std::endl;
                stream << "<data key=\"n_label\">" << node_label(name, index, element_size) << "</data>" << std::endl;
            };
            stream << "</node>" << std::endl;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, -0x2c(%rbp)
movl %ecx, %r15d
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rdi,%rax)
leaq 0x189ba(%rip), %rsi     # 0x3a51d
callq 0xc290
leal 0x3(,%r13,2), %r14d
leaq -0x50(%rbp), %r13
movl %r14d, (%r13)
movq %rax, %rdi
movq %r13, %rsi
callq 0xeb12
leaq 0x18c25(%rip), %rsi     # 0x3a7af
movq %rax, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x18984(%rip), %rsi     # 0x3a529
callq 0xc290
movl %r14d, (%r13)
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xeb12
leaq 0x166c7(%rip), %rsi     # 0x38288
movq %rax, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
testq %r12, %r12
je 0x21c95
movq 0x10(%rbx), %rdi
leaq 0x1895f(%rip), %rsi     # 0x3a544
callq 0xc290
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
leaq 0x1668c(%rip), %r13     # 0x38288
movq %rax, %rdi
movq %r13, %rsi
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x18947(%rip), %rsi     # 0x3a561
callq 0xc290
movl %r15d, %esi
movq %rax, %rdi
callq 0xc190
movq %rax, %rdi
movq %r13, %rsi
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
leaq 0x18937(%rip), %rsi     # 0x3a57f
callq 0xc290
movq %rax, %r13
movq (%rbx), %rax
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %r15d, %ecx
movl -0x2c(%rbp), %r8d
callq *0x28(%rax)
movq %r13, %rdi
movq %r14, %rsi
callq 0xc230
leaq 0x1660c(%rip), %rsi     # 0x38288
movq %rax, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
leaq -0x50(%rbp), %rdi
callq 0xc110
movq 0x10(%rbx), %rdi
leaq 0x188f4(%rip), %rsi     # 0x3a594
callq 0xc290
movq %rax, %rdi
callq 0xc120
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfgraphml.hpp
// Function: bal::CnfGraphMLStreamWriter<true>::write_edge(unsigned int, unsigned int, bal::CnfVigStreamWriter<true, false>::__edge_data_t const&)
void write_edge(const variableid_t source_id, const variableid_t target_id, const edge_data_t& edge) override {
            if (WEIGHTED) {
                stream << "<edge source=\"v" << literal_t(variable_t__literal_id(source_id)) << "\" target=\"v" << literal_t(variable_t__literal_id(target_id)) << "\">" << std::endl;
                CnfGraphMLStreamWriter_write_edge_weighted<WEIGHTED>(stream, edge);
                stream << "</edge>" << std::endl;
            } else {
                stream << "<edge source=\"v" << literal_t(variable_t__literal_id(source_id)) << "\" target=\"v" << literal_t(variable_t__literal_id(target_id)) << "\"/>" << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x17df8(%rip), %rsi     # 0x3a59c
callq 0xc290
leal 0x3(,%r12,2), %ecx
leaq -0x28(%rbp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xeb12
leaq 0x17de6(%rip), %rsi     # 0x3a5ac
movq %rax, %rdi
callq 0xc290
leal 0x3(,%r15,2), %ecx
leaq -0x24(%rbp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xeb12
leaq 0x17fc4(%rip), %rsi     # 0x3a7af
movq %rax, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xc120
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x19de6
movq 0x10(%rbx), %rdi
leaq 0x15a43(%rip), %rsi     # 0x38255
callq 0xc290
movq %rax, %rdi
callq 0xc120
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::CnfVigStreamWriter<false, false>::node_label[abi:cxx11](char const*, unsigned int, unsigned int) const
virtual const std::string node_label(const char* const name, const unsigned index, const unsigned element_size) const {
            std::string label;
            if (name != nullptr) {
                label = name;
                if (element_size == 1) {
                    label += "[" + std::to_string(index) + "]";
                } else {
                    label += "[" + std::to_string(index / element_size) + "]";
                    label += "[" + std::to_string(element_size - index % element_size - 1) + "]";
                };
            };
            return label;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x21e95
movl %r8d, %r14d
movl %ecx, %r15d
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xc500
cmpl $0x1, %r14d
jne 0x21dcf
leaq -0x38(%rbp), %rdi
movl %r15d, %esi
callq 0x188f9
leaq 0x16757(%rip), %rsi     # 0x384f4
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x1c480
leaq 0x1331e(%rip), %rdx     # 0x350cf
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d816
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0xc510
jmp 0x21e7a
movl %r15d, %eax
xorl %edx, %edx
divl %r14d
movl %edx, %r15d
leaq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x188f9
leaq 0x16708(%rip), %rsi     # 0x384f4
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x1c480
leaq 0x132cf(%rip), %rdx     # 0x350cf
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d816
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0xc510
leaq -0x78(%rbp), %rdi
callq 0xc110
leaq -0x58(%rbp), %rdi
callq 0xc110
leaq -0x38(%rbp), %rdi
callq 0xc110
notl %r15d
addl %r14d, %r15d
leaq -0x38(%rbp), %rdi
movl %r15d, %esi
callq 0x188f9
leaq 0x166a7(%rip), %rsi     # 0x384f4
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x1c480
leaq 0x1326e(%rip), %rdx     # 0x350cf
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d816
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0xc510
leaq -0x78(%rbp), %rdi
callq 0xc110
leaq -0x58(%rbp), %rdi
callq 0xc110
leaq -0x38(%rbp), %rdi
callq 0xc110
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21ead
jmp 0x21ebd
jmp 0x21ecd
jmp 0x21edf
jmp 0x21ead
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0xc110
jmp 0x21ec0
jmp 0x21ebd
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0xc110
jmp 0x21ed0
jmp 0x21ecd
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0xc110
jmp 0x21ee2
jmp 0x21edf
jmp 0x21edf
movq %rax, %r14
movq %rbx, %rdi
callq 0xc110
movq %r14, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::edge_weight_data_t<true>::update(unsigned int, bal::edge_action_t, unsigned int)
void update(const uint32_t clause_header, const edge_action_t action, const timestamp_t timestamp) {
            const clause_size_t clause_size = _clause_header_size(clause_header);
            const unsigned clause_cardinality = clause_size < 4 ?
                get_cardinality_uint16(_clause_header_flags(clause_header)) : 1;
            const double clause_weight = 2.0 * clause_cardinality / clause_size / (clause_size - 1);
            
            switch(action) {
                case eaInsert:
                case eaUpdate:
                    cardinality += clause_cardinality;
                    weight += clause_weight;
                    break;
                case eaRemove:
                    _assert_level_0(cardinality >= clause_cardinality);
                    cardinality -= clause_cardinality;
                    weight -= clause_weight;
                    break;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movl %esi, %r15d
andl $0x7fff, %r15d          # imm = 0x7FFF
cmpl $0x3, %r15d
ja 0x22da3
shrl $0x10, %esi
movl %esi, %edi
callq 0x1533e
movzwl %ax, %eax
jmp 0x22da6
pushq $0x1
popq %rax
leal (%rax,%rax), %ecx
cvtsi2sd %ecx, %xmm0
cvtsi2sd %r15d, %xmm1
divsd %xmm1, %xmm0
decl %r15d
cvtsi2sd %r15d, %xmm1
divsd %xmm1, %xmm0
cmpl $0x2, %r14d
jae 0x22dd6
addl %eax, (%rbx)
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0x22dee
jne 0x22dee
movl (%rbx), %ecx
subl %eax, %ecx
jb 0x22df9
movl %ecx, (%rbx)
movsd 0x8(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1784b(%rip), %rdi     # 0x3a64b
leaq 0x17866(%rip), %rsi     # 0x3a66d
leaq 0x17877(%rip), %rcx     # 0x3a685
pushq $0x50
popq %rdx
callq 0xc180