LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::evaluate_clauses()
inline processor_result_t CnfOptimizer::evaluate_clauses() {
        evaluations_ = 0;
        evaluations_aggregated_ = 0;
        variables_assigned_ = 0;
        
        const processor_result_t result = process_clauses<CnfOptimizer, &CnfOptimizer::process_clause_evaluate>(this);
        
        std::cout << "Evaluation: " << std::dec << evaluations_ << "/" << evaluations_aggregated_ << " cls, size: ";
        std::cout << cnf_.clauses_size() << "/" << cnf_.clauses_size<0, true>() << " cls, ";
        std::cout << (cnf_.memory_size() >> 10) << "/";
        std::cout << (clauses_index_.memory_size() >> 10) << " Kb";
        std::cout << std::endl;
        
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rdi)
andq $0x0, 0xd0(%rdi)
movq %rdi, %rsi
callq 0x125b0
movl %eax, %ebx
movq 0x40552(%rip), %r14     # 0x50fb0
leaq 0x23e22(%rip), %rsi     # 0x34887
movq %r14, %rdi
callq 0xc290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0xc0(%r15), %rsi
movq %rax, %rdi
callq 0xc190
leaq 0x212c6(%rip), %r12     # 0x31d5e
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
movq 0xc8(%r15), %rsi
movq %rax, %rdi
callq 0xc190
leaq 0x23ddb(%rip), %rsi     # 0x34894
movq %rax, %rdi
callq 0xc290
movq 0x8(%r15), %rdi
addq $0x78, %rdi
callq 0x107d8
movl %eax, %esi
movq %r14, %rdi
callq 0xc190
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
movq %rax, %r13
movq 0x8(%r15), %rdi
addq $0x78, %rdi
callq 0x12690
movl %eax, %esi
movq %r13, %rdi
callq 0xc190
leaq 0x23d9d(%rip), %rsi     # 0x348a1
movq %rax, %rdi
callq 0xc290
movq 0x8(%r15), %rdi
movq 0x78(%rdi), %rax
addq $0x78, %rdi
callq *0x10(%rax)
shrq $0xa, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0xc190
movq %rax, %rdi
movq %r12, %rsi
callq 0xc290
movl 0x40(%r15), %eax
movl 0x68(%r15), %ecx
shlq $0x3, %rax
movl 0x98(%r15), %edx
addq %rcx, %rdx
leaq (%rax,%rdx,4), %rsi
shrq $0xa, %rsi
movq %r14, %rdi
callq 0xc190
leaq 0x23d46(%rip), %rsi     # 0x348a8
movq %rax, %rdi
callq 0xc290
movq %r14, %rdi
callq 0xc120
movl %ebx, %eax
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/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>::transaction_rollback()
inline void transaction_rollback() {
            _assert_level_1(transaction_is_in() && this->size_ >= transaction_size_);
            rollback(transaction_size_, transaction_instances_size_, transaction_container_size_);
            transaction_size_ = CONTAINER_END;
            transaction_container_size_ = CONTAINER_END;
            transaction_instances_size_ = CONTAINER_END;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x50(%rdi), %esi
cmpl $-0x1, %esi
je 0x10bb8
movq %rdi, %rbx
cmpl %esi, 0x10(%rdi)
jb 0x10bb8
movl 0x58(%rbx), %edx
movl 0x54(%rbx), %ecx
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
orq $-0x1, 0x50(%rbx)
orl $-0x1, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x25d01(%rip), %rdi     # 0x368c0
leaq 0x22e1e(%rip), %rsi     # 0x339e4
leaq 0x25d2b(%rip), %rcx     # 0x368f8
pushq $0x71
popq %rdx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::_normalize_clause(unsigned int*) const
inline bool CnfOptimizer::_normalize_clause(uint32_t* const p_clause) const {
        processor_result_t result = erUndetermined;
        const clause_size_t clause_size = _clause_size(p_clause);
        
        if (_clause_size_is_aggregated(clause_size)) {
            result = normalize_ca(p_clause, p_clause);
        } else {
            result = normalize_cu(p_clause, p_clause);
        };
        _assert_level_1(result != erConflict);
        _assert_level_1(result == erSatisfied || _clause_size(p_clause) > 0);
        return (result != erSatisfied);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0x7fff, %eax           # imm = 0x7FFF
andl (%rsi), %eax
movq %rsi, %rdx
cmpl $0x4, %eax
ja 0x1153d
callq 0x11624
jmp 0x11542
callq 0x117e6
cmpl $0x3, %eax
je 0x11556
cmpl $0x4, %eax
je 0x11563
movzwl (%rbx), %ecx
testw $0x7fff, %cx            # imm = 0x7FFF
je 0x11582
cmpl $0x3, %eax
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x22e02(%rip), %rdi     # 0x3436c
leaq 0x22897(%rip), %rsi     # 0x33e08
leaq 0x22e09(%rip), %rcx     # 0x34381
movl $0x472, %edx            # imm = 0x472
callq 0xc180
leaq 0x22e39(%rip), %rdi     # 0x343c2
leaq 0x22878(%rip), %rsi     # 0x33e08
leaq 0x22dea(%rip), %rcx     # 0x34381
movl $0x473, %edx            # imm = 0x473
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndexIterator<bal::CnfClausesIndexedContainer<false>>::ContainerIndexIterator(bal::CnfClausesIndexedContainer<false> const&, bool)
ContainerIndexIterator(const INDEX_T& index, const bool b_begin): index_(index), instance_iterator_(index) {
            if (b_begin) {
                instance_offset_ = 0;
                load_instance();
            } else {
                instance_offset_ = index_.instances_.size_;
                container_offset_ = CONTAINER_END;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
orq $-0x1, 0x10(%rdi)
testl %edx, %edx
je 0x11f04
andl $0x0, 0x18(%rdi)
popq %rbp
jmp 0x11f10
movl 0x38(%rsi), %eax
movl %eax, 0x18(%rdi)
orl $-0x1, 0x1c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndexIterator<bal::CnfClausesIndexedContainer<false>>::load_instance()
inline void load_instance() {
            // move to the next instance which has items
            while (instance_offset_ < index_.instances_.size_ &&
                   index_.instances_.data_[instance_offset_] == CONTAINER_END) {
                instance_offset_++;
            };
            if (instance_offset_ < index_.instances_.size_) {
                container_offset_ = instance_iterator_.first(instance_offset_);
            } else {
                container_offset_ = CONTAINER_END;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movl 0x38(%rcx), %edx
movl 0x18(%rdi), %esi
pushq $-0x1
popq %rax
cmpq %rdx, %rsi
jae 0x11f45
movq 0x30(%rcx), %rdi
cmpl $-0x1, (%rdi,%rsi,4)
jne 0x11f3c
incq %rsi
movl %esi, 0x18(%rbx)
jmp 0x11f25
leaq 0x8(%rbx), %rdi
callq 0x11f50
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/binarytreeindex.hpp
// Function: bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>::first(unsigned int)
inline container_offset_t first(const container_offset_t instance_offset) {
            instance_offset_ = instance_offset;
            item_offset_ = instance_offset >= index_.instances_.size_ ? CONTAINER_END : index_.instances_.data_[instance_offset];
            // start from the deepest leftmost leaf node
            if (item_offset_ != CONTAINER_END) {
                while (_bti_left_offset(index_.data_, item_offset_) != CONTAINER_END) {
                    item_offset_ = _bti_left_offset(index_.data_, item_offset_);
                };
            };
            return item_offset_ == CONTAINER_END ? CONTAINER_END : _bti_container_offset(index_.data_, item_offset_);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, 0x8(%rdi)
movq (%rdi), %rax
cmpl %esi, 0x38(%rax)
jbe 0x11f86
movq 0x30(%rax), %rcx
movl %esi, %edx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0xc(%rdi)
cmpl $-0x1, %ecx
je 0x11f8a
movq 0x8(%rax), %rdx
movl %ecx, %eax
movl %ecx, %ecx
movl 0x8(%rdx,%rcx,4), %ecx
cmpl $-0x1, %ecx
je 0x11f8f
movl %ecx, 0xc(%rdi)
jmp 0x11f74
orl $-0x1, 0xc(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndexIterator<bal::CnfClausesIndexedContainer<false>>::next_item()
inline void next_item() {
            if (index_.instances_.size_ > 0) {
                container_offset_ = instance_iterator_.next();
                if (container_offset_ == CONTAINER_END) {
                    instance_offset_++;
                    load_instance();
                };
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpl $0x0, 0x38(%rax)
je 0x11fc3
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x11fdc
movl %eax, 0x1c(%rbx)
cmpl $-0x1, %eax
je 0x11fca
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
incl 0x18(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f10
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/binarytreeindex.hpp
// Function: bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>::next()
inline container_offset_t next() {
            if (item_offset_ != CONTAINER_END) {
                if (_bti_right_offset(index_.data_, item_offset_) != CONTAINER_END) {
                    // there is a right element - move one right then the deepest leftmost element
                    item_offset_ = _bti_right_offset(index_.data_, item_offset_);
                    while (item_offset_ != CONTAINER_END && _bti_left_offset(index_.data_, item_offset_) != CONTAINER_END) {
                        item_offset_ = _bti_left_offset(index_.data_, item_offset_);
                    };
                } else {
                    // no right element, move up as long as we come from right
                    // if coming from right and reached the root - its the end
                    while (item_offset_ != CONTAINER_END) {
                        container_offset_t parent_offset = _bti_parent_offset(index_.data_, item_offset_);
                        if (parent_offset != CONTAINER_END && _bti_right_offset(index_.data_, parent_offset) == item_offset_) {
                            item_offset_ = parent_offset;
                        } else {
                            item_offset_ = parent_offset;
                            break;
                        };
                    };
                };
            };
            return item_offset_ == CONTAINER_END ? CONTAINER_END : _bti_container_offset(index_.data_, item_offset_);
        }

// Assembly:
movl 0xc(%rdi), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rdx
je 0x1200f
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rax), %rcx
movl 0x4(%rcx,%rdx,4), %esi
cmpl $-0x1, %esi
je 0x12015
movl %esi, %eax
movl %esi, 0xc(%rdi)
movl %esi, %edx
movl 0x8(%rcx,%rdx,4), %esi
cmpl $-0x1, %esi
jne 0x11ffd
jmp 0x12034
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %edx, %eax
movl (%rcx,%rax,4), %eax
cmpq %rsi, %rax
je 0x12031
cmpl %edx, 0x4(%rcx,%rax,4)
jne 0x12031
movl %eax, 0xc(%rdi)
movl %eax, %edx
jmp 0x1201a
movl %eax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<bal::list_index_item_t, unsigned int, bal::LinkedListsIndexInstanceOffsetIterator<unsigned int>, bal::list_index_insertion_point_t>::reset(unsigned int, unsigned int)
virtual void reset(const container_size_t instances_size, const container_size_t index_size) {
            _assert_level_1(!transaction_is_in());
            instances_.reset(instances_size);
            instances_.append(CONTAINER_END, instances_size);
            Container<INDEX_DATA_T>::reset(index_size);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $-0x1, 0x50(%rdi)
jne 0x124e3
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leaq 0x30(%rdi), %r12
movq %r12, %rdi
callq 0xe0b8
pushq $-0x1
popq %rsi
movq %r12, %rdi
movl %r15d, %edx
callq 0x10204
addq $0x8, %r14
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12500
leaq 0x22171(%rip), %rdi     # 0x3465b
leaq 0x214f3(%rip), %rsi     # 0x339e4
leaq 0x22178(%rip), %rcx     # 0x34670
pushq $0x5c
popq %rdx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfprocessor.hpp
// Function: bal::processor_result_t bal::CnfProcessor::process_clauses<bal::CnfOptimizer, &bal::CnfOptimizer::process_clause_evaluate(unsigned int*)>(bal::CnfOptimizer*)
inline processor_result_t process_clauses(CALLER_T* const p_caller) {
            clauses_index_.reset(0, 0);
            processor_result_t result = erUndetermined;
            
            uint32_t offset = 0;
            while (offset < cnf_.size_) {
                uint32_t* p_clause = _clauses_offset_clause(clauses_data_, offset);
                // p_clause size may change
                const clause_size_t clause_size = _clause_size(p_clause);
                
                // the clause may be excluded during processing of the preceding ones
                if (_clause_is_included(p_clause)) {
                    processed_offset_ = offset;
                    if ((p_caller->*p_process_clause)(p_clause) == erConflict) {
                        result = erConflict;
                        break;
                    } else {
                        // the pointer may become invalid
                        p_clause = _clauses_offset_clause(clauses_data_, offset);
                        if (_clause_is_included(p_clause)) {
                            // append processed clause to the index if included
                            for (auto i = 0; i < _clause_size(p_clause); i++) {
                                clauses_index_.append(literal_t__variable_id(_clause_literal(p_clause, i)), offset);
                            };
                        };
                    };
                };
                
                _clauses_offset_size_next(offset, clause_size);
            };
            
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
leaq 0x30(%rdi), %r12
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x114ee
xorl %r13d, %r13d
movq %rbx, -0x30(%rbp)
movq 0x8(%rbx), %rax
cmpl 0x88(%rax), %r13d
jae 0x1267a
movq 0x18(%rbx), %rax
movq (%rax), %rax
movl %r13d, %r14d
movl 0xc(%rax,%r14,4), %ebx
testw %bx, %bx
js 0x12664
leaq (%rax,%r14,4), %rsi
addq $0xc, %rsi
movq -0x30(%rbp), %r15
movl %r13d, 0xb0(%r15)
movq -0x38(%rbp), %rdi
callq 0x126ec
cmpl $0x4, %eax
je 0x1267e
movq 0x18(%r15), %rax
movq (%rax), %rcx
movl 0xc(%rcx,%r14,4), %eax
testw %ax, %ax
js 0x12664
leaq (%rcx,%r14,4), %r14
xorl %r15d, %r15d
andl $0x7fff, %eax           # imm = 0x7FFF
cmpq %rax, %r15
jae 0x12664
movl 0x10(%r14,%r15,4), %esi
shrl %esi
decl %esi
movq %r12, %rdi
movl %r13d, %edx
callq 0x12840
incq %r15
movl 0xc(%r14), %eax
jmp 0x1263d
andl $0x7fff, %ebx           # imm = 0x7FFF
addl %ebx, %r13d
addl $0x4, %r13d
movq -0x30(%rbp), %rbx
jmp 0x125df
xorl %eax, %eax
jmp 0x12681
pushq $0x4
popq %rax
addq $0x18, %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/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::process_clause_evaluate(unsigned int*)
inline processor_result_t CnfOptimizer::process_clause_evaluate(uint32_t* const p_clause) {
        
        if ((evaluations_ & 0x3FFF) == 0) {
             std::cout << "s:" << std::dec << std::setfill(' ') << std::setw(8) << (clauses_size_ >> 10) << " Kb d: " << std::setw(8) << ((clauses_size_ - processed_offset_) >> 10) << "Kb v: " << std::setw(8) << variables_assigned_ << std::flush << "\r";
        };
        
        _assert_level_3(p_clause == _clauses_offset_clause(clauses_data_, processed_offset_));
        const processor_result_t result = evaluate_clause(processed_offset_);
        if (result == erConflict) {
            __print_conflict(variables_.data(), p_clause);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0xc0(%rdi), %eax
testw $0x3fff, %ax            # imm = 0x3FFF
jne 0x127d5
movq 0x3e89c(%rip), %rdi     # 0x50fb0
leaq 0x22191(%rip), %rsi     # 0x348ac
callq 0xc290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0xc400
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
pushq $0x8
popq %r15
movq %r15, 0x10(%rax,%rcx)
movq 0x20(%r14), %rcx
movl (%rcx), %esi
shrl $0xa, %esi
movq %rax, %rdi
callq 0xc190
leaq 0x22147(%rip), %rsi     # 0x348af
movq %rax, %rdi
callq 0xc290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
movq 0x20(%r14), %rcx
movl (%rcx), %esi
subl 0xb0(%r14), %esi
shrl $0xa, %esi
movq %rax, %rdi
callq 0xc190
leaq 0x2211c(%rip), %rsi     # 0x348b7
movq %rax, %rdi
callq 0xc290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r15, 0x10(%rax,%rcx)
movq 0xd0(%r14), %rsi
movq %rax, %rdi
callq 0xc190
movq %rax, %rdi
callq 0xc1a0
leaq 0x220f1(%rip), %rsi     # 0x348be
movq %rax, %rdi
callq 0xc290
movq 0x18(%r14), %rax
movq (%rax), %rax
movl 0xb0(%r14), %esi
leaq (%rax,%rsi,4), %rax
addq $0xc, %rax
cmpq %rbx, %rax
jne 0x12820
movq %r14, %rdi
callq 0x1292a
movl %eax, %r15d
cmpl $0x4, %eax
jne 0x12812
movq 0xb8(%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xe8cf
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22099(%rip), %rdi     # 0x348c0
leaq 0x215da(%rip), %rsi     # 0x33e08
leaq 0x220c7(%rip), %rcx     # 0x348fc
movl $0x84, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/linkedlistindex.hpp
// Function: bal::SimpleLinkedListsIndex<unsigned int>::append(unsigned int, unsigned int)
inline void append(const container_size_t instance_offset, const container_size_t container_offset) {
            if (instance_offset >= this->instances_.size_) {
                this->instances_.append(CONTAINER_END, instance_offset - this->instances_.size_ + 1);
                this->instances_last_.append(CONTAINER_END, instance_offset - instances_last_.size_ + 1);
            };
            
            this->reserve(1); // size_ is the valid offset for the new item
            this->data_[this->size_] = { CONTAINER_END, container_offset };
            if (this->instances_.data_[instance_offset] == CONTAINER_END) {
                // the instance list is empty
                assert(instances_last_.data_[instance_offset] == CONTAINER_END);
                this->instances_.data_[instance_offset] = this->size_;
            } else {
                // after the last item
                assert(instances_last_.data_[instance_offset] != CONTAINER_END);
                this->data_[instances_last_.data_[instance_offset]].next_offset = this->size_;
            }
            instances_last_.data_[instance_offset] = this->size_;
            this->size_++;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl %esi, %eax
ja 0x1288a
leaq 0x30(%rbx), %rdi
leal 0x1(%r14), %r12d
movl %r12d, %edx
subl %eax, %edx
pushq $-0x1
popq %r13
movl %r13d, %esi
callq 0x10204
leaq 0x60(%rbx), %rdi
subl 0x68(%rbx), %r12d
movl %r13d, %esi
movl %r12d, %edx
callq 0x10204
leaq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x151b2
movq 0x8(%rbx), %rdx
movl 0x10(%rbx), %eax
orl $-0x1, (%rdx,%rax,8)
movl %r15d, 0x4(%rdx,%rax,8)
movq 0x30(%rbx), %rsi
movq 0x60(%rbx), %rax
movl %r14d, %ecx
cmpl $-0x1, (%rsi,%rcx,4)
movl (%rax,%rcx,4), %edi
je 0x128c9
cmpl $-0x1, %edi
je 0x128ec
movl 0x10(%rbx), %r8d
movl %r8d, (%rdx,%rdi,8)
jmp 0x128d6
cmpl $-0x1, %edi
jne 0x1290b
movl 0x10(%rbx), %r8d
movl %r8d, (%rsi,%rcx,4)
movl %r8d, (%rax,%rcx,4)
incl 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23cd0(%rip), %rdi     # 0x365c3
leaq 0x23c22(%rip), %rsi     # 0x3651c
leaq 0x23c39(%rip), %rcx     # 0x3653a
movl $0xbd, %edx
callq 0xc180
leaq 0x23bd2(%rip), %rdi     # 0x364e4
leaq 0x23c03(%rip), %rsi     # 0x3651c
leaq 0x23c1a(%rip), %rcx     # 0x3653a
movl $0xb9, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::exclude_clause(unsigned int)
inline void CnfOptimizer::exclude_clause(const container_offset_t offset) {
#ifdef CNF_TRACE
        // it is possible that the clause is excluded for the second time due to recursive evaluation (?)
        if (p_tracer_ != nullptr && _clauses_offset_is_included(clauses_data_, offset)) {
            TRACE_CLAUSE_REMOVE(offset);
        };
#endif
        _clauses_offset_exclude(clauses_data_, offset);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3dd2f(%rip), %rdi     # 0x51300
testq %rdi, %rdi
je 0x135f0
movq 0x18(%rbx), %rax
movq (%rax), %rax
movl %esi, %r14d
testb $-0x80, 0xd(%rax,%r14,4)
jne 0x135f3
movq (%rdi), %rax
callq *0x60(%rax)
jmp 0x135f3
movl %esi, %r14d
movq 0x18(%rbx), %rax
movq (%rax), %rax
orl $0x8000, 0xc(%rax,%r14,4) # imm = 0x8000
popq %rbx
popq %r14
popq %rbp
retq
// 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_from_container_offset(bal::avl_tree_insertion_point_t&, unsigned int)
inline void insertion_point_from_container_offset(insertion_point_t& insertion_point, const container_offset_t offset) {
            static_assert(contains_data_itself, "not implemented");
            if (insertion_point.version_stamp == CONTAINER_END ||
                insertion_point.kind != btipkCurrent || insertion_point.offset != offset) {
                _assert_level_0(offset < this->size_);
                const CONTAINER_DATA_T* const p_item = _bti_item(this->data_, offset);
                bool result = false;
                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) == offset) ||
                                (_bti_item_right_offset(p_parent) == 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] == offset;
                };
                if (result) {
                    this->insertion_point_init(insertion_point);
                    insertion_point.kind = btipkCurrent;
                    insertion_point.offset = offset;
                    insertion_point.container_offset = _bti_item_container_offset(p_item, offset);
                };
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x4(%rsi)
je 0x13867
cmpl $0x3, 0x8(%rsi)
jne 0x13867
cmpl %edx, 0xc(%rsi)
je 0x138c8
cmpl %edx, 0x10(%rdi)
jbe 0x138ca
movq 0x8(%rdi), %rax
movl %edx, %r8d
movl (%rax,%r8,4), %ecx
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
cmpq %r9, %rcx
je 0x13890
cmpl %edx, 0x8(%rax,%rcx,4)
je 0x138b6
cmpl %edx, 0x4(%rax,%rcx,4)
je 0x138b6
jmp 0x138c8
leaq (%rax,%r8,4), %rax
movl $0x7fff, %ecx           # imm = 0x7FFF
andl 0xc(%rax), %ecx
decl %ecx
movl 0x10(%rax,%rcx,4), %eax
shrl %eax
decl %eax
cmpl 0x38(%rdi), %eax
jae 0x138e9
movq 0x30(%rdi), %rcx
movl %eax, %eax
cmpl %edx, (%rcx,%rax,4)
jne 0x138c8
movl 0x5c(%rdi), %eax
movl %eax, 0x4(%rsi)
movl $0x3, 0x8(%rsi)
movl %edx, 0xc(%rsi)
movl %edx, (%rsi)
popq %rbp
retq
leaq 0x2006b(%rip), %rdi     # 0x3393c
leaq 0x1fe55(%rip), %rsi     # 0x3372d
leaq 0x2141a(%rip), %rcx     # 0x34cf9
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xc180
leaq 0x20431(%rip), %rdi     # 0x33d21
leaq 0x1fe36(%rip), %rsi     # 0x3372d
leaq 0x213fb(%rip), %rcx     # 0x34cf9
movl $0x1f3, %edx            # imm = 0x1F3
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/cnf/cnfclauses.hpp
// Function: bal::resolve_ca_c2_flags(unsigned short&, unsigned short, unsigned short, unsigned short)
inline void resolve_ca_c2_flags(uint16_t& flags, const clause_size_t index, const clause_size_t c2_index, const uint16_t c2_flags) {
        
        // filters out clauses with specified literal negated (or not)
        // first dimention is whether negated or not, 0 means negated 1 direct
        // second dimention is the literal index, 0..3
        constexpr uint16_t clause_flags_negation_mask[2][4] = {
            {0x5555, 0x3333, 0x0F0F, 0x00FF}, // negated
            {0xAAAA, 0xCCCC, 0xF0F0, 0xFF00}  // direct
        };
        
        _assert_level_0(c2_flags <= 0xF);
        const uint8_t c2_combination = _c2_combination_index(c2_flags);
        _assert_level_1(c2_combination != 0xF);
        
        // if implicant is complemented, only get uncompemented clauses and vise versa
        if (c2_index == 0) {
            // (... lo ...) (lo, lx)
            flags &= clause_flags_negation_mask[!(c2_combination & 0b01)][index];
        } else {
            // (... lo ...) (lx, l0)
            flags &= clause_flags_negation_mask[!(c2_combination & 0b10)][index];
        };
        
        // if the resolvent literal is complemented, uncomplement the flags
        if (c2_combination == 0b00 || c2_combination == 0b11) {
            ca_flags_negate(flags, index);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x10, %cx
jae 0x14b52
movzwl %cx, %eax
movl $0xfee9, %r8d           # imm = 0xFEE9
btq %rax, %r8
jb 0x14b71
leaq 0x221ab(%rip), %r8      # 0x36cb0
movzbl (%rax,%r8), %r9d
movzwl %si, %esi
movzwl (%rdi), %r8d
testw %dx, %dx
je 0x14b24
xorl %edx, %edx
testb $0x2, %r9b
sete %dl
movq %rdx, %r9
jmp 0x14b2b
notl %r9d
andl $0x1, %r9d
leaq 0x2216e(%rip), %rdx     # 0x36ca0
leaq (%rdx,%r9,8), %rdx
andw (%rdx,%rsi,2), %r8w
movw %r8w, (%rdi)
cmpw $0x8, %cx
je 0x14b4a
cmpl $0x1, %eax
jne 0x14b50
popq %rbp
jmp 0x119c1
popq %rbp
retq
leaq 0x20633(%rip), %rdi     # 0x3518c
leaq 0x2063c(%rip), %rsi     # 0x3519c
leaq 0x20652(%rip), %rcx     # 0x351b9
movl $0x15c, %edx            # imm = 0x15C
callq 0xc180
leaq 0x206a5(%rip), %rdi     # 0x3521d
leaq 0x2061d(%rip), %rsi     # 0x3519c
leaq 0x20633(%rip), %rcx     # 0x351b9
movl $0x15e, %edx            # imm = 0x15E
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/linkedlistindex.hpp
// Function: bal::LinkedListsIndexInstanceFilteredOffsetIterator<unsigned int, bal::CnfProcessor, &bal::CnfProcessor::is_clause_included(unsigned int) const>::first(unsigned int)
inline container_offset_t first(const container_offset_t instance_offset) {
            instance_offset_ = instance_offset;
            item_offset_ = instance_offset < this->index_.instances_.size_ ? index_.instances_.data_[instance_offset] : CONTAINER_END;
            
            while (item_offset_ != CONTAINER_END) {
                const container_offset_t result = index_.data_[item_offset_].container_offset;
                if ((filter_.*IS_INCLUDED)(result)) {
                    return result;
                };
                item_offset_ = index_.data_[item_offset_].next_offset;
            };
            return CONTAINER_END;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, 0x8(%rdi)
movq (%rdi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, %r8d
cmpl %esi, 0x38(%rcx)
jbe 0x14bb1
movq 0x30(%rcx), %rdx
movl %esi, %esi
movl (%rdx,%rsi,4), %r8d
movq 0x10(%rdi), %rdx
movl %r8d, 0xc(%rdi)
cmpl $-0x1, %r8d
je 0x14be3
movq 0x8(%rcx), %rsi
movl %r8d, %r8d
movl 0x4(%rsi,%r8,8), %r9d
movq 0x18(%rdx), %r10
movq (%r10), %r10
testb $-0x80, 0xd(%r10,%r9,4)
je 0x14be0
movl (%rsi,%r8,8), %r8d
jmp 0x14bb5
movl %r9d, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/linkedlistindex.hpp
// Function: bal::LinkedListsIndexInstanceFilteredOffsetIterator<unsigned int, bal::CnfProcessor, &bal::CnfProcessor::is_clause_included(unsigned int) const>::next()
inline container_offset_t next() {
            while (item_offset_ != CONTAINER_END) {
                item_offset_ = index_.data_[item_offset_].next_offset;
                if (item_offset_ != CONTAINER_END) {
                    const container_offset_t result = index_.data_[item_offset_].container_offset;
                    if ((filter_.*IS_INCLUDED)(result)) {
                        return result;
                    };
                };
            };
            return CONTAINER_END;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xc(%rdi), %esi
movq (%rdi), %rcx
movq 0x10(%rdi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpl $-0x1, %esi
je 0x14c2d
movq 0x8(%rcx), %r9
movl %esi, %esi
movl (%r9,%rsi,8), %esi
movl %esi, 0xc(%rdi)
cmpq %r8, %rsi
je 0x14bff
movl 0x4(%r9,%rsi,8), %r9d
movq 0x18(%rdx), %r10
movq (%r10), %r10
testb $-0x80, 0xd(%r10,%r9,4)
jne 0x14bff
movl %r9d, %eax
popq %rbp
retq
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*)>::_remove(unsigned int)
inline void _remove(const container_offset_t offset) {
            _assert_level_0(offset < this->size_);
            const container_offset_t* const p_item = _bti_item(this->data_, offset);
            container_offset_t new_offset = CONTAINER_END;
            // check right then left then parent
            if (_bti_item_right_offset(p_item) != CONTAINER_END) {
                new_offset = _bti_item_right_offset(p_item);
                if (_bti_item_left_offset(p_item) != CONTAINER_END) {
                    // append left child as the leftmost leaf node of the right tree
                    container_offset_t leaf_offset = new_offset;
                    while (_bti_left_offset(this->data_, leaf_offset) != CONTAINER_END) {
                        leaf_offset = _bti_left_offset(this->data_, leaf_offset);
                    };
                    _bti_left_offset(this->data_, leaf_offset) = _bti_item_left_offset(p_item);
                    _bti_parent_offset(this->data_, _bti_item_left_offset(p_item)) = leaf_offset;
                };
            } else if (_bti_item_left_offset(p_item) != CONTAINER_END) {
                // right_offset is necessarily CONTAINER_END in this case
                new_offset = _bti_item_left_offset(p_item);
            };
            
            _update_parent(offset, new_offset);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %esi, 0x10(%rdi)
jbe 0x15193
movq 0x8(%rdi), %rax
movl %esi, %ecx
movl 0x4(%rax,%rcx,4), %edx
movl 0x8(%rax,%rcx,4), %r8d
cmpl $-0x1, %edx
je 0x1518a
cmpl $-0x1, %r8d
je 0x1518d
movl %edx, %r11d
movl %r11d, %r9d
movl %r11d, %r10d
movl 0x8(%rax,%r10,4), %r11d
cmpl $-0x1, %r11d
jne 0x1516a
movl %r8d, 0x8(%rax,%r10,4)
movl 0x8(%rax,%rcx,4), %ecx
movl %r9d, (%rax,%rcx,4)
jmp 0x1518d
movl %r8d, %edx
popq %rbp
jmp 0x1012c
leaq 0x1e7a2(%rip), %rdi     # 0x3393c
leaq 0x1e58c(%rip), %rsi     # 0x3372d
leaq 0x2121d(%rip), %rcx     # 0x363c5
movl $0xb6, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/bal/linkedlistindex.hpp
// Function: bool bal::LinkedListsIndex<unsigned int>::iterate_const<bal::CnfProcessor, bool, &bal::CnfProcessor::is_clause_included(unsigned int) const, false>(bal::CnfProcessor const*, unsigned int) const
inline RESULT_T iterate_const(const CALLER_T* const p_caller, const container_offset_t instance_offset) const {
            RESULT_T result = RESULT_CONTINUE;
            container_offset_t offset = instance_offset < this->instances_.size_ ? this->instances_.data_[instance_offset] : CONTAINER_END;
            while (offset != CONTAINER_END) {
                result = (p_caller->*container_offset_function)(this->data_[offset].container_offset);
                if (result == RESULT_CONTINUE) {
                    offset = this->data_[offset].next_offset;
                } else {
                    break;
                };
            };
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, 0x38(%rdi)
jbe 0x152a4
movq 0x30(%rdi), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %eax
jmp 0x152a9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x8(%rdi), %rcx
cmpl $-0x1, %eax
je 0x152cc
movl %eax, %edx
movl 0x4(%rcx,%rdx,8), %edi
movq 0x18(%rsi), %r8
movq (%r8), %r8
testb $-0x80, 0xd(%r8,%rdi,4)
je 0x152cc
movl (%rcx,%rdx,8), %eax
jmp 0x152ad
cmpl $-0x1, %eax
setne %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq (%rdi), %rdi
cmpq %rsi, %rdi
je 0x20775
testq %rdi, %rdi
je 0x20762
movq (%rdi), %rax
addq -0x20(%rax), %rdi
callq 0x15324
testq %rbx, %rbx
je 0x20772
movq (%rbx), %rax
movq -0x20(%rax), %rax
incl 0x8(%rbx,%rax)
movq %rbx, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfsubsumption.cpp
// Function: bal::CnfSubsumptionOptimizer::process_clause_subsumption(unsigned int*)
inline processor_result_t CnfSubsumptionOptimizer::process_clause_subsumption(uint32_t* const p_clause) {
        const clause_size_t clause_size = _clause_size(p_clause);
        switch(clause_size) {
            case 2:
                return process_clause_subsumption_ca<2>(p_clause);
            case 3:
                return process_clause_subsumption_ca<3>(p_clause);
            case 4:
                return process_clause_subsumption_ca<4>(p_clause);
            default:
                return erUndetermined;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x7fff, %eax           # imm = 0x7FFF
andl (%rsi), %eax
cmpl $0x4, %eax
je 0x1558e
cmpl $0x3, %eax
je 0x15588
cmpl $0x2, %eax
jne 0x15594
popq %rbp
jmp 0x15598
popq %rbp
jmp 0x156fa
popq %rbp
jmp 0x1587a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/cnf/processor/cnfsubsumption.cpp
// Function: void bal::__process_clause_subsumption_caca<(unsigned short)2, (unsigned short)3, (unsigned short)0, (unsigned short)2, (unsigned short)3>(unsigned int const*, unsigned int*)
inline void __process_clause_subsumption_caca(const uint32_t* const p_ca1, uint32_t* const p_ca2) {
        clause_flags_t original_flags = _clause_flags(p_ca2);
        clause_flags_t subsumed_flags = _clause_flags(p_ca1);
        caca_expand_flags<size1, size2, l0_index, l1_index, l2_index>(subsumed_flags);
        if ((original_flags & ~subsumed_flags) == 0) {
            _clause_exclude(p_ca2);
        } else if ((original_flags & subsumed_flags) != 0) {
            _clause_flags_set(p_ca2, original_flags & ~subsumed_flags);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %eax
movl %eax, %ecx
shrl $0x10, %ecx
movl (%rdi), %edx
movl %edx, %edi
shrl $0x10, %edi
andl $0x3, %edi
shrl $0xe, %edx
andl $0x30, %edx
orl %edi, %edx
leal (%rdx,%rdx,4), %edi
movl %edi, %edx
notl %edx
andl %ecx, %edx
je 0x15ac5
testl %ecx, %edi
je 0x15acc
shll $0x10, %edx
movzwl %ax, %eax
orl %edx, %eax
jmp 0x15aca
orl $0x8000, %eax           # imm = 0x8000
movl %eax, (%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23d91(%rip), %rsi     # 0x3a286
pushq $-0x1
popq %rdx
callq 0xc270
cmpq $-0x1, %rax
je 0x16596
incq %rax
leaq -0x60(%rbp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc2b0
movq (%r15), %r14
movq 0x8(%r15), %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x16541
movzbl (%r14,%r12), %edi
callq 0xc390
movb %al, (%r14,%r12)
incq %r12
jmp 0x16529
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0xc360
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x16570
movzbl (%rbx,%r15), %edi
callq 0xc390
movb %al, (%rbx,%r15)
incq %r15
jmp 0x16558
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc030
testl %eax, %eax
sete %bl
leaq -0x40(%rbp), %rdi
callq 0xc110
leaq -0x60(%rbp), %rdi
callq 0xc110
jmp 0x16598
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc110
jmp 0x165b8
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x164d9
testb %al, %al
je 0x16635
cmpb $0x0, 0x98(%r14)
je 0x16625
cmpl %r12d, 0x8(%r14)
je 0x16635
pushq $0x10
popq %rdi
callq 0xc130
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc4e0
movq 0x3a9c2(%rip), %rsi     # 0x50fd8
movq 0x3a9a3(%rip), %rdx     # 0x50fc0
movq %r14, %rdi
callq 0xc490
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 0xc1d0
movq %rbx, %rdi
callq 0xc4c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
jne 0x17046
movq (%rbx), %rax
movq -0x18(%rax), %r12
leaq 0x20786(%rip), %rsi     # 0x37797
leaq -0x88(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc0e0
addq %rbx, %r12
leaq -0x88(%rbp), %rsi
movq %r12, %rdi
callq 0x189ce
leaq -0x88(%rbp), %rdi
callq 0xc110
cmpq $0x0, 0x8(%r14)
je 0x17087
movq (%r14), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x17087
movq (%rbx), %rax
movq -0x18(%rax), %r12
leaq 0x20775(%rip), %rsi     # 0x377d7
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc0e0
addq %rbx, %r12
leaq -0x68(%rbp), %rsi
movq %r12, %rdi
callq 0x189ce
leaq -0x68(%rbp), %rdi
callq 0xc110
movq %r15, %rdi
movq %r14, %rsi
callq 0x19c10
movq %rax, %r14
cmpl $0x0, 0x48(%rax)
jne 0x170a2
cmpl $0x0, 0x50(%r14)
je 0x170d5
movq (%rbx), %rax
movq -0x18(%rax), %r15
leaq 0x204ab(%rip), %rsi     # 0x3755b
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0xc0e0
addq %r15, %rbx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x189ce
leaq -0x48(%rbp), %rdi
callq 0xc110
movb $0x1, 0x78(%r14)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
jmp 0x17107
jmp 0x1710e
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x17107
jmp 0x1710e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc110
jmp 0x17111
movq %rax, %rbx
movq %rbx, %rdi
callq 0xc4c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x19c10
movq %rax, %r14
cmpl $0x2, 0x40(%rax)
je 0x17174
movq (%r15), %rax
addq -0x18(%rax), %r15
leaq 0x206bb(%rip), %rsi     # 0x3780b
leaq -0x48(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0xc0e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x189ce
leaq -0x48(%rbp), %rdi
callq 0xc110
movl %ebx, 0x44(%r14)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_literal[abi:cxx11]()
inline std::string read_literal() {
        load_next_token();
        if (current_token_type_ != ttLiteral) {
            parse_error("Expect literal");
        };
        std::string result = current_line_.substr(current_token_pos_, current_token_len_);
        skip_token();
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x19176
cmpl $0x5, 0x40(%r14)
je 0x18985
leaq 0x1f5f0(%rip), %rsi     # 0x37f51
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0xc0e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x189ce
leaq -0x40(%rbp), %rdi
callq 0xc110
leaq 0x18(%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq %rbx, %rdi
callq 0xc2b0
movq 0x10(%r14), %rax
addq %rax, 0x8(%r14)
andq $0x0, 0x10(%r14)
andl $0x0, 0x40(%r14)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::is_symbol(char)
inline bool is_symbol(const char value) {
        load_next_token();
        if (current_token_len_ > 0) {
            return current_line_[current_token_pos_] == value;
        };
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x19176
cmpq $0x0, 0x10(%r14)
je 0x18aba
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
cmpb %bl, (%rcx,%rax)
sete %al
jmp 0x18abc
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_symbol(char)
inline void read_symbol(const char value) {
        if (is_symbol(value))
            skip_symbol();
        else
            parse_error(std::string("Expect \"") + std::string(1, value) + std::string("\" symbol"));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x18a92
testb %al, %al
je 0x18af2
movq %rbx, %rdi
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x197ba
leaq 0x1f467(%rip), %rsi     # 0x37f60
leaq -0x78(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0xc0e0
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
movsbl %r14b, %edx
leaq -0x38(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0xc2f0
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x195f2
leaq 0x1f430(%rip), %rsi     # 0x37f69
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xc0e0
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x195f2
leaq -0xb8(%rbp), %rsi
movq %rbx, %rdi
callq 0x189ce
leaq -0xb8(%rbp), %rdi
callq 0xc110
leaq -0x58(%rbp), %rdi
callq 0xc110
leaq -0x98(%rbp), %rdi
callq 0xc110
leaq -0x38(%rbp), %rdi
callq 0xc110
leaq -0x78(%rbp), %rdi
callq 0xc110
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0xc110
jmp 0x18bbf
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc110
jmp 0x18bcd
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xc110
jmp 0x18bde
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xc110
jmp 0x18bec
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xc110
movq %rbx, %rdi
callq 0xc4c0
nop