LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::merge_clause(unsigned int const*, unsigned int)
void merge_clause(const uint32_t* const p_clause, const container_offset_t offset) override {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(is_current_clause(p_clause, CONTAINER_END));
                _assert_level_0(offset != CONTAINER_END);
                write_action('m', 1);
                write_clause(p_cnf_->get_clause_data(offset));
                stream << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testb $0x2, 0x18(%rdi)
je 0x26d4d
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x26d4d
movl %edx, %r14d
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %r13
cmpq %r13, %rdx
je 0x26d5c
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x26d5c
testq %rsi, %rsi
je 0x26d7b
cmpq %rsi, -0x8(%rax)
jne 0x26d7b
cmpl $-0x1, %r14d
je 0x26d9a
movq 0x10(%rbx), %r15
movq (%r15), %rax
movq -0x18(%rax), %rcx
leaq (%r15,%rcx), %r12
cmpb $0x0, 0xe1(%r15,%rcx)
jne 0x26c99
movq %r12, %rdi
movl $0x20, %esi
movq %rdx, -0x38(%rbp)
callq 0xb2a0
movq -0x38(%rbp), %rdx
movb $0x1, 0xe1(%r12)
movq (%r15), %rax
subq %rdx, %r13
movb $0x2e, 0xe0(%r12)
movq -0x18(%rax), %rax
shlq $0x1e, %r13
movabsq $0x200000000, %rcx      # imm = 0x200000000
addq %r13, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%r15,%rax)
leaq -0x29(%rbp), %rsi
movb $0x6d, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0xb320
movq 0x20(%rbx), %rax
cmpl %r14d, 0x88(%rax)
jbe 0x26db9
movq 0x80(%rax), %rax
movl %r14d, %ecx
leaq (%rax,%rcx,4), %r14
addq $0xc, %r14
movq 0x10(%rbx), %rdi
leaq -0x2a(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0xb320
movq 0x10(%rbx), %rdi
leaq 0x19044(%rip), %rdx     # 0x3fd5e
movq %r14, %rsi
callq 0xf214
movq 0x10(%rbx), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20030(%rip), %rdi     # 0x46d93
leaq 0x1fec7(%rip), %rsi     # 0x46c31
leaq 0x20049(%rip), %rcx     # 0x46dba
movl $0x45, %edx
callq 0xb180
leaq 0x2017e(%rip), %rdi     # 0x46f00
leaq 0x1fea8(%rip), %rsi     # 0x46c31
leaq 0x2019b(%rip), %rcx     # 0x46f2b
movl $0x9a, %edx
callq 0xb180
leaq 0x1aaf4(%rip), %rdi     # 0x41895
leaq 0x1fe89(%rip), %rsi     # 0x46c31
leaq 0x2017c(%rip), %rcx     # 0x46f2b
movl $0x9b, %edx
callq 0xb180
leaq 0x1ab7c(%rip), %rdi     # 0x4193c
leaq 0x1a3d7(%rip), %rsi     # 0x4119e
leaq 0x201be(%rip), %rcx     # 0x46f8c
movl $0x3c, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::remove_clause(unsigned int)
void remove_clause(const container_offset_t offset) override {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(offset != CONTAINER_END);
                if (is_current_clause(nullptr, offset)) {
                    write_current_clause_action('x',  clauses_.back());
                    set_current_clause(clauses_.back(), CONTAINER_END);
                } else {
                    write_current_clause_action('x', p_cnf_->get_clause_data(offset));
                };
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testb $0x2, 0x18(%rdi)
je 0x26e4a
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x26e4a
cmpl $-0x1, %esi
je 0x26e9c
movq 0x48(%rbx), %rcx
cmpq %rcx, 0x40(%rbx)
je 0x26e7d
movq 0x30(%rbx), %rdx
cmpq %rdx, 0x28(%rbx)
je 0x26e7d
cmpl %esi, -0x4(%rcx)
jne 0x26e51
movq -0x8(%rdx), %rdx
movq %rbx, %rdi
movl $0x78, %esi
callq 0x2705e
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
je 0x26eda
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x26eda
movq 0x48(%rbx), %rax
movl $0xffffffff, -0x4(%rax) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl %esi, 0x88(%rax)
jbe 0x26ebb
movq 0x80(%rax), %rax
movl %esi, %ecx
leaq (%rax,%rcx,4), %rdx
addq $0xc, %rdx
movq %rbx, %rdi
movl $0x78, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2705e
leaq 0x1ff0f(%rip), %rdi     # 0x46d93
leaq 0x1fda6(%rip), %rsi     # 0x46c31
leaq 0x1ff28(%rip), %rcx     # 0x46dba
movl $0x45, %edx
callq 0xb180
leaq 0x1a9f2(%rip), %rdi     # 0x41895
leaq 0x1fd87(%rip), %rsi     # 0x46c31
leaq 0x2012b(%rip), %rcx     # 0x46fdc
movl $0xa4, %edx
callq 0xb180
leaq 0x1aa7a(%rip), %rdi     # 0x4193c
leaq 0x1a2d5(%rip), %rsi     # 0x4119e
leaq 0x200bc(%rip), %rcx     # 0x46f8c
movl $0x3c, %edx
callq 0xb180
leaq 0x1feb2(%rip), %rdi     # 0x46d93
leaq 0x1fd49(%rip), %rsi     # 0x46c31
leaq 0x1ff29(%rip), %rcx     # 0x46e18
movl $0x3d, %edx
callq 0xb180
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/tracer/cnfnativetracer.hpp
// Function: bal::CnfNativeTracer::write_current_clause_action(char, unsigned int const*)
inline void write_current_clause_action(const char action, const uint32_t* const p_clause) {
            if (options_ & TRACE_CLAUSE_EVALUATIONS && p_cnf_ != nullptr) {
                _assert_level_0(p_clause != nullptr);
                write_action(action, 1);
                if (!is_current_clause(p_clause, CONTAINER_END)) {
                    write_clause(p_clause);
                };
                stream << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testb $0x2, 0x18(%rdi)
je 0x27189
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x27189
movq %rdx, -0x38(%rbp)
testq %rdx, %rdx
je 0x271b7
movl %esi, %r8d
movq 0x48(%rbx), %r15
movq 0x10(%rbx), %r12
movq 0x40(%rbx), %r14
movq (%r12), %rax
movq -0x18(%rax), %rcx
leaq (%r12,%rcx), %r13
cmpb $0x0, 0xe1(%r12,%rcx)
jne 0x270db
movq %r13, %rdi
movl $0x20, %esi
movl %r8d, -0x30(%rbp)
callq 0xb2a0
movl -0x30(%rbp), %r8d
movb $0x1, 0xe1(%r13)
movq (%r12), %rax
subq %r14, %r15
movb $0x2e, 0xe0(%r13)
movq -0x18(%rax), %rax
shlq $0x1e, %r15
movabsq $0x200000000, %rcx      # imm = 0x200000000
addq %r15, %rcx
sarq $0x20, %rcx
movq %rcx, 0x10(%r12,%rax)
leaq -0x29(%rbp), %rsi
movb %r8b, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0xb320
movq 0x40(%rbx), %rax
cmpq 0x48(%rbx), %rax
je 0x27198
movq 0x30(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x27198
movq -0x38(%rbp), %r14
cmpq %r14, -0x8(%rax)
je 0x2715e
movq 0x10(%rbx), %rdi
leaq -0x2a(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0xb320
movq 0x10(%rbx), %rdi
leaq 0x18c08(%rip), %rdx     # 0x3fd5e
movq %r14, %rsi
callq 0xf214
movq 0x10(%rbx), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fbf4(%rip), %rdi     # 0x46d93
leaq 0x1fa8b(%rip), %rsi     # 0x46c31
leaq 0x1fc0d(%rip), %rcx     # 0x46dba
movl $0x45, %edx
callq 0xb180
leaq 0x1fb1f(%rip), %rdi     # 0x46cdd
leaq 0x1fa6c(%rip), %rsi     # 0x46c31
leaq 0x1fcda(%rip), %rcx     # 0x46ea6
movl $0x32, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/cnf/cnf.hpp
// Function: bal::Cnf::get_variable_value(unsigned int) const
literalid_t get_variable_value(const variableid_t variableid) const override {
            uint32_t unit_clause[_clause_size_memory_size(1)] = _clause_c1_make(variable_t__literal_id(variableid));
            insertion_point_t insertion_point;
            __insertion_point_t_init(insertion_point);
            find(unit_clause, insertion_point);
            if (insertion_point.container_offset != CONTAINER_END) {
                return (_clauses_offset_flags(this->data_, insertion_point.container_offset) == 1) ? LITERAL_CONST_0 : LITERAL_CONST_1;
            } else {
                return LITERALID_UNASSIGNED;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leal 0x3(,%rsi,2), %eax
movl %eax, %ecx
shrl %ecx
decl %ecx
cmpl 0xb0(%rdi), %ecx
jae 0x272de
movq 0xa8(%rdi), %rdx
movl %ecx, %ecx
movl (%rdx,%rcx,4), %ecx
cmpl $-0x1, %ecx
je 0x272de
movq 0x80(%rdi), %rdx
leaq 0x35063(%rip), %rsi     # 0x5c2f4
movl (%rsi), %edi
incl %edi
movw $0x7fff, %r8w           # imm = 0x7FFF
movl %ecx, %r9d
leaq (%rdx,%r9,4), %r10
movl %edi, (%rsi)
movzwl 0xc(%r10), %r11d
andw %r8w, %r11w
je 0x272d1
leaq (%rdx,%r9,4), %r9
addq $0xc, %r9
movzwl %r11w, %ebx
cmpl (%r9,%rbx,4), %eax
jne 0x272c9
cmpw $0x1, %r11w
jne 0x272cb
jmp 0x272ef
jae 0x272d1
movl 0x8(%r10), %ecx
jmp 0x272d5
movl 0x4(%r10), %ecx
cmpl $-0x1, %ecx
je 0x272de
incl %edi
jmp 0x2729a
leaq 0x3500b(%rip), %rax     # 0x5c2f0
incl (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %rbp
retq
cmpl $-0x1, %ecx
jne 0x272fd
leaq 0x34ff5(%rip), %rax     # 0x5c2f0
jmp 0x27304
leaq 0x34fe8(%rip), %rax     # 0x5c2ec
incl (%rax)
cmpl $-0x1, %ecx
je 0x272e7
movzwl 0x2(%r9), %ecx
shll $0x10, %ecx
xorl %eax, %eax
cmpl $0x10000, %ecx          # imm = 0x10000
setne %al
jmp 0x272ec
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/bal/binarytreeindex.hpp
// Function: bal::AvlTreesIndex<unsigned int, true, &int bal::compare_clauses<false>(unsigned int const*, unsigned int const*), &unsigned int bal::clause_index_variable_id<false>(unsigned int const*)>::insertion_point_is_valid(bal::avl_tree_insertion_point_t const&) const
bool insertion_point_is_valid(const insertion_point_t& insertion_point) const override {
            bool result = base_t::insertion_point_is_valid(insertion_point);
            if (!result && insertion_point.version_stamp != CONTAINER_END && insertion_point.kind == btipkCurrent) {
                _assert_level_0(insertion_point.offset < this->size_);
                const CONTAINER_DATA_T* const p_item = _bti_item(this->data_, insertion_point.offset);
                if (_bti_item_parent_offset(p_item) != CONTAINER_END) {
                    const CONTAINER_DATA_T* const p_parent = _bti_item(this->data_, _bti_item_parent_offset(p_item));
                    result = (_bti_item_left_offset(p_parent) == insertion_point.offset) ||
                                (_bti_item_right_offset(p_parent) == insertion_point.offset);
                } else if _bti_item_parent_offset(p_item) {
                    const container_offset_t instance_offset = instance_determiner(_bti_item_container_item(p_item));
                    _assert_level_0(instance_offset < this->instances_.size_);
                    result = this->instances_.data_[instance_offset] == insertion_point.offset;
                };
            };
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x5c(%rdi), %ecx
movl 0x4(%rsi), %edx
cmpl %ecx, %edx
sete %al
cmpl $-0x1, %edx
je 0x27569
cmpl %ecx, %edx
je 0x27569
cmpl $0x3, 0x8(%rsi)
jne 0x27569
movl 0xc(%rsi), %ecx
cmpl 0x10(%rdi), %ecx
jae 0x2756b
movq 0x8(%rdi), %rdx
movl (%rdx,%rcx,4), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rsi
je 0x2753f
movb $0x1, %al
cmpl %ecx, 0x8(%rdx,%rsi,4)
je 0x27569
leaq (%rdx,%rsi,4), %rax
addq $0x4, %rax
jmp 0x27564
leaq (%rdx,%rcx,4), %rax
movl $0x7fff, %edx           # imm = 0x7FFF
andl 0xc(%rax), %edx
decl %edx
movl 0x10(%rax,%rdx,4), %eax
shrl %eax
decl %eax
cmpl 0x38(%rdi), %eax
jae 0x2758a
movl %eax, %eax
shlq $0x2, %rax
addq 0x30(%rdi), %rax
cmpl %ecx, (%rax)
sete %al
popq %rbp
retq
leaq 0x1a3ba(%rip), %rdi     # 0x4192c
leaq 0x1a1b4(%rip), %rsi     # 0x4172d
leaq 0x1fdaf(%rip), %rcx     # 0x4732f
movl $0x1d4, %edx            # imm = 0x1D4
callq 0xb180
leaq 0x1a790(%rip), %rdi     # 0x41d21
leaq 0x1a195(%rip), %rsi     # 0x4172d
leaq 0x1fd90(%rip), %rcx     # 0x4732f
movl $0x1dc, %edx            # imm = 0x1DC
callq 0xb180
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<unsigned int, unsigned int, bal::BinaryTreesIndexInstanceOffsetIterator<unsigned int, bal::avl_tree_insertion_point_t, true>, bal::avl_tree_insertion_point_t>::rollback(unsigned int, unsigned int, unsigned int)
virtual void rollback(const container_size_t size,
                              const container_size_t instances_size,
                              const container_size_t container_size) {
            assert(size != CONTAINER_END && this->size_ >= size);
            assert(instances_.size_ >= instances_size);
            this->size_ = size;
            instances_.size_ = instances_size;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, %esi
je 0x27725
cmpl %esi, 0x10(%rdi)
jb 0x27725
cmpl %edx, 0x38(%rdi)
jb 0x27744
movl %esi, 0x10(%rdi)
movl %edx, 0x38(%rdi)
popq %rbp
retq
leaq 0x1f912(%rip), %rdi     # 0x4703e
leaq 0x1a2b1(%rip), %rsi     # 0x419e4
leaq 0x1f931(%rip), %rcx     # 0x4706b
movl $0x3f, %edx
callq 0xb180
leaq 0x1fb1e(%rip), %rdi     # 0x47269
leaq 0x1a292(%rip), %rsi     # 0x419e4
leaq 0x1f912(%rip), %rcx     # 0x4706b
movl $0x40, %edx
callq 0xb180
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>::is_constant() const
bool is_constant() const override {
            for (auto i = 0; i < N_; i++) {
                if (bits_[i] == nullptr || !bits_[i]->is_constant()) {
                    return false;
                };
            };
            return true;
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x28583
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r12
xorl %eax, %eax
btl %r13d, %r14d
setb %al
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x285a2
incq %r13
addq $0x8, %r15
cmpq $0x1f, %r13
jne 0x28537
leaq -0x30(%rbp), %rsi
movl $0x0, (%rsi)
addq $0x128, %rbx            # imm = 0x128
movq %rbx, %rdi
callq 0x28604
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f52a(%rip), %rdi     # 0x47ab4
leaq 0x1f52e(%rip), %rsi     # 0x47abf
leaq 0x1f53f(%rip), %rcx     # 0x47ad7
movl $0x35, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: int bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>::assign_to<int, 0>() const
T assign_to() const {
            T value = 0;
            constexpr T T_MAX_SIZE = size_in_bits_(std::numeric_limits<T>::max());
            if (T_MAX_SIZE < N_) {
                // assigning to a shorter type
                auto i = 0;
                T max_i = std::numeric_limits<T>::max();
                while (max_i > 0) {
                    if ((bool)bits_[i]) {
                        value |= 0b1 << i;
                    };
                    max_i >>= 1;
                    i++;
                };
                while (i < N_) {
                    _assert_level_0((bool)bits_[i] == false);
                    i++;
                };
            } else {
                // assigning to a longer type or a same sized type
                for (auto i = 0; i < N_; i++) {
                    if ((bool)bits_[i]) {
                        value |= 0b1 << i;
                    };
                };
            };
            return value;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x30(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x1, %edx
movl %r15d, %ecx
shll %cl, %edx
testb %al, %al
cmovel %r12d, %edx
orl %edx, %ebx
incq %r15
cmpq $0x1f, %r15
jne 0x286d2
movq 0x128(%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
jne 0x28714
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f575(%rip), %rdi     # 0x47c90
leaq 0x1f39d(%rip), %rsi     # 0x47abf
leaq 0x1f57f(%rip), %rcx     # 0x47ca8
movl $0x66, %edx
callq 0xb180
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/io/cnfdimacs.hpp
// Function: bal::DimacsStreamWriter::write(bal::Cnf const&)
void write(const Cnf& value) override {
            write_parameters(value);
            write_variables(value);
            write_header(value);
            write_clauses(value);
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
callq 0x3b4da
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x28d88
movq 0x18(%r15), %r15
leaq -0x98(%rbp), %r14
cmpq %r14, %r15
je 0x28a7f
leaq 0x1f62d(%rip), %r12     # 0x4807a
leaq 0x20(%r15), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xb0b0
testl %eax, %eax
je 0x28a6f
leaq 0x40(%r15), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x28ce2
movq %r15, %rdi
callq 0xb330
movq %rax, %r15
cmpq %r14, %rax
jne 0x28a4d
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb %al, %al
jne 0x28b07
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1f5e5(%rip), %rsi     # 0x48081
leaq 0x1f621(%rip), %rdx     # 0x480c4
leaq -0x50(%rbp), %rdi
callq 0x1dab2
leaq 0x1f612(%rip), %rsi     # 0x480c5
leaq -0x50(%rbp), %rdi
callq 0xb530
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f5af(%rip), %rsi     # 0x4807a
leaq 0x1f5ae(%rip), %rdx     # 0x48080
leaq -0x70(%rbp), %rdi
callq 0x1dab2
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
callq 0x28ce2
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x28af9
callq 0xb280
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x28b07
callq 0xb280
leaq -0xa0(%rbp), %rdi
callq 0x26354
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x28b3a
callq 0xb280
jmp 0x28b3a
jmp 0x28b37
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x28b51
callq 0xb280
jmp 0x28b51
jmp 0x28b4e
jmp 0x28b4e
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x26354
movq %rbx, %rdi
callq 0xb4e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::CnfVigStreamWriter<false, false>::write(bal::Cnf const&)
void write(const Cnf& value) override {
            edges_data_t edges;
            unsigned next_edge_id = 0;
            compute_edges(value, TIMESTAMP_MIN, edges, next_edge_id);
            
            write_header(value);
            write_nodes(value, edges);
            write_edges(value, edges);
            write_footer(value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq -0x14(%rbp), %r8
movl %ecx, (%r8)
movq (%rdi), %rax
leaq -0x48(%rbp), %rcx
xorl %edx, %edx
callq *0x38(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%rax)
movq (%r14), %rax
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r14), %rax
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
leaq -0x48(%rbp), %rdi
callq 0x2a36e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2a36e
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/io/cnfgraphml.hpp
// Function: bal::CnfGraphMLStreamWriter<true>::write_edge(unsigned int, unsigned int, bal::CnfVigStreamWriter<true, false>::__edge_data_t const&)
void write_edge(const variableid_t source_id, const variableid_t target_id, const edge_data_t& edge) override {
            if (WEIGHTED) {
                stream << "<edge source=\"v" << literal_t(variable_t__literal_id(source_id)) << "\" target=\"v" << literal_t(variable_t__literal_id(target_id)) << "\">" << std::endl;
                CnfGraphMLStreamWriter_write_edge_weighted<WEIGHTED>(stream, edge);
                stream << "</edge>" << std::endl;
            } else {
                stream << "<edge source=\"v" << literal_t(variable_t__literal_id(source_id)) << "\" target=\"v" << literal_t(variable_t__literal_id(target_id)) << "\"/>" << std::endl;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x10(%rdi), %r13
leaq 0x1d9a9(%rip), %rsi     # 0x483ee
movl $0xf, %edx
movq %r13, %rdi
callq 0xb320
leal 0x3(,%r12,2), %eax
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movq %r13, %rdi
callq 0xf3a7
movq %rax, %r12
leaq 0x1d98c(%rip), %rsi     # 0x483fe
movl $0xb, %edx
movq %rax, %rdi
callq 0xb320
leal 0x3(,%r15,2), %eax
leaq -0x2c(%rbp), %rsi
movl %eax, (%rsi)
movq %r12, %rdi
callq 0xf3a7
movq %rax, %r15
leaq 0x1db62(%rip), %rsi     # 0x48601
movl $0x2, %edx
movq %rax, %rdi
callq 0xb320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1e04b
movq 0x10(%rbx), %rbx
leaq 0x1b82b(%rip), %rsi     # 0x46315
movl $0x7, %edx
movq %rbx, %rdi
callq 0xb320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb2a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/io/cnfvig.hpp
// Function: bal::edge_weight_data_t<true>::update(unsigned int, bal::edge_action_t, unsigned int)
void update(const uint32_t clause_header, const edge_action_t action, const timestamp_t timestamp) {
            const clause_size_t clause_size = _clause_header_size(clause_header);
            const unsigned clause_cardinality = clause_size < 4 ?
                get_cardinality_uint16(_clause_header_flags(clause_header)) : 1;
            const double clause_weight = 2.0 * clause_cardinality / clause_size / (clause_size - 1);
            
            switch(action) {
                case eaInsert:
                case eaUpdate:
                    cardinality += clause_cardinality;
                    weight += clause_weight;
                    break;
                case eaRemove:
                    _assert_level_0(cardinality >= clause_cardinality);
                    cardinality -= clause_cardinality;
                    weight -= clause_weight;
                    break;
            };
        }

// Assembly:
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movl $0x1, %ecx
cmpl $0x3, %eax
ja 0x2b5a2
movl %esi, %ecx
shrl $0xf, %ecx
andl $0x1e, %ecx
leaq 0x1974c(%rip), %r8      # 0x44cc0
movl %esi, %r9d
shrl $0x13, %r9d
andl $0x1e, %r9d
movzwl (%r9,%r8), %r9d
addw (%rcx,%r8), %r9w
movl %esi, %ecx
shrl $0x17, %ecx
andl $0x1e, %ecx
addw (%rcx,%r8), %r9w
shrl $0x1c, %esi
addw (%r8,%rsi,2), %r9w
movzwl %r9w, %ecx
leal (%rcx,%rcx), %esi
cvtsi2sd %esi, %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
decl %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
cmpl $0x2, %edx
jae 0x2b5d0
addl %ecx, (%rdi)
addsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
retq
jne 0x2b5e8
movl (%rdi), %eax
subl %ecx, %eax
jb 0x2b5e9
movl %eax, (%rdi)
movsd 0x8(%rdi), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1cea9(%rip), %rdi     # 0x4849d
leaq 0x1cec4(%rip), %rsi     # 0x484bf
leaq 0x1ced5(%rip), %rcx     # 0x484d7
movl $0x50, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: bal::CnfGexfStreamWriter<false, true>::write_edge(unsigned int, unsigned int, bal::CnfVigStreamWriter<false, true>::__edge_data_t const&)
void write_edge(const variableid_t source_id, const variableid_t target_id, const edge_data_t& edge) override {
            stream << "<edge id=\"" << edge.id << "\"";
            stream << " source=\"" << literal_t(variable_t__literal_id(source_id)) << "\"";
            stream << " target=\"" << literal_t(variable_t__literal_id(target_id)) << "\"";
            CnfGexfStreamWriter_write_edge_dynamic(stream, edge);
            CnfGexfStreamWriter_write_edge_weighted(stream, edge);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, -0x30(%rbp)
movl %esi, %r13d
movq %rdi, %r14
movq 0x10(%rdi), %r12
leaq 0x16376(%rip), %rsi     # 0x488ed
movl $0xa, %edx
movq %r12, %rdi
callq 0xb320
movl 0xc(%rbx), %esi
movq %r12, %rdi
callq 0xb190
leaq 0x18446(%rip), %r12     # 0x4a9dc
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb320
movq 0x10(%r14), %r15
leaq 0x16347(%rip), %rsi     # 0x488f8
movl $0x9, %edx
movq %r15, %rdi
callq 0xb320
leal 0x3(,%r13,2), %eax
leaq -0x38(%rbp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0xf3a7
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb320
movq 0x10(%r14), %r15
leaq 0x16313(%rip), %rsi     # 0x48902
movl $0x9, %edx
movq %r15, %rdi
callq 0xb320
movq -0x30(%rbp), %rax
leal 0x3(,%rax,2), %eax
leaq -0x34(%rbp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0xf3a7
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb320
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x1dfc0
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x2c191
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/cnf/io/cnfgexf.hpp
// Function: bal::CnfGexfStreamWriter<false, false>::current_date_string[abi:cxx11]()
std::string current_date_string() {
            std::time_t t = std::time(nullptr);
            char mbstr[100];
            if (std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%d", std::localtime(&t))) {
                return std::string(mbstr);
            } else {
                return "";
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0xb260
leaq -0x18(%rbp), %rdi
movq %rax, (%rdi)
callq 0xb200
leaq 0x1c671(%rip), %rdx     # 0x487ab
leaq -0x80(%rbp), %rdi
movl $0x64, %esi
movq %rax, %rcx
callq 0xb220
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testq %rax, %rax
je 0x2c173
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0xb110
leaq (%rax,%rbp), %rdx
addq $-0x80, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x2c180
leaq 0x1fb5a(%rip), %rdx     # 0x4bcd4
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1dab2
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/anf/anfpolybori.hpp
// Function: bal::PolyBoRiStreamWriter::write(bal::Anf const&)
void write(const Anf& value) override {
            write_header(value);
            write_parameters(value);
            write_variables(value);
            write_equations(value);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2c210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c2a4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c3b0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2c478
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Literal<bal::Anf>::from_literal(bal::Anf*, unsigned int)
static Ref<Literal> from_literal(FORMULA_T* const formula, const literalid_t value) {
            if (literal_t__is_variable(value)) {
                return new Literal(formula, value);
            } else {
                return value;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movl %edx, -0x24(%rbp)
leal -0x2(%r14), %eax
cmpl $-0x4, %eax
ja 0x2d995
movq %rsi, %r15
movl $0x40, %edi
callq 0xb2c0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x2e6e4
movq %r12, (%rbx)
movq (%r12), %rax
movq -0x20(%rax), %rax
incl 0x8(%r12,%rax)
jmp 0x2d9a8
movq $0x0, (%rbx)
leaq -0x24(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e4aa
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/formulatracer.hpp
// Function: bal::FormulaTracer<32ul, bal::Literal<bal::Anf>>::trace(char const*, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> const&)
void trace(const char* const name, const Ref<GF2NElement<N, GF2E>>& value) override {
            Tracer<N, GF2E>::trace(name, value);
            VariablesArray array = variables_array(value);
#ifdef TRACER_LOG_COUT
            std::cout << name << ": " << array << std::endl;
#endif
            formula_.add_named_variable(name, array);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movl $0x20, %esi
callq 0xe6e4
movl $0x20, 0x1c(%r12)
movq (%r12), %rax
movq (%r15), %rcx
movl $0x25, %edx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x2e9d6
movl 0x20(%rsi), %esi
movl %esi, (%rax)
decq %rdx
addq $0x4, %rax
cmpq $0x5, %rdx
jne 0x2e98a
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rdx
movq %rbx, %rsi
callq 0x3af60
cmpl $0x0, -0x28(%rbp)
je 0x2e9c9
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2e9c9
callq 0xb350
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a810(%rip), %rdi     # 0x491ed
leaq 0x19433(%rip), %rsi     # 0x47e17
leaq 0x1a824(%rip), %rcx     # 0x4920f
movl $0x188, %edx            # imm = 0x188
callq 0xb180
movq %rax, %rbx
cmpl $0x0, -0x28(%rbp)
je 0x2ea0c
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2ea0c
callq 0xb350
movq %rbx, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/formulatracer.hpp
// Function: bal::FormulaTracer<32ul, bal::Literal<bal::Anf>>::trace(char const*, unsigned long, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> const&)
void trace(const char* const name, const size_t index, const Ref<GF2NElement<N, GF2E>>& value) override {
            Tracer<N, GF2E>::trace(name, index, value);
            VariablesArray array = variables_array(value);
#ifdef TRACER_LOG_COUT
            std::cout << name << "[" << index << "]: " << array << std::endl;
#endif
            formula_.add_named_variable(name, array, (variables_size_t)index);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movl $0x20, %esi
callq 0xe6e4
movl $0x20, 0x1c(%r13)
movq (%r13), %rax
movq (%r12), %rcx
movl $0x25, %edx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x2eaa7
movl 0x20(%rsi), %esi
movl %esi, (%rax)
decq %rdx
addq $0x4, %rax
cmpq $0x5, %rdx
jne 0x2ea57
movq 0x8(%r15), %rdi
leaq -0x48(%rbp), %rdx
movq %r14, %rsi
movl %ebx, %ecx
callq 0x3b05c
cmpl $0x0, -0x30(%rbp)
je 0x2ea98
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x2ea98
callq 0xb350
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a73f(%rip), %rdi     # 0x491ed
leaq 0x19362(%rip), %rsi     # 0x47e17
leaq 0x1a753(%rip), %rcx     # 0x4920f
movl $0x188, %edx            # imm = 0x188
callq 0xb180
movq %rax, %rbx
cmpl $0x0, -0x30(%rbp)
je 0x2eadd
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x2eadd
callq 0xb350
movq %rbx, %rdi
callq 0xb4e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./acl/sha1.hpp
// Function: acl::SHA1<bal::Literal<bal::Anf>>::f(unsigned int, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>&, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>&, bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>>&)
const Ref<Word> f(unsigned int t, Ref<Word> &b, Ref<Word> &c, Ref<Word> &d) {
            switch (t / 20) {
                case 0: return ch(b, c, d);
                case 1: return parity(b, c, d);
                case 2: return maj(b, c, d);
                case 3: return parity(b, c, d);
                default:
                    assert(false);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %edx
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rdx, %rax
shrq $0x24, %rax
cmpl $0x3, %eax
ja 0x2eb5a
movq %rdi, %rbx
leaq 0x177a6(%rip), %rdx     # 0x462b0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq (%rcx), %rdx
movq (%r8), %rcx
movq (%r9), %r8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2f82d
jmp 0x2eb50
movq (%rcx), %rdx
movq (%r8), %rcx
movq (%r9), %r8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2f261
jmp 0x2eb50
movq (%rcx), %rdx
movq (%r8), %rcx
movq (%r9), %r8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2f8cd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x19141(%rip), %rdi     # 0x47ca2
leaq 0x1a74e(%rip), %rsi     # 0x492b6
leaq 0x1a956(%rip), %rcx     # 0x494c5
movl $0x29, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::rotr<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, int)
Ref<GF2NElement<N, GF2E>> rotr(GF2NElement<N, GF2E>* const r,
                                   const GF2NElement<N, GF2E>* const value, const int n) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            (*result)[i] = (*value)[(i + n) % N];
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
callq 0x2eddc
movl $0x30, %r12d
movl %ebx, %eax
andl $0x1f, %eax
movq (%r15), %rdi
addq %r12, %rdi
movq 0x30(%r14,%rax,8), %rsi
callq 0x2e56e
incl %ebx
addq $0x8, %r12
cmpq $0x130, %r12            # imm = 0x130
jne 0x2edac
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/bal/referenceable.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::new_instance_if_unassigned<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>, 0>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*)
Ref<T> new_instance_if_unassigned(T* const value) {
        Ref<T> result = value;
        if (value == nullptr) {
            new_instance(result);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
testq %rsi, %rsi
je 0x2edfb
movq (%rsi), %rax
movq -0x20(%rax), %rax
incl 0x8(%rsi,%rax)
jmp 0x2ee03
movq %rbx, %rdi
callq 0x2ee26
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2ee1e
movq %rbx, %rsi
callq 0xb8d2
movq %r14, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::eor<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const* const*, unsigned long)
Ref<GF2NElement<N, GF2E>> eor(GF2NElement<N, GF2E>* const r,
                                  const GF2NElement<N, GF2E>* const args[], const std::size_t args_size) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            const GF2E* args_i[args_size];
            for (auto j = 0; j < args_size; j++) {
                args_i[j] = (*args[j])[i];
            };
            (*result)[i] = eor((*result)[i].data(), args_i, args_size);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x2eddc
xorl %r13d, %r13d
leaq 0xf(,%r14,8), %rax
andq $-0x10, %rax
movq %rax, -0x30(%rbp)
movq %rsp, %r12
movq %rsp, %rdx
subq -0x30(%rbp), %rdx
movq %rdx, %rsp
testq %r14, %r14
je 0x2ef1f
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movq 0x30(%rcx,%r13,8), %rcx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x2ef0a
movq (%rbx), %rax
movq 0x30(%rax,%r13,8), %rsi
leaq -0x38(%rbp), %rdi
movq %r14, %rcx
callq 0x2ef78
movq %r12, %rsp
movq (%rbx), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x30(%rax,%r13,8)
incq %r13
cmpq $0x20, %r13
jne 0x2eef6
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2ef70
movq %rbx, %rsi
callq 0xb909
movq %r14, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::update_formula(bal::Anf*&, bal::Literal<bal::Anf> const*)
void update_formula(FORMULA_T*& formula, const Literal* const instance) {
            _assert_level_0(instance != nullptr);
            if (instance->formula != nullptr) {
                _assert_level_1(formula == nullptr || formula == instance->formula);
                formula = instance->formula;
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x2f102
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x2f100
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
cmpq %rax, %rcx
sete %cl
orb %dl, %cl
je 0x2f121
movq %rax, (%rdi)
popq %rbp
retq
leaq 0x1a28f(%rip), %rdi     # 0x49398
leaq 0x18d07(%rip), %rsi     # 0x47e17
leaq 0x1a295(%rip), %rcx     # 0x493ac
movl $0x57, %edx
callq 0xb180
leaq 0x1a2cc(%rip), %rdi     # 0x493f4
leaq 0x18ce8(%rip), %rsi     # 0x47e17
leaq 0x1a276(%rip), %rcx     # 0x493ac
movl $0x59, %edx
callq 0xb180
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/gf2n.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Anf>>> bal::ch<32ul, bal::Literal<bal::Anf>>(bal::GF2NElement<32ul, bal::Literal<bal::Anf>>*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*, bal::GF2NElement<32ul, bal::Literal<bal::Anf>> const*)
Ref<GF2NElement<N, GF2E>> ch(GF2NElement<N, GF2E>* const r,
                                 const GF2NElement<N, GF2E>* const x,
                                 const GF2NElement<N, GF2E>* const y,
                                 const GF2NElement<N, GF2E>* const z) {
        Ref<GF2NElement<N, GF2E>> result = new_instance_if_unassigned(r);
        for (auto i = 0; i < N; i++) {
            (*result)[i] = ch((*result)[i].data(), (*x)[i].data(), (*y)[i].data(), (*z)[i].data());
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
callq 0x2eddc
movq (%rbx), %rax
xorl %r13d, %r13d
movq 0x30(%rax,%r13), %rsi
movq 0x30(%r12,%r13), %rdx
movq 0x30(%r15,%r13), %rcx
movq 0x30(%r14,%r13), %r8
leaq -0x30(%rbp), %rdi
callq 0x2f2e9
movq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax,%r13)
addq $0x8, %r13
cmpq $0x100, %r13            # imm = 0x100
jne 0x2f286
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2f2e1
movq %rbx, %rsi
callq 0xb940
movq %r14, %rdi
callq 0xb4e0
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Ref<bal::Literal<bal::Anf>> bal::inv<bal::Anf>(bal::Literal<bal::Anf>*, bal::Literal<bal::Anf> const*)
Ref<Literal<FORMULA_T>> inv(Literal<FORMULA_T>* const r,
                                const Literal<FORMULA_T>* const x) {
        if (literal_t__is_variable(x->value)) {
            return new Literal<FORMULA_T>(x->formula, literal_t__negated(x->value));
        } else if (literal_t__is_constant(x->value)) {
            return literal_t__negated(x->value);
        } else if (literal_t__is_unassigned(x->value)) {
            return x->value;
        } else {
            _assert_level_0(false);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movl 0x20(%rdx), %r14d
leal 0x1(%r14), %eax
cmpl $0x3, %eax
jae 0x2f5f2
cmpl $0x1, %r14d
ja 0x2f5da
xorl $0x1, %r14d
leaq -0x24(%rbp), %rsi
movl %r14d, (%rsi)
movq $0x0, (%rbx)
movq %rbx, %rdi
jmp 0x2f5eb
addq $0x20, %r15
movq $0x0, (%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e4aa
jmp 0x2f622
movl $0x40, %edi
callq 0xb2c0
movq %rax, %r12
movq 0x18(%r15), %rsi
xorl $0x1, %r14d
movq %rax, %rdi
movl %r14d, %edx
callq 0x2e6e4
movq %r12, (%rbx)
movq (%r12), %rax
movq -0x20(%rax), %rax
incl 0x8(%r12,%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/vsklad[P]cgen/./bal/encoding/literal.hpp
// Function: bal::Ref<bal::Literal<bal::Anf>> bal::con2<bal::Anf>(bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*, bal::Literal<bal::Anf>*)
Ref<Literal<FORMULA_T>> con2(Literal<FORMULA_T>* const r,
                                 Literal<FORMULA_T>* const x, Literal<FORMULA_T>* const y) {
        if (x->value == y->value) {
            return x;
        } else if (literal_t__is_negation_of(x->value, y->value)) {
            return 0;
        } else if (literal_t__is_constant_0(x->value) || literal_t__is_constant_0(y->value)) {
            return 0;
        } else if (literal_t__is_constant_1(x->value)) {
            return y;
        } else if (literal_t__is_constant_1(y->value)) {
            return x;
        } else {
            _assert_level_1(x->formula != nullptr && x->formula == y->formula);
            const literalid_t r_value = x->formula->new_variable_literal();
            con2(x->formula, r_value, x->value, y->value);
            return new Literal<FORMULA_T>(x->formula, r_value);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movl 0x20(%rdx), %ecx
movl 0x20(%r15), %eax
cmpl %eax, %ecx
jne 0x2f666
movq %r14, (%rbx)
movq (%r14), %rax
movq -0x20(%rax), %rax
incl 0x8(%r14,%rax)
jmp 0x2f69e
movl %eax, %edx
xorl %ecx, %edx
cmpl $0x1, %edx
jne 0x2f675
leaq -0x28(%rbp), %rsi
jmp 0x2f689
testl %ecx, %ecx
setne %dl
testl %eax, %eax
setne %sil
testb %sil, %dl
jne 0x2f6ae
leaq -0x24(%rbp), %rsi
movl $0x0, (%rsi)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x2e50c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %ecx
je 0x2f6ff
cmpl $0x1, %eax
je 0x2f655
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x2f710
cmpq 0x18(%r15), %rdi
jne 0x2f710
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %r12d
movq 0x18(%r14), %rdi
movl 0x20(%r14), %edx
movl 0x20(%r15), %ecx
movl %eax, %esi
callq 0xeab5
movl $0x40, %edi
callq 0xb2c0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
movl %r12d, %edx
callq 0x2e6e4
movq %r15, (%rbx)
movq (%r15), %rax
movq -0x20(%rax), %rax
incl 0x8(%r15,%rax)
jmp 0x2f69e
leaq 0x19f28(%rip), %rdi     # 0x4963f
leaq 0x186f9(%rip), %rsi     # 0x47e17
leaq 0x19f4c(%rip), %rcx     # 0x49671
movl $0xf8, %edx
callq 0xb180