LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq (%rax), %rdx
xorl %eax, %eax
cmpl 0x38(%rdx), %ecx
movb %al, -0x11(%rbp)
jae 0x19290
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq 0x30(%rax), %rax
movl 0x18(%rcx), %ecx
cmpl $-0x1, (%rax,%rcx,4)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x19299
jmp 0x192a8
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x19264
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %eax
movq (%rcx), %rcx
cmpl 0x38(%rcx), %eax
jae 0x192d5
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movl 0x18(%rax), %esi
callq 0x192f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x192e0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rcx)
movl -0xc(%rbp), %eax
movq (%rcx), %rcx
cmpl 0x38(%rcx), %eax
jb 0x1931e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x19332
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0xc(%rax)
cmpl $-0x1, 0xc(%rax)
je 0x19372
jmp 0x19344
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rax), %rax
movl 0xc(%rcx), %ecx
cmpl $-0x1, 0x8(%rax,%rcx,4)
je 0x19370
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movl 0xc(%rax), %edx
movl 0x8(%rcx,%rdx,4), %ecx
movl %ecx, 0xc(%rax)
jmp 0x19344
jmp 0x19372
movq -0x18(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
jne 0x19386
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0x19390
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rax
cmpl $0x0, 0x38(%rax)
jbe 0x1942d
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x19440
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
cmpl $-0x1, 0x1c(%rax)
jne 0x1942b
movq -0x10(%rbp), %rdi
movl 0x18(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x18(%rdi)
callq 0x19250
jmp 0x1942d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1a670
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a607
jmp 0x1a609
jmp 0x1a628
leaq 0x44157(%rip), %rdi     # 0x5e767
leaq 0x433ee(%rip), %rsi     # 0x5da05
movl $0x5c, %edx
leaq 0x44159(%rip), %rcx     # 0x5e77c
callq 0xd1c0
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
callq 0x11790
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15a70
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0x10(%rbp), %esi
callq 0x1a690
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0xc0(%rax), %rax
andq $0x3fff, %rax           # imm = 0x3FFF
cmpq $0x0, %rax
jne 0x1ab85
movq 0x6852a(%rip), %rdi     # 0x82fa0
leaq 0x43f3b(%rip), %rsi     # 0x5e9b8
callq 0xd320
movq %rax, %rdi
leaq -0xa7cc(%rip), %rsi     # 0x102c0
callq 0xd0f0
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x1ad60
movq -0x50(%rbp), %rdi
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %esi
callq 0xd4e0
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0x1ad80
movq -0x48(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0xd390
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %esi
shrl $0xa, %esi
callq 0xd420
movq %rax, %rdi
leaq 0x43ed0(%rip), %rsi     # 0x5e9bb
callq 0xd320
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x1ad80
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0xd390
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movl (%rcx), %esi
subl 0xb0(%rax), %esi
shrl $0xa, %esi
callq 0xd420
movq %rax, %rdi
leaq 0x43e91(%rip), %rsi     # 0x5e9c3
callq 0xd320
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x1ad80
movq -0x38(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0xd390
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq 0xd0(%rax), %rsi
callq 0xd0a0
movq %rax, %rdi
movq 0x68437(%rip), %rsi     # 0x82fa8
callq 0xd360
movq %rax, %rdi
leaq 0x43e4a(%rip), %rsi     # 0x5e9ca
callq 0xd320
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rdx), %rcx
movq (%rcx), %rcx
movl 0xb0(%rdx), %edx
shlq $0x2, %rdx
addq %rdx, %rcx
addq $0xc, %rcx
cmpq %rcx, %rax
jne 0x1abac
jmp 0x1abcb
leaq 0x43e19(%rip), %rdi     # 0x5e9cc
leaq 0x4335a(%rip), %rsi     # 0x5df14
movl $0x84, %edx
leaq 0x43e42(%rip), %rcx     # 0x5ea08
callq 0xd1c0
movq -0x30(%rbp), %rdi
movl 0xb0(%rdi), %esi
callq 0x1ada0
movl %eax, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jne 0x1abff
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x10310
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x12940
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x67292(%rip), %rdi     # 0x83390
callq 0x16210
cmpq $0x0, %rax
je 0x1c151
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl 0xc(%rax,%rcx,4), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
jne 0x1c151
leaq 0x67264(%rip), %rdi     # 0x83390
callq 0x16210
cmpq $0x0, %rax
je 0x1c14f
leaq 0x67252(%rip), %rdi     # 0x83390
callq 0x178d0
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x60(%rax)
jmp 0x1c151
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movl 0xc(%rax,%rcx,4), %edx
orl $0x8000, %edx           # imm = 0x8000
movl %edx, 0xc(%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rcx)
movl -0x14(%rbp), %eax
movq (%rcx), %rcx
cmpl 0x38(%rcx), %eax
jae 0x1e6ee
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
jmp 0x1e6f8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x24(%rbp)
jmp 0x1e6f8
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
je 0x1e792
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movl 0xc(%rax), %edx
movl 0x4(%rcx,%rdx,8), %ecx
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x1e735
jmp 0x1e751
movq -0x30(%rbp), %rax
movq (%rax), %rax
leaq -0x2103(%rip), %rcx     # 0x1c640
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x38(%rbp)
jmp 0x1e75e
leaq -0x2118(%rip), %rax     # 0x1c640
movq %rax, -0x38(%rbp)
jmp 0x1e75e
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %esi
callq *%rax
testb $0x1, %al
jne 0x1e771
jmp 0x1e779
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e799
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movl 0xc(%rax), %edx
movl (%rcx,%rdx,8), %ecx
movl %ecx, 0xc(%rax)
jmp 0x1e702
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
je 0x1e85c
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movl 0xc(%rax), %edx
movl (%rcx,%rdx,8), %ecx
movl %ecx, 0xc(%rax)
cmpl $-0x1, 0xc(%rax)
je 0x1e857
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movl 0xc(%rax), %edx
movl 0x4(%rcx,%rdx,8), %ecx
movl %ecx, -0x14(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x1e811
jmp 0x1e82d
movq -0x28(%rbp), %rax
movq (%rax), %rax
leaq -0x21df(%rip), %rcx     # 0x1c640
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x30(%rbp)
jmp 0x1e83a
leaq -0x21f4(%rip), %rax     # 0x1c640
movq %rax, -0x30(%rbp)
jmp 0x1e83a
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %esi
callq *%rax
testb $0x1, %al
jne 0x1e84d
jmp 0x1e855
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e863
jmp 0x1e857
jmp 0x1e7c4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x1f111
jmp 0x1f130
leaq 0x3e845(%rip), %rdi     # 0x5d95d
leaq 0x3e62f(%rip), %rsi     # 0x5d74e
movl $0xb6, %edx
leaq 0x413a6(%rip), %rcx     # 0x604d1
callq 0xd1c0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
je 0x1f1c0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x1f1be
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
cmpl $-0x1, 0x8(%rax,%rcx,4)
je 0x1f197
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
movl 0x8(%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
jmp 0x1f171
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %esi
movq 0x8(%rax), %rcx
movl -0x20(%rbp), %edx
movl %esi, 0x8(%rcx,%rdx,4)
movl -0x20(%rbp), %edx
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x1f1d6
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x1f1d4
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f1d6
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x15920
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x38(%rcx), %eax
jae 0x1f4ba
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f4c4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x1f4c4
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x1f54e
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x1f4e0
jmp 0x1f4fc
movq -0x38(%rbp), %rax
movq (%rax), %rax
leaq -0x2eae(%rip), %rcx     # 0x1c640
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x40(%rbp)
jmp 0x1f509
leaq -0x2ec3(%rip), %rax     # 0x1c640
movq %rax, -0x40(%rbp)
jmp 0x1f509
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq 0x8(%rcx), %rcx
movl -0x1c(%rbp), %edx
movl 0x4(%rcx,%rdx,8), %esi
callq *%rax
andb $0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1f547
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f549
jmp 0x1f54e
jmp 0x1f4ca
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: vsklad[P]cgen/./bal/bal/referenceable.hpp
// Function: bal::Ref<bal::CnfTracer>::set_value(bal::CnfTracer*) 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x1f5f2
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1f5d7
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1f600
cmpq $0x0, -0x10(%rbp)
je 0x1f5e7
movq -0x10(%rbp), %rdi
callq 0x1f650
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x2, %eax
je 0x1fb7a
jmp 0x1fb66
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0x1fb8c
jmp 0x1fb70
movl -0x20(%rbp), %eax
subl $0x4, %eax
je 0x1fb9e
jmp 0x1fbb0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1fbc0
movl %eax, -0x4(%rbp)
jmp 0x1fbb7
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1fe10
movl %eax, -0x4(%rbp)
jmp 0x1fbb7
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x200a0
movl %eax, -0x4(%rbp)
jmp 0x1fbb7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: vsklad[P]cgen/./bal/cnf/processor/cnfsubsumption.cpp
// Function: void bal::__process_clause_subsumption_caca<(unsigned short)2, (unsigned short)3, (unsigned short)1, (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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
movw %ax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x20830
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x20375
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x8000, %ecx           # imm = 0x8000
movl %ecx, (%rax)
jmp 0x203a9
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x203a7
movzwl -0x12(%rbp), %ecx
movzwl -0x14(%rbp), %eax
xorl $-0x1, %eax
andl %eax, %ecx
shll $0x10, %ecx
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x203a9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x428ad(%rip), %rsi     # 0x644db
movq $-0x1, %rdx
callq 0xd2e0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x21db4
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
incq %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq $-0x1, %rcx
callq 0xd340
movq -0xd0(%rbp), %rdi
callq 0xd270
movq -0xd0(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xd180
movq -0xd0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0xd270
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x21dd0
movq %rax, -0xc8(%rbp)
jmp 0x21cb5
movq -0xc8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xd130
jmp 0x21cd2
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xd270
movq -0xe0(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0xd180
movq -0xe0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0xd270
movq %rax, -0xb0(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0x21e50
movq %rax, -0xd8(%rbp)
jmp 0x21d35
movq -0xd8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xd040
movl %eax, -0xe4(%rbp)
jmp 0x21d5b
movl -0xe4(%rbp), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xd1b0
leaq -0x40(%rbp), %rdi
callq 0xd1b0
jmp 0x21db8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x21da9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xd1b0
leaq -0x40(%rbp), %rdi
callq 0xd1b0
jmp 0x21dc6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xd5a0
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21c10
testb $0x1, %al
jne 0x21f05
jmp 0x21f90
movq -0x18(%rbp), %rax
testb $0x1, 0x98(%rax)
jne 0x21f33
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x98(%rax)
jmp 0x21f8e
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
je 0x21f8c
movl $0x10, %edi
callq 0xd150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
callq 0xd5f0
jmp 0x21f5e
movq -0x40(%rbp), %rdi
movq 0x6106f(%rip), %rsi     # 0x82fd8
movq 0x61050(%rip), %rdx     # 0x82fc0
callq 0xd570
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xd210
jmp 0x21f96
jmp 0x21f8e
jmp 0x21f90
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xd5a0
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26cc0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x26cf0
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
je 0x23527
movq -0x70(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xd5b0
movq -0x78(%rbp), %rdx
leaq 0x3e3f8(%rip), %rsi     # 0x618c3
leaq -0x50(%rbp), %rdi
callq 0xd440
jmp 0x234d6
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x262a0
jmp 0x234e5
leaq -0x50(%rbp), %rdi
callq 0xd1b0
leaq -0x51(%rbp), %rdi
callq 0xd370
jmp 0x23527
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2351c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xd1b0
leaq -0x51(%rbp), %rdi
callq 0xd370
jmp 0x2353a
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::is_token(TextReader::TokenType)
inline bool is_token(const TokenType token_type) {
        load_next_token();
        if (current_token_len_ > 0) {
            return (current_token_type_ == token_type);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x272c0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x25beb
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x25bef
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x272c0
movq -0x50(%rbp), %rax
cmpl $0x5, 0x40(%rax)
je 0x26236
leaq -0x31(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xd5b0
movq -0x68(%rbp), %rdx
leaq 0x3be2f(%rip), %rsi     # 0x62009
leaq -0x30(%rbp), %rdi
callq 0xd440
jmp 0x261e5
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x262a0
jmp 0x261f4
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0x31(%rbp), %rdi
callq 0xd370
jmp 0x26236
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2622b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0x31(%rbp), %rdi
callq 0xd370
jmp 0x26297
movq -0x50(%rbp), %rax
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq %rax, %rsi
addq $0x18, %rsi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
callq 0xd340
movq -0x50(%rbp), %rdi
callq 0x26900
jmp 0x26261
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0x2628d
jmp 0x26284
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xd1b0
jmp 0x26297
movq -0x60(%rbp), %rdi
callq 0xd1b0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xd5a0
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x272c0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x26421
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x26425
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x100, %rsp            # imm = 0x100
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x263d0
testb $0x1, %al
jne 0x2645f
jmp 0x26470
movq -0xe0(%rbp), %rdi
callq 0x283f0
jmp 0x26659
leaq -0x71(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xd5b0
movq -0xe8(%rbp), %rdx
leaq 0x3bb8a(%rip), %rsi     # 0x62018
leaq -0x70(%rbp), %rdi
callq 0xd440
jmp 0x26499
movsbl -0x9(%rbp), %eax
movl %eax, -0xf4(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xd5b0
movl -0xf4(%rbp), %edx
movq -0xf0(%rbp), %rcx
leaq -0xa8(%rbp), %rdi
movl $0x1, %esi
callq 0xd1d0
jmp 0x264d6
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x28080
jmp 0x264ec
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xd5b0
movq -0x100(%rbp), %rdx
leaq 0x3bb14(%rip), %rsi     # 0x62021
leaq -0xd0(%rbp), %rdi
callq 0xd440
jmp 0x2651b
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0x28080
jmp 0x26531
movq -0xe0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x262a0
jmp 0x26543
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0xd0(%rbp), %rdi
callq 0xd1b0
leaq -0xd1(%rbp), %rdi
callq 0xd370
leaq -0x50(%rbp), %rdi
callq 0xd1b0
leaq -0xa8(%rbp), %rdi
callq 0xd1b0
leaq -0xa9(%rbp), %rdi
callq 0xd370
leaq -0x70(%rbp), %rdi
callq 0xd1b0
leaq -0x71(%rbp), %rdi
callq 0xd370
jmp 0x26659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2664e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x26639
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2662d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x26618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2660c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd1b0
leaq -0xd0(%rbp), %rdi
callq 0xd1b0
leaq -0xd1(%rbp), %rdi
callq 0xd370
leaq -0x50(%rbp), %rdi
callq 0xd1b0
leaq -0xa8(%rbp), %rdi
callq 0xd1b0
leaq -0xa9(%rbp), %rdi
callq 0xd370
leaq -0x70(%rbp), %rdi
callq 0xd1b0
leaq -0x71(%rbp), %rdi
callq 0xd370
jmp 0x26662
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xd5a0
nopl (%rax,%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::is_eol()
inline bool is_eol() {
        load_first_line();
        // skip \r symbol at the end if exists
        if (current_token_pos_ == current_line_.size() - 1 && current_line_[current_token_pos_] == '\r') {
            current_token_pos_++;
        };
        return current_token_pos_ >= current_line_.size();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x28450
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0xd1f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x266da
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x266da
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0xd1f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
setae %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::is_token(char const*)
inline bool is_token(const char* value) {
        load_next_token();
        if (current_token_len_ > 0) {
            auto index = 0;
            while (index < current_token_len_ && value[index] != 0) {
                if (current_line_[current_token_pos_ + index] != value[index])
                    return false;
                index++;
            };
            if (value[index] != 0) {
                index++;
            };
            return (index == current_token_len_);
        };
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x272c0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x268e3
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x29(%rbp)
jae 0x2686b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x26874
jmp 0x268b3
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
callq 0xd630
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x268a8
movb $0x0, -0x1(%rbp)
jmp 0x268e7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26843
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x268cd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rax
cmpq 0x10(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x268e7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::read_until_eol[abi:cxx11]()
inline const std::string read_until_eol() {
        std::string result = get_current_token();
        current_token_pos_ = current_line_.size();
        reset_token();
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x28520
movq %rax, -0x38(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xd5b0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xd440
jmp 0x26980
leaq -0x12(%rbp), %rdi
callq 0xd370
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0xd1f0
movq -0x48(%rbp), %rdi
movq %rax, 0x8(%rdi)
callq 0x28430
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x269cf
jmp 0x269c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0xd370
jmp 0x269d9
movq -0x40(%rbp), %rdi
callq 0xd1b0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd5a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray& bal::VariablesArray::operator=<char, std::char_traits<char>>(char const*)
inline VariablesArray& operator = (const charT* const s) {
            static constexpr std::size_t charT_size_bits = sizeof(charT) << 3;
            
            const std::size_t size_char = charT_traits::length(s);
            const std::size_t size_bits = size_char * charT_size_bits;
            
            _assert_level_0(size_bits <= VARIABLEID_MAX);
            _assert_level_1(size_bits % element_size_ == 0);
            resize((container_size_t)size_bits);
            
            // encode bit by bit for each byte
            bal::literalid_t* p_value = data_;
            for (auto i = 0; i < size_char; i++) {
                for (auto j = 0; j < charT_size_bits; j++) {
                    *p_value = literal_t__constant(s[i] & (1 << (charT_size_bits - 1 - j)));
                    p_value++;
                };
            };
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13d50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
cmpq $0x7ffffffe, -0x20(%rbp) # imm = 0x7FFFFFFE
ja 0x26a2d
jmp 0x26a4c
leaq 0x3b69e(%rip), %rdi     # 0x620d2
leaq 0x34cf1(%rip), %rsi     # 0x5b72c
movl $0x44, %edx
leaq 0x3b6a7(%rip), %rcx     # 0x620ee
callq 0xd1c0
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x1c(%rcx), %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x26a64
jmp 0x26a83
leaq 0x3b6fc(%rip), %rdi     # 0x62167
leaq 0x34cba(%rip), %rsi     # 0x5b72c
movl $0x45, %edx
leaq 0x3b670(%rip), %rcx     # 0x620ee
callq 0xd1c0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x11390
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x26b19
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
cmpq $0x8, %rax
jae 0x26b0c
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movslq -0x30(%rbp), %rcx
movl $0x7, %eax
subq %rcx, %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
andl %eax, %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x26ab5
jmp 0x26b0e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x26aa4
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_literal()
inline void parse_literal() {
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq 0x8(%rdi), %rax
addq 0x10(%rdi), %rax
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0xd1f0
movq -0x20(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jae 0x27eeb
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x27e37
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x39, %ecx
movb %al, -0x21(%rbp)
jle 0x27ee5
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x27e7c
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5a, %ecx
movb %al, -0x21(%rbp)
jle 0x27ee5
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x27ec1
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x7a, %ecx
movb %al, -0x21(%rbp)
jle 0x27ee5
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x8(%rax), %rsi
addq 0x10(%rax), %rsi
callq 0xd630
movsbl (%rax), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x27ef4
jmp 0x27f09
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x27dc0
addq $0x30, %rsp
popq %rbp
retq
nop