LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::get()
std::char_traits<char>::int_type get()
    {
        ++chars_read;
        current = ia->get_character();
        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
        {
            token_string.push_back(std::char_traits<char>::to_char_type(current));
        }
        return current;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incq 0x18(%rdi)
movq (%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x10(%rbx)
cmpl $-0x1, %eax
je 0x3452
movb %al, 0xf(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x3444
movb %al, (%rsi)
incq 0x28(%rbx)
jmp 0x3452
leaq 0x20(%rbx), %rdi
leaq 0xf(%rsp), %rdx
callq 0x60ec
movl 0x10(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>& nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[]<char const>(char const*)
reference operator[](T* key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value = value_t::object;
            assert_invariant();
        }

        // at only works for objects
        if (JSON_LIKELY(is_object()))
        {
            return m_value.object->operator[](key);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x4043
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x3240
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x4386
cmpb $0x1, (%r14)
jne 0x408e
movq 0x8(%r14), %r14
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0x3100
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x7696
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4082
callq 0x3220
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3130
movq %rax, %rbx
movzbl (%r14), %eax
cmpq $0x8, %rax
ja 0x40b2
leaq 0x9cac(%rip), %rcx      # 0xdd58
movq (%rcx,%rax,8), %rsi
jmp 0x40b9
leaq 0x60a5(%rip), %rsi      # 0xa15e
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3100
leaq 0x6042(%rip), %rsi      # 0xa111
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x64fb
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x7712
xorl %ebp, %ebp
leaq 0x9c1c(%rip), %rsi      # 0xdd18
leaq 0x3749(%rip), %rdx      # 0x784c
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x416e
callq 0x3220
jmp 0x416e
movq %rax, %r14
jmp 0x416e
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4146
callq 0x3220
jmp 0x4146
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4161
callq 0x3220
jmp 0x4161
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x416e
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](unsigned long)
reference operator[](size_type idx)
    {
        // implicitly convert null value to an empty array
        if (is_null())
        {
            m_type = value_t::array;
            m_value.array = create<array_t>();
            assert_invariant();
        }

        // operator[] only works for arrays
        if (JSON_LIKELY(is_array()))
        {
            // fill up array with null values if given idx is outside range
            if (idx >= m_value.array->size())
            {
                m_value.array->insert(m_value.array->end(),
                                      idx - m_value.array->size() + 1,
                                      basic_json());
            }

            return m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x41b7
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x3240
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x4386
cmpb $0x2, (%r14)
jne 0x4236
movq 0x8(%r14), %r15
movq 0x8(%r15), %r12
movq %r12, %rax
subq (%r15), %rax
sarq $0x4, %rax
cmpq %rbx, %rax
ja 0x4219
movq %rbx, %r13
subq %rax, %r13
incq %r13
leaq 0x8(%rsp), %rbp
movb $0x0, (%rbp)
movq $0x0, 0x8(%rbp)
movq %rbp, %rdi
callq 0x4386
movq %rbp, %rdi
callq 0x4386
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x7d2a
leaq 0x8(%rsp), %rdi
callq 0x4358
movq 0x8(%r14), %rax
shlq $0x4, %rbx
addq (%rax), %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3130
movq %rax, %rbx
movzbl (%r14), %eax
cmpq $0x8, %rax
ja 0x425a
leaq 0x9b04(%rip), %rcx      # 0xdd58
movq (%rcx,%rax,8), %rsi
jmp 0x4261
leaq 0x5efd(%rip), %rsi      # 0xa15e
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3100
leaq 0x5e9a(%rip), %rsi      # 0xa111
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x64fb
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x7712
xorl %ebp, %ebp
leaq 0x9a74(%rip), %rsi      # 0xdd18
leaq 0x35a1(%rip), %rdx      # 0x784c
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4358
jmp 0x4308
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42e0
callq 0x3220
jmp 0x42e0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42fb
callq 0x3220
jmp 0x42fb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4308
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::parse(bool, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>&)
void parse(const bool strict, BasicJsonType& result)
    {
        // read first token
        get_token();

        parse_internal(true, result);
        result.assert_invariant();

        // in strict mode, input must be completely read
        if (strict)
        {
            get_token();
            expect(token_type::end_of_input);
        }

        // in case of an error, return discarded value
        if (errored)
        {
            result = value_t::discarded;
            return;
        }

        // set top-level value to null if it was discarded by the callback
        // function
        if (result.is_discarded())
        {
            result = nullptr;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%r14)
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x4eea
movq %rbx, %rdi
callq 0x4386
testl %ebp, %ebp
je 0x4af5
movq %r15, %rdi
callq 0x585a
movl %eax, 0x28(%r14)
cmpl $0xf, %eax
jne 0x4b75
cmpb $0x1, 0xb0(%r14)
jne 0x4b12
leaq 0x18(%rsp), %r14
movb $0x8, (%r14)
movq $0x0, 0x8(%r14)
jmp 0x4b30
cmpb $0x8, (%rbx)
jne 0x4b6a
leaq 0x8(%rsp), %r14
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4386
movq %r14, %rdi
callq 0x4386
movq %r14, %rdi
callq 0x4386
movb (%rbx), %al
movb (%r14), %cl
movb %cl, (%rbx)
movb %al, (%r14)
movq 0x8(%rbx), %rax
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x4386
movq %r14, %rdi
callq 0x4358
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x345b
jmp 0x4af5
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::input_stream_adapter::input_stream_adapter(std::istream&)
explicit input_stream_adapter(std::istream& i)
        : is(i), sb(*i.rdbuf())
    {
        // skip byte order mark
        std::char_traits<char>::int_type c;
        if ((c = get_character()) == 0xEF)
        {
            if ((c = get_character()) == 0xBB)
            {
                if ((c = get_character()) == 0xBF)
                {
                    return; // Ignore BOM
                }
                else if (c != std::char_traits<char>::eof())
                {
                    is.unget();
                }
                is.putback('\xBB');
            }
            else if (c != std::char_traits<char>::eof())
            {
                is.unget();
            }
            is.putback('\xEF');
        }
        else if (c != std::char_traits<char>::eof())
        {
            is.unget(); // no byte order mark; process as usual
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8f99(%rip), %rax      # 0xdc50
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rdi
movq %rdi, 0x10(%rbx)
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x4d56
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%rdi)
cmpl $-0x1, %eax
je 0x4d19
cmpl $0xef, %eax
jne 0x4d1b
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $-0x1, %eax
je 0x4d47
cmpl $0xbb, %eax
jne 0x4d25
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $-0x1, %eax
je 0x4d39
cmpl $0xbf, %eax
jne 0x4d30
popq %rbx
retq
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x30b0
movq 0x8(%rbx), %rdi
callq 0x30b0
jmp 0x4d47
movq 0x8(%rbx), %rdi
callq 0x30b0
movq 0x8(%rbx), %rdi
movl $0xffffffbb, %esi       # imm = 0xFFFFFFBB
callq 0x33d0
movq 0x8(%rbx), %rdi
movl $0xffffffef, %esi       # imm = 0xFFFFFFEF
popq %rbx
jmp 0x33d0
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x4ce5
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::scan_literal(char const*, unsigned long, nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::token_type)
token_type scan_literal(const char* literal_text, const std::size_t length,
                            token_type return_type)
    {
        assert(current == literal_text[0]);
        for (std::size_t i = 1; i < length; ++i)
        {
            if (JSON_UNLIKELY(get() != literal_text[i]))
            {
                error_message = "invalid literal";
                return token_type::parse_error;
            }
        }
        return return_type;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movsbl (%rsi), %eax
cmpl %eax, 0x10(%rdi)
jne 0x59f1
movl %ecx, %ebx
movq %rdx, %r15
cmpq $0x2, %rdx
jb 0x59d3
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, %r13d
movq %r14, %rdi
callq 0x3412
movsbl (%r12,%r13), %ecx
cmpl %ecx, %eax
jne 0x59df
incq %r13
cmpq %r13, %r15
jne 0x59ba
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3f10(%rip), %rax      # 0x98f6
movq %rax, 0x58(%r14)
movl $0xe, %ebx
jmp 0x59d3
leaq 0x3f28(%rip), %rdi      # 0x9920
leaq 0x3c5f(%rip), %rsi      # 0x965e
leaq 0x3f35(%rip), %rcx      # 0x993b
movl $0xa5d, %edx            # imm = 0xA5D
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::unget()
void unget()
    {
        --chars_read;
        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
        {
            ia->unget_character();
            assert(token_string.size() != 0);
            token_string.pop_back();
        }
    }

// Assembly:
pushq %rbx
decq 0x18(%rdi)
cmpl $-0x1, 0x10(%rdi)
je 0x6350
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x6352
decq %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
leaq 0x3b79(%rip), %rdi      # 0x9ed2
leaq 0x32fe(%rip), %rsi      # 0x965e
leaq 0x3b84(%rip), %rcx      # 0x9eeb
movl $0xa91, %edx            # imm = 0xA91
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::get_token_string() const
std::string get_token_string() const
    {
        // escape control characters
        std::string result;
        for (const auto c : token_string)
        {
            if ('\x00' <= c and c <= '\x1F')
            {
                // escape control characters
                std::stringstream ss;
                ss << "<U+" << std::setw(4) << std::uppercase << std::setfill('0')
                   << std::hex << static_cast<int>(c) << ">";
                result += ss.str();
            }
            else
            {
                // add character as is
                result.push_back(c);
            }
        }

        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rbp
movq 0x28(%rsi), %r13
cmpq %r13, %rbp
je 0x66d4
leaq 0x40(%rsp), %r14
movsbl (%rbp), %r15d
cmpl $0x1f, %r15d
ja 0x66bd
leaq 0x30(%rsp), %rdi
callq 0x3180
movl $0x3, %edx
movq %r14, %rdi
leaq 0x3a35(%rip), %rsi      # 0xa00b
callq 0x3290
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x4, 0x50(%rsp,%rcx)
movq -0x18(%rax), %rcx
orl $0x4000, 0x58(%rsp,%rcx) # imm = 0x4000
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r12
cmpb $0x0, 0x121(%rsp,%rax)
jne 0x6629
movq %r12, %rdi
movl $0x20, %esi
callq 0x3230
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x58(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x58(%rsp,%rax)
movq %r14, %rdi
movl %r15d, %esi
callq 0x3380
movl $0x1, %edx
movq %rax, %rdi
leaq 0x39f1(%rip), %rsi      # 0xa054
callq 0x3290
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3330
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x30a0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x669d
callq 0x3220
leaq 0x30(%rsp), %rdi
movq 0x7907(%rip), %rsi      # 0xdfb0
callq 0x31b0
leaq 0xb0(%rsp), %rdi
callq 0x30c0
jmp 0x66c8
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3200
incq %rbp
cmpq %r13, %rbp
jne 0x65ae
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x66ed
jmp 0x670b
movq %rax, %r14
jmp 0x672c
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x670e
callq 0x3220
jmp 0x670e
movq %rax, %r14
movq 0x789b(%rip), %rsi      # 0xdfb0
leaq 0x30(%rsp), %rdi
callq 0x31b0
leaq 0xb0(%rsp), %rdi
callq 0x30c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x673b
callq 0x3220
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]syzygy-tools/smartvio/syzygy.c
// Function: szgComputeCRC
unsigned short
szgComputeCRC(const unsigned char *data, unsigned int length)
{
	unsigned short x, crc = 0xffff;

	while (length--){
		x = (crc >> 8) ^ *data++;
		x ^= x>>4;
		crc = (crc<<8) ^ (x<<12) ^ (x<<5) ^ (x);
		crc &= 0xffff;
	}
	return(crc);
}

// Assembly:
testl %esi, %esi
je 0x8703
movl %esi, %ecx
movw $0xffff, %ax            # imm = 0xFFFF
xorl %edx, %edx
movzwl %ax, %esi
shrl $0x8, %esi
movzbl (%rdi,%rdx), %r8d
xorl %esi, %r8d
movl %r8d, %esi
shrl $0x4, %esi
xorl %r8d, %esi
shll $0x8, %eax
movl %esi, %r8d
orl %esi, %eax
shll $0xc, %esi
shll $0x5, %r8d
xorl %esi, %eax
xorl %r8d, %eax
incq %rdx
cmpl %edx, %ecx
jne 0x86d0
retq
movw $0xffff, %ax            # imm = 0xFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: vec_len(std::vector<double, std::allocator<double>>)
double vec_len(vector<double> a)
{
	double res=0;
	for (int i=0; i<a.size(); i++)
		res+=a[i]*a[i];
	return sqrt(res);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
subq %rax, %rcx
je 0x2877
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x2862
ucomisd %xmm1, %xmm0
jb 0x2140
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: main
int main(int argc,char**argv)
{
    if (argc<2)
        return 0;
    else
    {
        version = argv[1];
        if (argc==3)
            trainortest = argv[2];
        prepare();
        test.run();
    }
}

// Assembly:
cmpl $0x2, %edi
jl 0x33be
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
movq 0x8e4f(%rip), %r15      # 0xc1a0
leaq 0x8e40(%rip), %r12      # 0xc198
movq %r14, %rdi
callq 0x20b0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2210
cmpl $0x3, %ebp
jne 0x33a5
movq 0x10(%rbx), %rbx
movq 0x8e3d(%rip), %r14      # 0xc1c0
leaq 0x8e2e(%rip), %r15      # 0xc1b8
movq %rbx, %rdi
callq 0x20b0
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x2210
callq 0x298e
leaq 0x39dbf(%rip), %rdi     # 0x3d170
callq 0x382e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: Test::add(int, int, int, bool)
void add(int x,int y,int z, bool flag)
    {
    	if (flag)
    	{
        	fb_h.push_back(x);
        	fb_r.push_back(z);
        	fb_l.push_back(y);
        }
        ok[make_pair(x,z)][y]=1;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
testl %r8d, %r8d
je 0x37ee
movq 0xc8(%rbx), %rax
cmpq 0xd0(%rbx), %rax
je 0x3772
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0xc8(%rbx)
jmp 0x3786
leaq 0xc0(%rbx), %rdi
leaq 0x14(%rsp), %rdx
movq %rax, %rsi
callq 0x6c04
movq 0xf8(%rbx), %rsi
cmpq 0x100(%rbx), %rsi
je 0x37a9
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xf8(%rbx)
jmp 0x37ba
leaq 0xf0(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x6c04
movq 0xe0(%rbx), %rsi
cmpq 0xe8(%rbx), %rsi
je 0x37dd
movl 0x10(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xe0(%rbx)
jmp 0x37ee
leaq 0xd8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6c04
addq $0x108, %rbx            # imm = 0x108
movl 0x14(%rsp), %eax
movl 0xc(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x18(%rsp), %rsi
movq %rcx, (%rsi)
movq %rbx, %rdi
callq 0x53da
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x366e
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: main
int main()
{
    Tree code = {};
    TreeConstructor (&code);

    if (LoadTree (&code))
        GoElf (&code);

    TreeDestructor (&code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq -0x58(%rbp), %rbx
movq $0x0, (%rbx)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movl $0xc, 0x30(%rbx)
movups %xmm0, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
callq 0x3190
movq %rbx, %rdi
callq 0x37cd
testb %al, %al
je 0x1305
leaq -0x58(%rbp), %rdi
callq 0x1317
leaq -0x58(%rbp), %rdi
callq 0x31cd
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: GoElf(Tree*)
void GoElf (Tree* code)
{
    assert (code);

    Elf elf = {};
    if (ElfConstructor (&elf))
        return;
    
    ElfAddBytes (&elf, "\xE8\x00\x00\x00\x00"           // call ♂sex♂
                       "\x48\xC7\xC0\x3C\x00\x00\x00"   // mov rax, 0x3C
                       "\x48\x31\xFF"                   // xor rdi, rdi
                       "\x0F\x05",                      // syscall
                       17);

    ElfAddPlace (&elf, "♂sex♂", 1);

    if (PrintDec (&elf, code->head))
        printf ("Something went wrong...\n");

    ElfCreateJumps (&elf);
    ElfWrite (&elf);
    system ("chmod u+x CompileResult/RightProgram.elf");
    ElfDestructor (&elf);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1434
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, -0x80(%rbp)
movq $-0x1, %rcx
movq %rcx, -0x78(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x70(%rbp)
movq %rax, -0x60(%rbp)
movq %rcx, -0x58(%rbp)
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10a0
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rbp)
movups %xmm0, -0x50(%rbp)
movups %xmm0, -0x30(%rbp)
movb $0x0, -0x20(%rbp)
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x1429
leaq -0x30(%rbp), %r15
leaq 0x3cba(%rip), %rax      # 0x5044
movq %rax, -0x50(%r15)
leaq 0x3cbd(%rip), %rax      # 0x5052
movq %rax, -0x30(%r15)
movq $0x1000, 0x8(%r15)      # imm = 0x1000
leaq 0x3cd9(%rip), %rsi      # 0x5081
leaq -0x80(%rbp), %r14
movl $0x11, %edx
movq %r14, %rdi
callq 0x15a4
leaq 0x403a(%rip), %rsi      # 0x53fa
movl $0x1, %edx
movq %r14, %rdi
callq 0x1717
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1dd8
testb %al, %al
je 0x13e8
leaq 0x43fc(%rip), %rdi      # 0x57df
callq 0x1180
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x1b23
movq %rbx, %rdi
callq 0x1cb2
leaq 0x4001(%rip), %rdi      # 0x5404
callq 0x10d0
movq 0x40(%rbx), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x48(%rbx), %rdi
callq 0x1519
movq $0x0, 0x48(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3fa7(%rip), %rdi      # 0x53e2
leaq 0x3c86(%rip), %rsi      # 0x50c8
leaq 0x3f9e(%rip), %rcx      # 0x53e7
movl $0x12b, %edx            # imm = 0x12B
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfConstructor(Elf*)
bool ElfConstructor (Elf* elf)
{
    assert (elf);

    elf->text = (char*) calloc (ALIGN, sizeof (*(elf->text)));
    if (!(elf->text))
        return 1;
    
    elf->printf_.func_name  = PRINT_STR;
    elf-> scanf_.func_name  = SCAN_STR;
    elf->aligned_text_size  = ALIGN;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14a3
movq %rdi, %rbx
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10a0
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x1496
leaq 0x3bc4(%rip), %rcx      # 0x5044
movq %rcx, (%rbx)
leaq 0x3bc8(%rip), %rcx      # 0x5052
movq %rcx, 0x20(%rbx)
movq $0x1000, 0x58(%rbx)     # imm = 0x1000
testq %rax, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3e64(%rip), %rdi      # 0x530e
leaq 0x3c17(%rip), %rsi      # 0x50c8
leaq 0x3c24(%rip), %rcx      # 0x50dc
movl $0x11, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfDestructor(Elf*)
bool ElfDestructor  (Elf* elf)
{
    assert (elf);

    free (elf->text);
    elf->aligned_text_size = 0;
    elf->text_size = 0;
    bool ret = FuncPointerDestructor (elf->functions);
    elf->functions = 0;

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14fa
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x48(%rbx), %rdi
callq 0x1519
movq $0x0, 0x48(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3e0d(%rip), %rdi      # 0x530e
leaq 0x3bc0(%rip), %rsi      # 0x50c8
leaq 0x3be8(%rip), %rcx      # 0x50f7
movl $0x1f, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerDestructor(FuncPointer*)
bool FuncPointerDestructor  (FuncPointer* func_p)
{
    assert (func_p);

    while (func_p)
    {
        PointerPlace* i_place = func_p->last_pl;
        while (i_place)
        {
            PointerPlace* next_place = i_place->next_place;
            *i_place = {};
            free (i_place);
            i_place  = next_place;
        }

        FuncPointer* next_func = func_p->p_next;
        *func_p = {};
        free (func_p);
        func_p = next_func;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1585
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1551
movq 0x8(%rdi), %r14
movq $-0x1, (%rdi)
movq $0x0, 0x8(%rdi)
callq 0x1120
movq %r14, %rdi
testq %r14, %r14
jne 0x1531
leaq 0x10(%rbx), %rax
movq 0x18(%rbx), %r14
movq $0x0, (%rbx)
movq $-0x1, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, %rdi
callq 0x1120
movq %r14, %rbx
testq %r14, %r14
jne 0x1528
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3dbb(%rip), %rdi      # 0x5347
leaq 0x3b35(%rip), %rsi      # 0x50c8
leaq 0x3db4(%rip), %rcx      # 0x534e
movl $0xf5, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddBytes(Elf*, char const*, unsigned long)
bool ElfAddBytes    (Elf* elf, const char* bytes, size_t amount_bytes)
{
    assert (elf);
    assert (bytes);
    if (elf->aligned_text_size < elf->text_size + amount_bytes)
        if (ElfResizeText (elf))
            return 1;

    memcpy (elf->text + elf->text_size, bytes, amount_bytes);
    elf->text_size += amount_bytes;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1602
movq %rsi, %r15
testq %rsi, %rsi
je 0x1621
movq %rdx, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rax
addq %rdx, %rax
cmpq %rax, 0x58(%rdi)
jae 0x15de
movq %r14, %rdi
callq 0x1640
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x15f7
movq 0x40(%r14), %rdi
addq 0x50(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10c0
addq %rbx, 0x50(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d05(%rip), %rdi      # 0x530e
leaq 0x3ab8(%rip), %rsi      # 0x50c8
leaq 0x3afa(%rip), %rcx      # 0x5111
movl $0x2c, %edx
callq 0x1090
leaq 0x3b17(%rip), %rdi      # 0x513f
leaq 0x3a99(%rip), %rsi      # 0x50c8
leaq 0x3adb(%rip), %rcx      # 0x5111
movl $0x2d, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfResizeText(Elf*)
bool ElfResizeText  (Elf* elf)
{
    assert (elf);

    elf->text = (char*) realloc (elf->text, elf->aligned_text_size + ALIGN); // sizeof (byte = 1)
    if (!(elf->text)) return 1;
    elf->aligned_text_size += ALIGN;
    return ElfFillZero (elf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16a0
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movl $0x1000, %esi           # imm = 0x1000
addq 0x58(%rbx), %rsi
callq 0x1190
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x1695
movq 0x58(%rbx), %rcx
leaq 0x1000(%rcx), %rdx
movq %rdx, 0x58(%rbx)
cmpq $-0x1000, %rcx          # imm = 0xF000
setae %bl
jae 0x1697
movl $0x2000, %edx           # imm = 0x2000
movq %rax, %rdi
xorl %esi, %esi
callq 0x1080
jmp 0x1697
movb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3c67(%rip), %rdi      # 0x530e
leaq 0x3a1a(%rip), %rsi      # 0x50c8
leaq 0x3a90(%rip), %rcx      # 0x5145
movl $0x39, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfFillZero(Elf*)
bool ElfFillZero    (Elf* elf)
{
    assert (elf);

    if (elf->aligned_text_size < ALIGN)
        return 1;
    
    for (size_t i_byte = 0; i_byte < ALIGN / 4; i_byte++)
        ((size_t*) elf->text)[i_byte] = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16f8
movq 0x58(%rdi), %rbx
cmpq $0x1000, %rbx           # imm = 0x1000
jb 0x16e7
movq 0x40(%rdi), %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x1080
cmpq $0x1000, %rbx           # imm = 0x1000
setb %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3c0f(%rip), %rdi      # 0x530e
leaq 0x39c2(%rip), %rsi      # 0x50c8
leaq 0x3a52(%rip), %rcx      # 0x515f
movl $0x43, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddPlace(Elf*, char const*, unsigned long)
bool ElfAddPlace    (Elf* elf, const char* func_name, size_t place)
{
    assert (elf);

    if (strcmp (PRINT_STR, func_name) == 0)
        return ElfAddPrintf (elf, place);

    if (strcmp (SCAN_STR, func_name)  == 0)
        return ElfAddScanf  (elf, place);

    FuncPointer* func_p = elf->functions;
    while (func_p)
    {
        if (strcmp (func_p->func_name, func_name) == 0)
            return FuncPointerGetNewPlace (func_p, place);
        
        func_p = func_p->p_next;
    }
    
    if (FuncPointerConstructor (elf, func_name))
        return 1;
    
    return FuncPointerGetNewPlace (elf->functions, place);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1830
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3909(%rip), %rdi      # 0x5044
callq 0x1150
testl %eax, %eax
je 0x177b
leaq 0x3907(%rip), %rdi      # 0x5052
movq %r15, %rsi
callq 0x1150
testl %eax, %eax
je 0x17d1
movq 0x48(%r14), %r12
testq %r12, %r12
je 0x17aa
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1150
testl %eax, %eax
je 0x17fc
movq 0x18(%r12), %r12
jmp 0x175b
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
movq %rax, %rcx
testq %rax, %rax
sete %al
je 0x1827
movq %rbx, (%rcx)
movq 0x10(%r14), %rdx
movq %rdx, 0x8(%rcx)
movq %rcx, 0x10(%r14)
jmp 0x1827
movq %r14, %rdi
movq %r15, %rsi
callq 0x196c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1827
movq 0x48(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x190d
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
movq %rax, %rcx
testq %rax, %rax
sete %al
je 0x1827
movq %rbx, (%rcx)
movq 0x30(%r14), %rdx
movq %rdx, 0x8(%rcx)
movq %rcx, 0x30(%r14)
jmp 0x1827
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
movq %rax, %rcx
testq %rax, %rax
sete %al
je 0x1827
movq %rbx, (%rcx)
movq 0x10(%r12), %rdx
movq %rdx, 0x8(%rcx)
movq %rcx, 0x10(%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ad7(%rip), %rdi      # 0x530e
leaq 0x388a(%rip), %rsi      # 0x50c8
leaq 0x3932(%rip), %rcx      # 0x5177
movl $0x4f, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerGetNewPlace(FuncPointer*, unsigned long)
bool FuncPointerGetNewPlace (FuncPointer* func_p, size_t place)
{
    assert (func_p);

    PointerPlace* new_place = (PointerPlace*) calloc (1, sizeof (*new_place));
    if (!new_place)
        return 1;
    
    new_place->point = place;
    new_place->next_place = func_p->last_pl;
    func_p->last_pl = new_place;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x194d
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
testq %rax, %rax
je 0x1942
movq %r14, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rbx)
testq %rax, %rax
sete %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x39f3(%rip), %rdi      # 0x5347
leaq 0x376d(%rip), %rsi      # 0x50c8
leaq 0x3a16(%rip), %rcx      # 0x5378
movl $0x10d, %edx            # imm = 0x10D
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerConstructor(Elf*, char const*)
bool FuncPointerConstructor (Elf* elf, const char* func_name)
{
    assert (elf);
    assert (func_name);

    FuncPointer* func_p = (FuncPointer*) calloc (1, sizeof (*func_p));
    if (!func_p)
        return 1;
    
    func_p->func_name = func_name;
    func_p->p_next    = elf->functions;
    elf->functions    = func_p;
    func_p->func_pl   = elf->text_size;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x19b9
movq %rsi, %r14
testq %rsi, %rsi
je 0x19d8
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
testq %rax, %rax
je 0x19ae
movq %r14, (%rax)
movq 0x48(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x48(%rbx)
movq 0x50(%rbx), %rcx
movq %rcx, 0x8(%rax)
testq %rax, %rax
sete %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x394e(%rip), %rdi      # 0x530e
leaq 0x3701(%rip), %rsi      # 0x50c8
leaq 0x3948(%rip), %rcx      # 0x5316
movl $0xe5, %edx
callq 0x1090
leaq 0x382c(%rip), %rdi      # 0x520b
leaq 0x36e2(%rip), %rsi      # 0x50c8
leaq 0x3929(%rip), %rcx      # 0x5316
movl $0xe6, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddFunc(Elf*, char const*)
bool ElfAddFunc     (Elf* elf, const char* func_name)
{
    assert (elf);
    assert (func_name);

    FuncPointer* func_p = elf->functions;
    while (func_p)
    {
        if (strcmp (func_p->func_name, func_name) == 0)
        {
            func_p->func_pl = elf->text_size;
            return 0;
        }

        func_p = func_p->p_next;
    }

    return FuncPointerConstructor (elf, func_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a73
movq %rsi, %r14
testq %rsi, %rsi
je 0x1a92
movq %rdi, %rbx
movq 0x48(%rdi), %r15
testq %r15, %r15
je 0x1a33
movq (%r15), %rdi
movq %r14, %rsi
callq 0x1150
testl %eax, %eax
je 0x1a5e
movq 0x18(%r15), %r15
jmp 0x1a19
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movq %rax, %r15
testq %rax, %rax
sete %al
je 0x1a68
movq %r14, (%r15)
movq 0x48(%rbx), %rcx
movq %rcx, 0x18(%r15)
movq %r15, 0x48(%rbx)
jmp 0x1a60
xorl %eax, %eax
movq 0x50(%rbx), %rcx
movq %rcx, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3894(%rip), %rdi      # 0x530e
leaq 0x3647(%rip), %rsi      # 0x50c8
leaq 0x375e(%rip), %rcx      # 0x51e6
movl $0x76, %edx
callq 0x1090
leaq 0x3772(%rip), %rdi      # 0x520b
leaq 0x3628(%rip), %rsi      # 0x50c8
leaq 0x373f(%rip), %rcx      # 0x51e6
movl $0x77, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfCreateJumps(Elf*)
bool ElfCreateJumps (Elf* elf)
{
    assert (elf);

    FuncPointer* func_p = elf->functions;

    while (func_p)
    {
        if (func_p->func_pl == __SIZE_MAX__)
        {
            printf ("Error: Function \"%s\" isn't defined.\n", func_p->func_name);
            return 1;
        }

        FuncPointerFillPlaces (func_p, elf->text);
        func_p = func_p->p_next;
    }

    if (elf->printf_.last_pl)
        if (ElfAddLibrary (elf, "Libraries/printf.gcmlib", &(elf->printf_)))
            return 1;

    if (elf->scanf_.last_pl)
        if (ElfAddLibrary (elf, "Libraries/scanf.gcmlib", &(elf->scanf_)))
            return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1bb7
movq %rdi, %rbx
movq 0x48(%rdi), %r14
testq %r14, %r14
je 0x1b58
cmpq $-0x1, 0x8(%r14)
je 0x1b9f
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x1bd6
movq 0x18(%r14), %r14
jmp 0x1b3a
cmpq $0x0, 0x10(%rbx)
je 0x1b79
leaq 0x3725(%rip), %rsi      # 0x528b
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x1c49
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1bb2
cmpq $0x0, 0x30(%rbx)
je 0x1b9b
leaq 0x20(%rbx), %rdx
leaq 0x3718(%rip), %rsi      # 0x52a3
movq %rbx, %rdi
callq 0x1c49
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1bb2
xorl %eax, %eax
jmp 0x1bb2
movq (%r14), %rsi
leaq 0x36bd(%rip), %rdi      # 0x5266
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3750(%rip), %rdi      # 0x530e
leaq 0x3503(%rip), %rsi      # 0x50c8
leaq 0x367f(%rip), %rcx      # 0x524b
movl $0x9d, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerFillPlaces(FuncPointer*, char*)
void FuncPointerFillPlaces  (FuncPointer* func_p, char* text)
{
    assert (func_p);
    assert (text);

    int func_addr = (int) func_p->func_pl;
    PointerPlace* i_place = func_p->last_pl;

    while (i_place)
    {
        *(int*) (text + i_place->point) = func_addr - JMP_NUM_SIZE - i_place->point;
        i_place = i_place->next_place;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1c0b
testq %rsi, %rsi
je 0x1c2a
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1c09
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
addq 0x8(%rdi), %rcx
movq (%rax), %rdx
movl %ecx, %edi
subl %edx, %edi
movl %edi, (%rsi,%rdx)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1bf6
popq %rbp
retq
leaq 0x3735(%rip), %rdi      # 0x5347
leaq 0x34af(%rip), %rsi      # 0x50c8
leaq 0x378b(%rip), %rcx      # 0x53ab
movl $0x11b, %edx            # imm = 0x11B
callq 0x1090
leaq 0x37ac(%rip), %rdi      # 0x53dd
leaq 0x3490(%rip), %rsi      # 0x50c8
leaq 0x376c(%rip), %rcx      # 0x53ab
movl $0x11c, %edx            # imm = 0x11C
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddLibrary(Elf*, char const*, FuncPointer*)
bool ElfAddLibrary  (Elf* elf, const char* lib_name, FuncPointer* lib_p)
{
    char* lib_text  = nullptr;
    size_t lib_size = ReadTxt (&lib_text, lib_name);
    if (!lib_size)
        return 1;

    lib_p->func_pl = elf->text_size;
    if (ElfAddBytes (elf, lib_text, lib_size))
        return 1;

    FuncPointerFillPlaces (lib_p, elf->text);
    free (lib_text);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rdi
movq $0x0, (%rdi)
callq 0x3546
movb $0x1, %r15b
testq %rax, %rax
je 0x1ca4
movq 0x50(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rbp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x15a4
testb %al, %al
jne 0x1ca4
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x1bd6
movq -0x20(%rbp), %rdi
callq 0x1120
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfWrite(Elf*)
bool ElfWrite       (Elf* elf)
{
    assert (elf);

    system ("cp Backend/ServiceFiles/MagicHeader CompileResult/RightProgram.elf");

    FILE* compiled_file = fopen ("CompileResult/RightProgram.elf", "a+b");
    if (!compiled_file)
    {
        printf ("Error: Unable to create or open file: \"CompileResult/RightProgram.elf\".\n");
        return 1;
    }

    fwrite (&(elf->text_size), sizeof (elf->text_size), 1, compiled_file); // p_filesz
    fwrite (&(elf->text_size), sizeof (elf->text_size), 1, compiled_file); // p_memsz
    fwrite (&ALIGN, sizeof (ALIGN), 1, compiled_file); // p_align
    // fseek  (compiled_file, ALIGN, SEEK_SET); It doesn't work (documentation for a) :-(

    size_t align_need_many_zeroes = (ALIGN - ftell (compiled_file)) / 8;
    for (size_t i_8byte = 0; i_8byte < align_need_many_zeroes; i_8byte++)
        fwrite ("\0\0\0\0\0\0\0\0", 1, 8, compiled_file);

    fwrite (elf->text, sizeof (*(elf->text)), elf->aligned_text_size, compiled_file);
    fclose (compiled_file);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1db9
movq %rdi, %r14
leaq 0x35ff(%rip), %rdi      # 0x52cf
callq 0x10d0
leaq 0x3617(%rip), %rdi      # 0x52f3
leaq 0x362f(%rip), %rsi      # 0x5312
callq 0x1110
movq %rax, %rbx
testq %rax, %rax
je 0x1d9e
leaq 0x50(%r14), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11a0
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11a0
leaq 0x3347(%rip), %rdi      # 0x5070
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11a0
movq %rbx, %rdi
callq 0x1030
movl $0x1000, %r12d          # imm = 0x1000
subq %rax, %r12
cmpq $0x8, %r12
jb 0x1d7f
shrq $0x3, %r12
cmpq $0x1, %r12
adcq $0x0, %r12
leaq 0x3313(%rip), %r15      # 0x5078
movl $0x1, %esi
movl $0x8, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11a0
decq %r12
jne 0x1d65
movq 0x40(%r14), %rdi
movq 0x58(%r14), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x11a0
movq %rbx, %rdi
callq 0x10f0
jmp 0x1daa
leaq 0x3a52(%rip), %rdi      # 0x57f7
callq 0x1180
testq %rbx, %rbx
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x354e(%rip), %rdi      # 0x530e
leaq 0x3301(%rip), %rsi      # 0x50c8
leaq 0x34ec(%rip), %rcx      # 0x52ba
movl $0xca, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintDec(Elf*, element*)
bool PrintDec (Elf* elf, element* el)
{
    assert (elf);
    assert (el);
    
    if (el->type != DEC)
        return 1;

    if (PrintFunc (elf, el->left))
        return 1;

    if (el->right && PrintDec (elf, el->right))
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1e2b
movq %rsi, %r15
testq %rsi, %rsi
je 0x1e4a
movb $0x1, %bl
cmpl $0x1, (%r15)
jne 0x1e1e
movq %rdi, %r14
movq 0x8(%r15), %rsi
callq 0x1e69
testb %al, %al
jne 0x1e1e
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x1e1c
movq %r14, %rdi
callq 0x1dd8
testb %al, %al
jne 0x1e1e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34dc(%rip), %rdi      # 0x530e
leaq 0x328f(%rip), %rsi      # 0x50c8
leaq 0x35ed(%rip), %rcx      # 0x542d
movl $0x145, %edx            # imm = 0x145
callq 0x1090
leaq 0x35fc(%rip), %rdi      # 0x544d
leaq 0x3270(%rip), %rsi      # 0x50c8
leaq 0x35ce(%rip), %rcx      # 0x542d
movl $0x146, %edx            # imm = 0x146
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintFunc(Elf*, element*)
bool PrintFunc (Elf* elf, element* el)
{
    assert (elf);
    assert (el);
    if (el->type != FUNC)
        return 1;

    ElfAddFunc (elf, el->ind);
    elf->xmm_counter = 0;

    const size_t max_var_num = 32;
    Stack vars_ = {};
    StackConstructor (&vars_, max_var_num);

    char var_count = FIRST_LOCAL_VAR;
    if (TakeFuncVars (el, &vars_, &var_count))
    {
        StackDestructor (&vars_);
        return 1;
    }

    Stack* vars = &vars_;
    ElfStartFunc (elf);
    TryPrint (PrintLR,   right);
    ElfEndFunc (elf);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
testq %rdi, %rdi
je 0x1f86
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1fa5
movb $0x1, %r15b
cmpl $0x2, (%rbx)
jne 0x1f78
movq %rdi, %r14
movq 0x18(%rbx), %rsi
callq 0x19f7
movb $0x0, 0x60(%r14)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
leaq -0x68(%rbp), %r15
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movl $0xc, 0x28(%r15)
movups %xmm0, 0x30(%r15)
movq %rax, 0x40(%r15)
movl $0x20, %esi
movq %r15, %rdi
callq 0x3a98
leaq -0x19(%rbp), %rdx
movb $-0x8, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1fc4
testb %al, %al
je 0x1f08
leaq -0x68(%rbp), %rdi
callq 0x3f06
movb $0x1, %r15b
jmp 0x1f78
leaq 0x3151(%rip), %rsi      # 0x5060
movl $0xb, %edx
movq %r14, %rdi
callq 0x15a4
movq 0x10(%rbx), %rsi
leaq -0x68(%rbp), %rdx
movq %r14, %rdi
callq 0x212f
movl %eax, %r15d
testb %al, %al
je 0x1f64
leaq 0x3537(%rip), %rdi      # 0x5471
leaq 0x350f(%rip), %rsi      # 0x5450
movl $0x16b, %edx            # imm = 0x16B
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x353e(%rip), %rdi      # 0x5496
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
jmp 0x1f78
leaq 0x32da(%rip), %rsi      # 0x5245
movl $0x5, %edx
movq %r14, %rdi
callq 0x15a4
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3381(%rip), %rdi      # 0x530e
leaq 0x3134(%rip), %rsi      # 0x50c8
leaq 0x34b5(%rip), %rcx      # 0x5450
movl $0x156, %edx            # imm = 0x156
callq 0x1090
leaq 0x34a1(%rip), %rdi      # 0x544d
leaq 0x3115(%rip), %rsi      # 0x50c8
leaq 0x3496(%rip), %rcx      # 0x5450
movl $0x157, %edx            # imm = 0x157
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: PrintLR(Elf*, element*, Stack*)
bool PrintLR    (Elf* elf, element* el, Stack* vars)
{
    print_ass;

    if (el->type == LR)
    {
        if (el->left)
            TryPrint (PrintLR, left);
        if (el->right)
            TryPrint (PrintLR, right);
        return 0;
    }

    elf->xmm_counter = 0;

    switch (el->type)
    {
        case EQUAL:
            return PrintEqual (elf, el, vars);
        case CALL:
            return PrintCall  (elf, el, vars);
        case RET:
            return PrintRet   (elf, el, vars);
        case IF:
        case WHILE:
            return PrintCond  (elf, el, vars);
        default:
            return 1;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2266
movq %rsi, %rbx
testq %rsi, %rsi
je 0x226f
movq %rdx, %r14
testq %rdx, %rdx
je 0x2278
movq %rdi, %r15
movl (%rbx), %eax
cmpl $0x3, %eax
jne 0x2191
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x21c6
movq %r15, %rdi
movq %r14, %rdx
callq 0x212f
testb %al, %al
je 0x21c6
leaq 0x32ee(%rip), %rdi      # 0x5471
leaq 0x3391(%rip), %rsi      # 0x551b
movl $0x1bc, %edx            # imm = 0x1BC
jmp 0x21f1
movb $0x0, 0x60(%r15)
addl $-0xa, %eax
cmpl $0x4, %eax
ja 0x220d
leaq 0x2e8b(%rip), %rcx      # 0x5030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x268e
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2211
movq %r15, %rdi
movq %r14, %rdx
callq 0x212f
testb %al, %al
je 0x2211
leaq 0x328c(%rip), %rdi      # 0x5471
leaq 0x332f(%rip), %rsi      # 0x551b
movl $0x1be, %edx            # imm = 0x1BE
xorl %eax, %eax
callq 0x1040
movq 0x18(%rbx), %rdx
leaq 0x3293(%rip), %rdi      # 0x5496
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movb $0x1, %al
jmp 0x2213
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x232d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25c1
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x243c
leaq 0x30a1(%rip), %rdi      # 0x530e
jmp 0x227f
leaq 0x31d7(%rip), %rdi      # 0x544d
jmp 0x227f
leaq 0x323a(%rip), %rdi      # 0x54b9
leaq 0x2e42(%rip), %rsi      # 0x50c8
leaq 0x328e(%rip), %rcx      # 0x551b
movl $0x1b7, %edx            # imm = 0x1B7
callq 0x1090