LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::eor(bal::Cnf*, unsigned int, unsigned int const*, unsigned long)
void eor(Cnf* const formula, const literalid_t r, const literalid_t args[], const std::size_t args_size) {
        // more than one variable, generate 2^(N-1) clauses
        _assert_level_0(formula != nullptr);
        _assert_level_1(args_size > 1 && args_size < MAX_XOR_SIZE); // args_size + 1 for result
        literalid_t clause_args[args_size + 1];
        
        for (uint32_t i = 0; i < (1 << args_size); i++) {
            // i bits can be used to determine the negation and the result
            literalid_t constant = 0b0;
            for (auto j = 0; j < args_size; j++) {
                clause_args[j] = literal_t__negated_onlyif(args[j], i & (0x1 << j));
                literal_t__negate_onlyif(constant, i & (0x1 << j));
            };
            clause_args[args_size] = literal_t__negated_onlyif(r, literal_t__is_constant_0(constant));
            formula->append_clause(clause_args, args_size + 1);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
testq %rdi, %rdi
je 0x10866
movq %rcx, %rbx
leaq -0x2(%rcx), %rax
cmpq $0x1e, %rax
jae 0x10885
movq %rdx, %r14
leal 0x1(%rbx), %eax
movq %rsp, %r13
leaq 0x13(,%rbx,4), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
addq $0x78, -0x38(%rbp)
xorl %r12d, %r12d
movzwl %ax, %r15d
testq %rbx, %rbx
je 0x1082d
xorl %eax, %eax
xorl %esi, %esi
movl %esi, %ecx
xorl %edx, %edx
btl %eax, %r12d
setb %dl
movl (%r14,%rax,4), %esi
xorl %edx, %esi
movl %esi, (%r13,%rax,4)
movl %edx, %esi
xorl %ecx, %esi
incq %rax
cmpq %rax, %rbx
jne 0x10802
xorl %eax, %eax
cmpl %ecx, %edx
sete %al
jmp 0x10832
movl $0x1, %eax
xorl -0x2c(%rbp), %eax
movl %eax, (%r13,%rbx,4)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x10fec
incl %r12d
movl %r12d, %eax
movl %ebx, %ecx
shrl %cl, %eax
testl %eax, %eax
je 0x107f9
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3bf93(%rip), %rdi     # 0x4c800
leaq 0x31540(%rip), %rsi     # 0x41db4
leaq 0x3155c(%rip), %rcx     # 0x41dd7
movl $0x10, %edx
callq 0xc180
leaq 0x315a0(%rip), %rdi     # 0x41e2c
leaq 0x31521(%rip), %rsi     # 0x41db4
leaq 0x3153d(%rip), %rcx     # 0x41dd7
movl $0x11, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::con2(bal::Cnf*, unsigned int, unsigned int, unsigned int)
void con2(Cnf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_1(formula != nullptr);
        _assert_level_1(literal_t__is_variable(r));
        _assert_level_1(literal_t__is_variable(x));
        _assert_level_1(literal_t__is_variable(y));
        formula->append_clause_l(literal_t__negated(x), literal_t__negated(y), r);
        formula->append_clause_l(x, literal_t__negated(r));
        formula->append_clause_l(y, literal_t__negated(r));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1096b
movl %esi, %r15d
leal -0x2(%r15), %eax
cmpl $-0x3, %eax
jae 0x1098a
movl %edx, %r12d
leal -0x2(%r12), %eax
cmpl $-0x3, %eax
jae 0x109a9
movl %ecx, %r14d
leal -0x2(%r14), %eax
cmpl $-0x3, %eax
jae 0x109c8
movq %rdi, %rbx
addq $0x78, %rbx
movl %r12d, %eax
xorl $0x1, %eax
movl %r14d, %ecx
xorl $0x1, %ecx
leaq -0x34(%rbp), %r13
movl %eax, (%r13)
movl %ecx, 0x4(%r13)
movl %r15d, 0x8(%r13)
movq %rbx, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq 0x10fec
xorl $0x1, %r15d
movl %r12d, (%r13)
movl %r15d, 0x4(%r13)
leaq -0x34(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x10fec
movl %r14d, (%r12)
movl %r15d, 0x4(%r12)
leaq -0x34(%rbp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x10fec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3be8e(%rip), %rdi     # 0x4c800
leaq 0x3143b(%rip), %rsi     # 0x41db4
leaq 0x314d6(%rip), %rcx     # 0x41e56
movl $0x21, %edx
callq 0xc180
leaq 0x31519(%rip), %rdi     # 0x41eaa
leaq 0x3141c(%rip), %rsi     # 0x41db4
leaq 0x314b7(%rip), %rcx     # 0x41e56
movl $0x22, %edx
callq 0xc180
leaq 0x3153a(%rip), %rdi     # 0x41eea
leaq 0x313fd(%rip), %rsi     # 0x41db4
leaq 0x31498(%rip), %rcx     # 0x41e56
movl $0x23, %edx
callq 0xc180
leaq 0x3155b(%rip), %rdi     # 0x41f2a
leaq 0x313de(%rip), %rsi     # 0x41db4
leaq 0x31479(%rip), %rcx     # 0x41e56
movl $0x24, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::dis2(bal::Cnf*, unsigned int, unsigned int, unsigned int)
void dis2(Cnf* const formula, const literalid_t r, const literalid_t x, const literalid_t y) {
        _assert_level_1(formula != nullptr);
        _assert_level_1(literal_t__is_variable(r));
        _assert_level_1(literal_t__is_variable(x));
        _assert_level_1(literal_t__is_variable(y));
        formula->append_clause_l(x, y, literal_t__negated(r));
        formula->append_clause_l(literal_t__negated(x), r);
        formula->append_clause_l(literal_t__negated(y), r);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x10aac
movl %esi, %r15d
leal -0x2(%r15), %eax
cmpl $-0x3, %eax
jae 0x10acb
movl %edx, %r12d
leal -0x2(%r12), %eax
cmpl $-0x3, %eax
jae 0x10aea
movl %ecx, %r14d
leal -0x2(%r14), %eax
cmpl $-0x3, %eax
jae 0x10b09
movq %rdi, %rbx
addq $0x78, %rbx
movl %r15d, %eax
xorl $0x1, %eax
leaq -0x34(%rbp), %r13
movl %r12d, (%r13)
movl %r14d, 0x4(%r13)
movl %eax, 0x8(%r13)
movq %rbx, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq 0x10fec
xorl $0x1, %r12d
movl %r12d, (%r13)
movl %r15d, 0x4(%r13)
leaq -0x34(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x10fec
xorl $0x1, %r14d
movl %r14d, (%r12)
movl %r15d, 0x4(%r12)
leaq -0x34(%rbp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x10fec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3bd4d(%rip), %rdi     # 0x4c800
leaq 0x312fa(%rip), %rsi     # 0x41db4
leaq 0x314a9(%rip), %rcx     # 0x41f6a
movl $0x2b, %edx
callq 0xc180
leaq 0x313d8(%rip), %rdi     # 0x41eaa
leaq 0x312db(%rip), %rsi     # 0x41db4
leaq 0x3148a(%rip), %rcx     # 0x41f6a
movl $0x2c, %edx
callq 0xc180
leaq 0x313f9(%rip), %rdi     # 0x41eea
leaq 0x312bc(%rip), %rsi     # 0x41db4
leaq 0x3146b(%rip), %rcx     # 0x41f6a
movl $0x2d, %edx
callq 0xc180
leaq 0x3141a(%rip), %rdi     # 0x41f2a
leaq 0x3129d(%rip), %rsi     # 0x41db4
leaq 0x3144c(%rip), %rcx     # 0x41f6a
movl $0x2e, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::ch(bal::Cnf*, unsigned int, unsigned int, unsigned int, unsigned int)
void ch(Cnf* const formula, const literalid_t r, const literalid_t x, const literalid_t y, const literalid_t z) {
        _assert_level_1(formula != nullptr);
        _assert_level_1(literal_t__is_variable(r));
        _assert_level_1(literal_t__is_variable(x));
        _assert_level_1(literal_t__is_variable(y));
        _assert_level_1(literal_t__is_variable(z));
        formula->append_clause_l(literal_t__negated(x), y, literal_t__negated(r));
        formula->append_clause_l(x, z, literal_t__negated(r));
        formula->append_clause_l(literal_t__negated(x), literal_t__negated(y), r);
        formula->append_clause_l(x, literal_t__negated(z), r);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x10c30
leal -0x2(%rsi), %eax
cmpl $-0x3, %eax
jae 0x10c4f
leal -0x2(%rdx), %eax
cmpl $-0x3, %eax
jae 0x10c6e
movl %ecx, %r13d
leal -0x2(%r13), %eax
cmpl $-0x3, %eax
jae 0x10c8d
leal -0x2(%r8), %eax
cmpl $-0x3, %eax
movq %r8, -0x58(%rbp)
jae 0x10cac
addq $0x78, %rdi
movl %edx, %r12d
xorl $0x1, %r12d
movl %esi, %r14d
xorl $0x1, %r14d
leaq -0x34(%rbp), %r15
movl %r12d, (%r15)
movl %r13d, 0x4(%r15)
movl %r14d, 0x8(%r15)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %r15, %rsi
movq %rdx, %rbx
movq %rdx, -0x50(%rbp)
movl $0x3, %edx
callq 0x10fec
movl %ebx, (%r15)
movq -0x58(%rbp), %rbx
movl %ebx, 0x4(%r15)
movl %r14d, 0x8(%r15)
movq -0x40(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0x10fec
xorl $0x1, %r13d
movl %r12d, (%r15)
movl %r13d, 0x4(%r15)
movq -0x48(%rbp), %r12
movl %r12d, 0x8(%r15)
movq %r14, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0x10fec
xorl $0x1, %ebx
movq -0x50(%rbp), %rax
movl %eax, (%r15)
movl %ebx, 0x4(%r15)
movl %r12d, 0x8(%r15)
leaq -0x34(%rbp), %rsi
movq %r14, %rdi
movl $0x3, %edx
callq 0x10fec
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3bbc9(%rip), %rdi     # 0x4c800
leaq 0x31176(%rip), %rsi     # 0x41db4
leaq 0x31379(%rip), %rcx     # 0x41fbe
movl $0x38, %edx
callq 0xc180
leaq 0x31254(%rip), %rdi     # 0x41eaa
leaq 0x31157(%rip), %rsi     # 0x41db4
leaq 0x3135a(%rip), %rcx     # 0x41fbe
movl $0x39, %edx
callq 0xc180
leaq 0x31275(%rip), %rdi     # 0x41eea
leaq 0x31138(%rip), %rsi     # 0x41db4
leaq 0x3133b(%rip), %rcx     # 0x41fbe
movl $0x3a, %edx
callq 0xc180
leaq 0x31296(%rip), %rdi     # 0x41f2a
leaq 0x31119(%rip), %rsi     # 0x41db4
leaq 0x3131c(%rip), %rcx     # 0x41fbe
movl $0x3b, %edx
callq 0xc180
leaq 0x31370(%rip), %rdi     # 0x42023
leaq 0x310fa(%rip), %rsi     # 0x41db4
leaq 0x312fd(%rip), %rcx     # 0x41fbe
movl $0x3c, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/encoding/cnfencoding.cpp
// Function: bal::add(bal::Cnf&, unsigned int*, unsigned long, unsigned long, unsigned int, bool)
void add(Cnf& formula, literalid_t args[],
             const std::size_t input_size, const std::size_t output_size,
             const literalid_t constant, const bool b_2nd_c1) {
        _assert_level_0(input_size > 1);
        _assert_level_0(output_size >= 1 && output_size <= 3);
        _assert_level_0(literal_t__is_constant(constant) && (constant == 0 || constant == 1));
        _assert_level_0(!b_2nd_c1 || input_size == 3);
        _assert_level_0(!b_2nd_c1 || output_size == 2);
        
        bool is_2nd_carry = output_size == 3 && !b_2nd_c1;
        const addition_map_entry_t* p_map = b_2nd_c1 ? &ADD_31_C1_I0O2xC1_MAP : &(ADD_MAP[input_size][constant][is_2nd_carry]);
        
        formula.record_clauses(p_map->map, p_map->map_size, args, input_size, output_size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x1, %rdx
jbe 0x10f51
movq %rcx, %r10
movq %rdx, %rax
leaq -0x1(%rcx), %rdx
cmpq $0x3, %rdx
jae 0x10f70
cmpl $0x2, %r8d
jae 0x10f8f
movq %rsi, %rcx
cmpq $0x3, %rax
sete %sil
movl %r9d, %edx
xorb $0x1, %dl
orb %dl, %sil
je 0x10fae
cmpq $0x2, %r10
sete %sil
orb %dl, %sil
je 0x10fcd
testb %r9b, %r9b
je 0x10f0e
leaq 0x4a284(%rip), %rdx     # 0x5b190
jmp 0x10f3e
cmpq $0x3, %r10
sete %sil
andb %dl, %sil
movl %r8d, %r8d
movq %rax, %rdx
shlq $0x6, %rdx
leaq 0x4a276(%rip), %r9      # 0x5b1a0
addq %rdx, %r9
shlq $0x5, %r8
addq %r9, %r8
movzbl %sil, %edx
shll $0x4, %edx
addq %r8, %rdx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rax, %r8
movq %r10, %r9
popq %rbp
jmp 0x11188
leaq 0x31171(%rip), %rdi     # 0x420c9
leaq 0x30e55(%rip), %rsi     # 0x41db4
leaq 0x31172(%rip), %rcx     # 0x420d8
movl $0x5a, %edx
callq 0xc180
leaq 0x311ca(%rip), %rdi     # 0x42141
leaq 0x30e36(%rip), %rsi     # 0x41db4
leaq 0x31153(%rip), %rcx     # 0x420d8
movl $0x5b, %edx
callq 0xc180
leaq 0x311d0(%rip), %rdi     # 0x42166
leaq 0x30e17(%rip), %rsi     # 0x41db4
leaq 0x31134(%rip), %rcx     # 0x420d8
movl $0x5c, %edx
callq 0xc180
leaq 0x31200(%rip), %rdi     # 0x421b5
leaq 0x30df8(%rip), %rsi     # 0x41db4
leaq 0x31115(%rip), %rcx     # 0x420d8
movl $0x5d, %edx
callq 0xc180
leaq 0x311fe(%rip), %rdi     # 0x421d2
leaq 0x30dd9(%rip), %rsi     # 0x41db4
leaq 0x310f6(%rip), %rcx     # 0x420d8
movl $0x5e, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/cnf/cnf.hpp
// Function: bal::Cnf::record_clauses(char const* const*, unsigned long, unsigned int*, unsigned long, unsigned long)
void record_clauses(const char* const * const map, const std::size_t map_size,
                            literalid_t args[], const std::size_t input_size, const std::size_t output_size) {
            assert(map_size > 0 && input_size > 0 && output_size > 0);
            
            // create output literals
            for (auto i = 0; i < output_size; i++) {
                if (literal_t__is_unassigned(args[input_size + i])) {
                    args[input_size + i] = new_variable_literal();
                };
            };
            
            // buffer for clause literals
            literalid_t literalid_args[input_size + output_size];
            
            // record clauses one by one from the map
            for(auto i = 0; i < map_size; i++) {
                _assert_level_1(std::char_traits<char>::length(map[i]) == input_size + output_size);
                
                clause_size_t clause_size = 0;
                
                // record clause literals
                for (auto j = 0; j < input_size + output_size; j++) {
                    if (map[i][j] == '0' || map[i][j] == '1') {
                        literalid_args[clause_size++] = literal_t__negated_onlyif(args[j], map[i][j] == '0');
                    };
                };
                
                append_clause(literalid_args, clause_size);
            };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
testq %rdx, %rdx
je 0x112a3
movq %r8, %r15
testq %r8, %r8
je 0x112a3
movq %r9, %rbx
testq %r9, %r9
je 0x112a3
movq %rcx, %r14
leaq (%rcx,%r15,4), %r12
xorl %r13d, %r13d
cmpl $-0x1, (%r12,%r13,4)
jne 0x111e5
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, (%r12,%r13,4)
incq %r13
cmpq %r13, %rbx
jne 0x111d0
addq %r15, %rbx
leaq 0xf(,%rbx,4), %rax
andq $-0x10, %rax
movq %rsp, %r12
subq %rax, %r12
movq %r12, %rsp
addq $0x78, -0x30(%rbp)
xorl %r13d, %r13d
movq -0x40(%rbp), %rax
movq (%rax,%r13,8), %r15
movq %r15, %rdi
callq 0xc110
cmpq %rbx, %rax
jne 0x11284
testq %rbx, %rbx
je 0x1125b
xorl %eax, %eax
xorl %ecx, %ecx
movb (%r15,%rax), %dl
movl %edx, %esi
andb $-0x2, %sil
cmpb $0x30, %sil
jne 0x11251
xorl %esi, %esi
cmpb $0x30, %dl
sete %sil
xorl (%r14,%rax,4), %esi
movzwl %cx, %edx
incl %ecx
movl %esi, (%r12,%rdx,4)
incq %rax
cmpq %rax, %rbx
jne 0x1122b
jmp 0x1125d
xorl %ecx, %ecx
movzwl %cx, %edx
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x10fec
incq %r13
cmpq -0x38(%rbp), %r13
jne 0x1120d
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31fcd(%rip), %rdi     # 0x43258
leaq 0x31f30(%rip), %rsi     # 0x431c2
leaq 0x31f3f(%rip), %rcx     # 0x431d8
movl $0x67, %edx
callq 0xc180
leaq 0x31ee6(%rip), %rdi     # 0x43190
leaq 0x31f11(%rip), %rsi     # 0x431c2
leaq 0x31f20(%rip), %rcx     # 0x431d8
movl $0x59, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/cnf/cnfclausescontainer.hpp
// Function: bal::CnfClausesIndexedContainer<false>::normalize_clause_literals(unsigned int*, unsigned short)
inline static clause_size_t normalize_clause_literals(uint32_t* const literals, const clause_size_t literals_size) {
            assert(literals_size > 0);
            
            std::sort(literals, literals + literals_size);
            
            assert(literal_t__is_variable(literals[0]));
            clause_size_t validated_size = 1;
            for (auto i = 1; i < literals_size; i++) {
                assert(literal_t__is_variable(literals[i]));
                if (literals[i] == literals[validated_size - 1]) {
                    //warning(literals_size, literals, "ignoring duplicate literal");
                    continue;
                } else if (literal_t__is_negation_of(literals[i], literals[validated_size - 1])) {
                    //warning(literals_size, literals, "ignoring the clause, always satisfied");
                    return 0;
                } else {
                    if (validated_size < i) {
                        literals[validated_size] = literals[i];
                    };
                    validated_size++;
                };
            };
            
            return validated_size;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
je 0x1139a
movl %esi, %r14d
movq %rdi, %rbx
movzwl %r14w, %r12d
leaq (%rdi,%r12,4), %r15
bsrq %r12, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rsi
callq 0x117f6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x118cf
movl (%rbx), %eax
incl %eax
cmpl $0x3, %eax
jb 0x1137b
movw $0x1, %ax
cmpw $0x1, %r14w
je 0x11353
movw $0x1, %ax
movl $0x1, %ecx
movl (%rbx,%rcx,4), %edx
leal 0x1(%rdx), %esi
cmpl $0x2, %esi
jbe 0x1135c
movzwl %ax, %esi
movl -0x4(%rbx,%rsi,4), %edi
cmpl %edi, %edx
je 0x11347
xorl %edx, %edi
cmpl $0x1, %edi
je 0x11351
cmpq %rsi, %rcx
jbe 0x11345
movl %edx, (%rbx,%rsi,4)
incl %eax
incq %rcx
cmpq %rcx, %r12
jne 0x11320
jmp 0x11353
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3202e(%rip), %rdi     # 0x43391
leaq 0x31f43(%rip), %rsi     # 0x432ad
leaq 0x31f62(%rip), %rcx     # 0x432d3
movl $0x47, %edx
callq 0xc180
leaq 0x31feb(%rip), %rdi     # 0x4336d
leaq 0x31f24(%rip), %rsi     # 0x432ad
leaq 0x31f43(%rip), %rcx     # 0x432d3
movl $0x44, %edx
callq 0xc180
leaq 0x31efa(%rip), %rdi     # 0x4329b
leaq 0x31f05(%rip), %rsi     # 0x432ad
leaq 0x31f24(%rip), %rcx     # 0x432d3
movl $0x40, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfVariableEvaluator::execute()
bool CnfVariableEvaluator::execute() {
        clauses_.transaction_begin();
        bool result = (evaluate_clauses() != erConflict);
        clauses_.transaction_rollback();
        
        if (result) {
            // update variables to resolve any sequenced references
            // lighter version of update_variables() with no reindexing
            literalid_t* var_values = variables_.data();
            
            // go through the variables sequentially
            for (variableid_t i = 0; i < variables_.size(); i++) {
                const literalid_t value = var_values[i];
                if (literal_t__is_variable(value) && i != literal_t__variable_id(value)) {
                    _assert_level_1(i > literal_t__variable_id(value));
                    const literalid_t new_value = var_values[literal_t__variable_id(value)];
                    _assert_level_1(!literal_t__is_unassigned(new_value));
                    var_values[i] = literal_t__substitute_literal(value, new_value);
                };
            };
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpl $-0x1, 0x50(%rax)
jne 0x12504
movq %rdi, %r14
movl 0x10(%rax), %ecx
movl %ecx, 0x50(%rax)
movq 0x28(%rax), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x54(%rax)
movl 0x38(%rax), %ecx
movl %ecx, 0x58(%rax)
callq 0x12f82
movq 0x10(%r14), %r15
movl 0x50(%r15), %esi
cmpl $-0x1, %esi
je 0x12523
cmpl %esi, 0x10(%r15)
jb 0x12523
movl %eax, %ebx
movl 0x58(%r15), %edx
movl 0x54(%r15), %ecx
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq $-0x1, 0x50(%r15)
movl $0xffffffff, 0x58(%r15) # imm = 0xFFFFFFFF
cmpl $0x4, %ebx
je 0x124b5
movq 0xb8(%r14), %rax
cmpl $0x0, 0x8(%rax)
je 0x124b5
movq (%rax), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
leal -0x2(%rsi), %edi
cmpl $-0x4, %edi
ja 0x124aa
movl %esi, %edi
shrl %edi
decl %edi
cmpq %rdi, %rdx
je 0x124aa
movl %edi, %edi
cmpq %rdi, %rdx
jbe 0x124c6
movl (%rcx,%rdi,4), %edi
cmpl $-0x1, %edi
je 0x124e5
andl $0x1, %esi
xorl %edi, %esi
xorl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
movl 0x8(%rax), %esi
cmpq %rsi, %rdx
jb 0x1247a
cmpl $0x4, %ebx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3198d(%rip), %rdi     # 0x43e5a
leaq 0x31924(%rip), %rsi     # 0x43df8
leaq 0x319ab(%rip), %rcx     # 0x43e86
movl $0x541, %edx            # imm = 0x541
callq 0xc180
leaq 0x319cc(%rip), %rdi     # 0x43eb8
leaq 0x31905(%rip), %rsi     # 0x43df8
leaq 0x3198c(%rip), %rcx     # 0x43e86
movl $0x543, %edx            # imm = 0x543
callq 0xc180
leaq 0x32140(%rip), %rdi     # 0x4464b
leaq 0x314e2(%rip), %rsi     # 0x439f4
leaq 0x341de(%rip), %rcx     # 0x466f7
movl $0x63, %edx
callq 0xc180
leaq 0x34386(%rip), %rdi     # 0x468b0
leaq 0x314c3(%rip), %rsi     # 0x439f4
leaq 0x343b0(%rip), %rcx     # 0x468e8
movl $0x71, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndexIterator<bal::CnfClausesIndexedContainer<false>>::ContainerIndexIterator(bal::CnfClausesIndexedContainer<false> const&, bool)
ContainerIndexIterator(const INDEX_T& index, const bool b_begin): index_(index), instance_iterator_(index) {
            if (b_begin) {
                instance_offset_ = 0;
                load_instance();
            } else {
                instance_offset_ = index_.instances_.size_;
                container_offset_ = CONTAINER_END;
            };
        }

// Assembly:
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
movq $-0x1, 0x10(%rdi)
testl %edx, %edx
je 0x14b3d
movl $0x0, 0x18(%rdi)
movl 0x38(%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x14bb4
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rsi), %rdx
cmpl $-0x1, (%rdx)
je 0x14b4a
xorl %r8d, %r8d
movb $0x1, %r9b
xorl %r10d, %r10d
jmp 0x14b77
movl 0x38(%rsi), %eax
movl %eax, 0x18(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x14bb4
leaq -0x1(%rcx), %r9
xorl %r10d, %r10d
leal 0x1(%r10), %r8d
movl %r8d, 0x18(%rdi)
cmpq %r10, %r9
je 0x14bb3
leaq 0x1(%r10), %r8
cmpl $-0x1, 0x4(%rdx,%r10,4)
movq %r8, %r10
je 0x14b51
cmpq %rcx, %r8
setb %r9b
movl %r8d, %r10d
testb %r9b, %r9b
je 0x14bb3
movl %r10d, 0x10(%rdi)
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
cmpl %r10d, %ecx
jbe 0x14b8f
movl (%rdx,%r8,4), %r9d
movl %r9d, 0x14(%rdi)
cmpl $-0x1, %r9d
je 0x14bb0
movq 0x8(%rsi), %rax
movl %r9d, %ecx
movl 0x8(%rax,%rcx,4), %ecx
cmpl $-0x1, %ecx
je 0x14bb0
movl %ecx, 0x14(%rdi)
movl %ecx, %ecx
jmp 0x14ba0
movl 0x14(%rdi), %eax
popq %rbp
movl %eax, 0x1c(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/bal/containerindex.hpp
// Function: bal::ContainerIndex<bal::list_index_item_t, unsigned int, bal::LinkedListsIndexInstanceOffsetIterator<unsigned int>, bal::list_index_insertion_point_t>::reset(unsigned int, unsigned int)
virtual void reset(const container_size_t instances_size, const container_size_t index_size) {
            _assert_level_1(!transaction_is_in());
            instances_.reset(instances_size);
            instances_.append(CONTAINER_END, instances_size);
            Container<INDEX_DATA_T>::reset(index_size);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $-0x1, 0x50(%rdi)
jne 0x15073
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x30(%rdi), %r12
cmpl %esi, 0x48(%rdi)
je 0x14fcc
movq (%r12), %rdi
testq %rdi, %rdi
je 0x14f80
testl %r15d, %r15d
je 0x14fb4
movl %r15d, %esi
shlq $0x2, %rsi
callq 0xc470
testq %rax, %rax
je 0x15092
movq %rax, (%r12)
jmp 0x14fc8
testl %r15d, %r15d
je 0x14fc1
movl %r15d, %edi
shlq $0x2, %rdi
callq 0xc380
movq %rax, (%r12)
testq %rax, %rax
jne 0x14fc1
leaq 0x2c884(%rip), %rdi     # 0x41825
leaq 0x2c80f(%rip), %rsi     # 0x417b7
leaq 0x2c820(%rip), %rcx     # 0x417cf
jmp 0x15041
callq 0xc350
movq $0x0, 0x30(%rbx)
movl $0x0, 0x38(%rbx)
movl %r15d, 0x48(%rbx)
movl $0x0, 0x38(%rbx)
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %r15d, %edx
callq 0x12094
cmpl %r14d, 0x20(%rbx)
je 0x15063
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x15012
testl %r14d, %r14d
je 0x1504b
movl %r14d, %esi
shlq $0x3, %rsi
callq 0xc470
testq %rax, %rax
je 0x150a9
movq %rax, 0x8(%rbx)
jmp 0x1505f
testl %r14d, %r14d
je 0x15058
movl %r14d, %edi
shlq $0x3, %rdi
callq 0xc380
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x15058
leaq 0x2c7f2(%rip), %rdi     # 0x41825
leaq 0x2c77d(%rip), %rsi     # 0x417b7
leaq 0x2f7cc(%rip), %rcx     # 0x4480d
movl $0x38, %edx
callq 0xc180
callq 0xc350
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movl %r14d, 0x20(%rbx)
movl $0x0, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f5d1(%rip), %rdi     # 0x4464b
leaq 0x2e973(%rip), %rsi     # 0x439f4
leaq 0x2f5d8(%rip), %rcx     # 0x44660
movl $0x5c, %edx
callq 0xc180
leaq 0x2c70a(%rip), %rdi     # 0x417a3
leaq 0x2c717(%rip), %rsi     # 0x417b7
leaq 0x2c728(%rip), %rcx     # 0x417cf
jmp 0x150be
leaq 0x2c6f3(%rip), %rdi     # 0x417a3
leaq 0x2c700(%rip), %rsi     # 0x417b7
leaq 0x2f74f(%rip), %rcx     # 0x4480d
movl $0x33, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/cnf/processor/cnfoptimizer.cpp
// Function: bal::CnfOptimizer::process_clause_evaluate(unsigned int*)
inline processor_result_t CnfOptimizer::process_clause_evaluate(uint32_t* const p_clause) {
        
        if ((evaluations_ & 0x3FFF) == 0) {
             std::cout << "s:" << std::dec << std::setfill(' ') << std::setw(8) << (clauses_size_ >> 10) << " Kb d: " << std::setw(8) << ((clauses_size_ - processed_offset_) >> 10) << "Kb v: " << std::setw(8) << variables_assigned_ << std::flush << "\r";
        };
        
        _assert_level_3(p_clause == _clauses_offset_clause(clauses_data_, processed_offset_));
        const processor_result_t result = evaluate_clause(processed_offset_);
        if (result == erConflict) {
            __print_conflict(variables_.data(), p_clause);
        };
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0xc0(%rdi), %eax
testl $0x3fff, %eax           # imm = 0x3FFF
jne 0x1536d
movq 0x49d4c(%rip), %r15     # 0x5efa8
leaq 0x2f639(%rip), %rsi     # 0x4489c
movl $0x2, %edx
movq %r15, %rdi
callq 0xc320
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r15,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%r15,%rcx)
movq -0x18(%rax), %rax
leaq (%r15,%rax), %r12
cmpb $0x0, 0xe1(%r15,%rax)
jne 0x152b8
movq %r12, %rdi
movl $0x20, %esi
callq 0xc2a0
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x20, 0xe0(%r12)
movq (%r15), %rax
movq -0x18(%rax), %rax
movl $0x8, %r12d
movq %r12, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movl (%rax), %esi
shrl $0xa, %esi
movq %r15, %rdi
callq 0xc190
movq %rax, %r15
leaq 0x2f5b1(%rip), %rsi     # 0x4489f
movl $0x7, %edx
movq %rax, %rdi
callq 0xc320
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq 0x20(%r14), %rax
movl (%rax), %esi
subl 0xb0(%r14), %esi
shrl $0xa, %esi
movq %r15, %rdi
callq 0xc190
movq %rax, %r15
leaq 0x2f57e(%rip), %rsi     # 0x448a7
movl $0x6, %edx
movq %rax, %rdi
callq 0xc320
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq 0xd0(%r14), %rsi
movq %r15, %rdi
callq 0xc190
movq %rax, %rdi
callq 0xc1a0
leaq 0x2f54e(%rip), %rsi     # 0x448ae
movl $0x1, %edx
movq %rax, %rdi
callq 0xc320
movq 0x18(%r14), %rax
movq (%rax), %rax
movl 0xb0(%r14), %esi
leaq (%rax,%rsi,4), %rax
addq $0xc, %rax
cmpq %rbx, %rax
jne 0x153b6
movq %r14, %rdi
callq 0x15568
movl %eax, %r15d
cmpl $0x4, %eax
jne 0x153aa
movq 0xb8(%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x103d6
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f4f3(%rip), %rdi     # 0x448b0
leaq 0x2ea34(%rip), %rsi     # 0x43df8
leaq 0x2f521(%rip), %rcx     # 0x448ec
movl $0x84, %edx
callq 0xc180
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/bal/referenceable.hpp
// Function: bal::Ref<bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>>::set_value(bal::GF2NElement<32ul, bal::Literal<bal::Cnf>>*) const
T* set_value(T* value) const {
            if (value_ != value) {
                if (value_ != nullptr)
                    value_->release();
                if (value != nullptr)
                    value->add_ref();
                value_ = value;
            };
            return value;
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x302bf(%rip), %rsi     # 0x4a0c8
movl $0x1, %ecx
movq $-0x1, %rdx
callq 0xc540
cmpq $-0x1, %rax
je 0x19ed2
incq %rax
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xc2e0
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x19e66
movq -0x60(%rbp), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0xc3b0
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x19e50
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x1f204
movq -0x38(%rbp), %rbx
testq %rbx, %rbx
je 0x19ea7
movq -0x40(%rbp), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0xc3b0
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %rbx
jne 0x19e91
movq -0x58(%rbp), %r15
movq -0x38(%rbp), %r12
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
testq %rdx, %rdx
je 0x19ed6
movq -0x40(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0xc2d0
testl %eax, %eax
sete %bl
jmp 0x19ed8
xorl %ebx, %ebx
jmp 0x19f02
movb $0x1, %bl
cmpq %r12, %r15
sete %r15b
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x19eed
callq 0xc280
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19eff
callq 0xc280
andb %r15b, %bl
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19f26
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commandline.cpp
// Function: validate_file_extension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CGenCommandInfo&, CGenFormulaType, CGenOutputFormat, char const*)
void validate_file_extension(const std::string& file_name, const std::string& value, CGenCommandInfo& info,
                             const CGenFormulaType formula_type, const CGenOutputFormat output_format,
                             const char* const error_message) {
    if (is_file_extension(file_name, value)) {
        if (!info.b_formula_type_specified) {
            info.formula_type = formula_type;
            info.output_format = output_format;
            info.b_formula_type_specified = true;
        } else if (info.formula_type != formula_type) {
            throw std::invalid_argument(error_message);
        };
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r14
callq 0x19ded
testb %al, %al
je 0x19f9c
cmpb $0x0, 0x98(%r14)
je 0x19f8c
cmpl %r12d, 0x8(%r14)
je 0x19f9c
movl $0x10, %edi
callq 0xc130
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc520
movq 0x45053(%rip), %rsi     # 0x5efd0
movq 0x45034(%rip), %rdx     # 0x5efb8
movq %r14, %rdi
callq 0xc4b0
movl %r12d, 0x8(%r14)
movl %r15d, 0xc(%r14)
movb $0x1, 0x98(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xc1e0
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commandline.cpp
// Function: CGenCommandLineReader::parse_variable_replace(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CGenVariableInfo, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, CGenVariableInfo>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CGenCommandLineReader::parse_variable_replace(CGenVariablesMap& variables_map, const std::string& variable_name) {
    if (variable_name.empty()) {
        parse_error(ERROR_REPLACE_MUST_FOLLOW_DEFINITION);
    };
    if (is_binary_variable_name(variable_name)) {
        parse_error(ERROR_BINARY_VARIABLE_REPLACE_INCOMPATIBLE);
    };
    
    CGenVariableInfo& variable_value = variables_map.find(variable_name)->second;
    
    if (variable_value.except_count > 0 || variable_value.except_range_size > 0) {
        parse_error(ERROR_EXCEPT_REPLACE_INCOMPATIBLE);
    };

    variable_value.replace_existing = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
jne 0x1b07a
movq (%rbx), %rax
leaq -0x58(%rbp), %rcx
movq -0x18(%rax), %r12
addq %rbx, %r12
movq %rcx, -0x10(%rcx)
leaq 0x2c7dd(%rip), %rsi     # 0x47827
leaq 0x2c815(%rip), %rdx     # 0x47866
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x1f29e
movq %r12, %rdi
movq %r13, %rsi
callq 0x1de0a
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x1b07a
callq 0xc280
cmpq $0x0, 0x8(%r14)
je 0x1b0d8
movq (%r14), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x1b0d8
movq (%rbx), %rax
leaq -0x38(%rbp), %rcx
movq -0x18(%rax), %r12
addq %rbx, %r12
movq %rcx, -0x10(%rcx)
leaq 0x2c7bf(%rip), %rsi     # 0x47867
leaq 0x2c7eb(%rip), %rdx     # 0x4789a
leaq -0x48(%rbp), %r13
movq %r13, %rdi
callq 0x1f29e
movq %r12, %rdi
movq %r13, %rsi
callq 0x1de0a
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1b0d8
callq 0xc280
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f570
movq %rax, %r14
cmpl $0x0, 0x48(%rax)
jne 0x1b0f3
cmpl $0x0, 0x50(%r14)
je 0x1b13c
movq (%rbx), %rax
leaq -0x78(%rbp), %r12
addq -0x18(%rax), %rbx
movq %r12, -0x10(%r12)
leaq 0x2c4e1(%rip), %rsi     # 0x475eb
leaq 0x2c514(%rip), %rdx     # 0x47625
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0x1f29e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1de0a
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b13c
callq 0xc280
movb $0x1, 0x78(%r14)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
jmp 0x1b168
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
jne 0x1b17e
jmp 0x1b183
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b183
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/commandline.cpp
// Function: CGenCommandLineReader::parse_variable_compute_mode(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CGenVariableInfo, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, CGenVariableInfo>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CGenVariableComputeMode)
void CGenCommandLineReader::parse_variable_compute_mode(CGenVariablesMap& variables_map,
                                                        const std::string& variable_name,
                                                        const CGenVariableComputeMode compute_mode) {
    CGenVariableInfo& variable_value = variables_map.find(variable_name)->second;
    
    if (variable_value.mode != vmCompute) {
        parse_error(ERROR_COMPUTE_MODE_CONTEXT);
    };

    variable_value.compute_mode = compute_mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1f570
movq %rax, %r14
cmpl $0x2, 0x40(%rax)
je 0x1b1f8
movq (%r15), %rax
leaq -0x38(%rbp), %r13
addq -0x18(%rax), %r15
movq %r13, -0x10(%r13)
leaq 0x2c6cf(%rip), %rsi     # 0x4789b
leaq 0x2c702(%rip), %rdx     # 0x478d5
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x1f29e
movq %r15, %rdi
movq %r12, %rsi
callq 0x1de0a
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1b1f8
callq 0xc280
movl %ebx, 0x44(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1b21c
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::is_token(char const*)
inline bool is_token(const char* value) {
        load_next_token();
        if (current_token_len_ > 0) {
            auto index = 0;
            while (index < current_token_len_ && value[index] != 0) {
                if (current_line_[current_token_pos_ + index] != value[index])
                    return false;
                index++;
            };
            if (value[index] != 0) {
                index++;
            };
            return (index == current_token_len_);
        };
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1eae0
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1e450
movq 0x18(%r14), %rdx
addq 0x8(%r14), %rdx
xorl %ecx, %ecx
movb (%rbx,%rcx), %sil
testb %sil, %sil
je 0x1e441
cmpb %sil, (%rdx,%rcx)
jne 0x1e450
incq %rcx
cmpq %rcx, %rax
jne 0x1e427
movq %rax, %rcx
cmpb $0x1, (%rbx,%rcx)
sbbl $-0x1, %ecx
cmpq %rcx, %rax
sete %al
jmp 0x1e452
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/variables/variablesarray.hpp
// Function: bal::VariablesArray& bal::VariablesArray::operator=<char, std::char_traits<char>>(char const*)
inline VariablesArray& operator = (const charT* const s) {
            static constexpr std::size_t charT_size_bits = sizeof(charT) << 3;
            
            const std::size_t size_char = charT_traits::length(s);
            const std::size_t size_bits = size_char * charT_size_bits;
            
            _assert_level_0(size_bits <= VARIABLEID_MAX);
            _assert_level_1(size_bits % element_size_ == 0);
            resize((container_size_t)size_bits);
            
            // encode bit by bit for each byte
            bal::literalid_t* p_value = data_;
            for (auto i = 0; i < size_char; i++) {
                for (auto j = 0; j < charT_size_bits; j++) {
                    *p_value = literal_t__constant(s[i] & (1 << (charT_size_bits - 1 - j)));
                    p_value++;
                };
            };
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc110
leaq (,%rax,8), %r12
cmpq $0x7fffffff, %r12       # imm = 0x7FFFFFFF
jae 0x1e563
movq %rax, %r15
movl 0x1c(%rbx), %ecx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x1e582
cmpl %r12d, 0x8(%rbx)
je 0x1e527
cmpl %r12d, 0x18(%rbx)
je 0x1e523
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1e4d4
testq %r12, %r12
je 0x1e50c
movq %r15, %rsi
shlq $0x5, %rsi
callq 0xc470
testq %rax, %rax
je 0x1e5a1
movq %rax, (%rbx)
jmp 0x1e51f
testq %r12, %r12
je 0x1e518
movq %r15, %rdi
shlq $0x5, %rdi
callq 0xc380
movq %rax, (%rbx)
testq %rax, %rax
jne 0x1e518
leaq 0x23331(%rip), %rdi     # 0x41825
leaq 0x232bc(%rip), %rsi     # 0x417b7
leaq 0x232cd(%rip), %rcx     # 0x417cf
movl $0x38, %edx
callq 0xc180
callq 0xc350
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
movl %r12d, 0x18(%rbx)
movl %r12d, 0x8(%rbx)
testq %r15, %r15
je 0x1e557
movq (%rbx), %rax
xorl %ecx, %ecx
movl $0x7, %edx
movsbl (%r14,%rcx), %esi
xorl %edi, %edi
btl %edx, %esi
setb %dil
movl %edi, (%rax)
addq $0x4, %rax
addl $-0x1, %edx
jb 0x1e536
incq %rcx
cmpq %r15, %rcx
jne 0x1e531
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29b5d(%rip), %rdi     # 0x480c7
leaq 0x231bb(%rip), %rsi     # 0x4172c
leaq 0x29b6b(%rip), %rcx     # 0x480e3
movl $0x44, %edx
callq 0xc180
leaq 0x29bd3(%rip), %rdi     # 0x4815c
leaq 0x2319c(%rip), %rsi     # 0x4172c
leaq 0x29b4c(%rip), %rcx     # 0x480e3
movl $0x45, %edx
callq 0xc180
leaq 0x231fb(%rip), %rdi     # 0x417a3
leaq 0x23208(%rip), %rsi     # 0x417b7
leaq 0x23219(%rip), %rcx     # 0x417cf
movl $0x33, %edx
callq 0xc180
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./acl/sha.hpp
// Function: acl::SHA<32ul, 16u, bal::Literal<bal::Cnf>>::pad_message(unsigned int const*, unsigned int)
static VariablesArray pad_message(const literalid_t* const message, const variables_size_t message_size) {
            constexpr auto block_bits_size = MESSAGE_BLOCK_SIZE * WORD_SIZE;
            variables_size_t number_of_blocks = message_size / block_bits_size + 1;
            if ((message_size % block_bits_size) > 447) {
                number_of_blocks++;
            };
            
            const variables_size_t padded_words_size = number_of_blocks * MESSAGE_BLOCK_SIZE;
            const variables_size_t padded_bits_size = padded_words_size * WORD_SIZE;
            VariablesArray padded_message(padded_words_size, WORD_SIZE);
            literalid_t* data = padded_message.data();

            // copy the message
            std::copy(message, message + message_size, data);
            // append 1 bit
            data[message_size] = literal_t__constant(1);
            // append the rest with zeros except for the last 64 bits
            std::fill(data + message_size + 1, data + padded_bits_size - 64, literal_t__constant(0));
            // the last 64 bits is the message size in bits
            uint64_t message_size_ = message_size;
            for (auto i = 0; i < 64; i++) {
                data[padded_bits_size - i - 1] = message_size_ & 1;
                message_size_ >>= 1;
            };

            return padded_message;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movl %edx, %r15d
shrl $0x9, %r15d
movl %edx, %eax
notl %eax
andl $0x1c0, %eax            # imm = 0x1C0
cmpl $0x1, %eax
adcl $0x1, %r15d
movl %edx, %r13d
movl %r15d, %esi
shll $0x4, %esi
shll $0x9, %r15d
movl $0x20, %edx
callq 0xf76c
movq (%rbx), %r14
testl %r12d, %r12d
je 0x1e6fe
leaq (,%r13,4), %rdx
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0xc450
leaq (%r14,%r13,4), %rdi
addq $0x4, %rdi
movl $0x1, -0x4(%rdi)
movl %r15d, %edx
leaq (%r14,%rdx,4), %rax
addq $-0x100, %rax
cmpq %rax, %rdi
je 0x1e73c
shlq $0x2, %rdx
leaq (,%r13,4), %rax
subq %rax, %rdx
addq $-0x104, %rdx           # imm = 0xFEFC
xorl %esi, %esi
callq 0xc160
addl $0xfffffe00, %r15d      # imm = 0xFFFFFE00
leaq (%r14,%r15,4), %rax
addq $0x7fc, %rax            # imm = 0x7FC
xorl %ecx, %ecx
movl %r13d, %edx
andl $0x1, %edx
movl %edx, (%rax,%rcx,4)
shrq %r13
decq %rcx
cmpq $-0x40, %rcx
jne 0x1e74f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/vsklad[P]cgen/./bal/io/textreader.hpp
// Function: TextReader::parse_hex()
inline void parse_hex() {
        current_token_len_++;
        current_token_len_++;
        while (current_token_pos_ + current_token_len_ < current_line_.size() &&
               _is_hex_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            current_token_len_++;
        };
        if (current_token_pos_ + current_token_len_ < current_line_.size() &&
            _is_literal_symbol(current_line_[current_token_pos_ + current_token_len_])) {
            parse_error(ERROR_HEX_INVALID_SYMBOL);
        } else if (current_token_len_ == 2) {
            parse_error(ERROR_MISSING_HEX_VALUE);
        };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rdx
addq $0x2, %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rdi), %rcx
addq %rax, %rcx
cmpq %rdx, %rcx
setb %r8b
jae 0x1ed2b
movq 0x18(%rbx), %rsi
movabsq $0x3f0000003f, %rdi     # imm = 0x3F0000003F
movb (%rsi,%rcx), %r9b
leal -0x30(%r9), %r10d
cmpb $0xa, %r10b
jb 0x1ed18
movzbl %r9b, %r9d
addl $-0x41, %r9d
cmpl $0x25, %r9d
ja 0x1ed77
btq %r9, %rdi
jae 0x1ed77
incq %rax
movq %rax, 0x10(%rbx)
incq %rcx
cmpq %rdx, %rcx
setb %r8b
jb 0x1ecf6
cmpq $0x2, %rax
jne 0x1ed6c
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x290ed(%rip), %rsi     # 0x47e2d
leaq 0x2911a(%rip), %rdx     # 0x47e61
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1f29e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1de0a
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1ed6c
callq 0xc280
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, %r8b
je 0x1ed2b
movq 0x18(%rbx), %rdx
movb (%rdx,%rcx), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
setb %dl
leal -0x41(%rcx), %esi
cmpb $0x1a, %sil
setb %sil
orb %dl, %sil
jne 0x1edb4
leal -0x61(%rcx), %edx
cmpb $0x1a, %dl
setae %dl
cmpb $0x5f, %cl
setne %cl
testb %dl, %cl
jne 0x1ed2b
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x29046(%rip), %rsi     # 0x47e09
leaq 0x29062(%rip), %rdx     # 0x47e2c
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x1f29e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1de0a
movq -0x58(%rbp), %rdi
jmp 0x1ed62
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x1edfa
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1ee04
callq 0xc280
movq %rbx, %rdi
callq 0xc4e0