LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH14_OverloadedOperationsAndConversions/examples/directcall.cc
// Function: main
int main()
{
	Sales_data data1, data2;
	std::cin >> data1 >> data2;    // read Sales_data transactions
	cout << data1 + data2 << endl; // write sum of Sales_data objects
	cout << 42 + 5 << endl;        // write sum of ints

	// equivalent calls to a nonmember operator function
	data1 + data2;            // normal expression
	operator+(data1, data2);  // equivalent function call
	cout << operator+(data1, data2) << endl;

	data1 += data2;           // expression-based ``call''
	data1.operator+=(data2);  // equivalent call to a member operator function
	cout << data1 << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xf8, %rsp
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x2d0f(%rip), %rdi      # 0x3fe0
leaq -0x38(%rbp), %rsi
callq 0x147e
leaq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x147e
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1554
movq 0x2ccf(%rip), %rdi      # 0x3fd0
leaq -0x98(%rbp), %rsi
callq 0x1586
movq %rax, %rdi
callq 0x1040
leaq -0x98(%rbp), %rdi
callq 0x1030
movq 0x2ca8(%rip), %rdi      # 0x3fd0
pushq $0x2f
popq %rsi
callq 0x10f0
movq %rax, %rdi
callq 0x1040
leaq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1554
leaq -0xf8(%rbp), %rdi
callq 0x1030
leaq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1554
leaq -0xc8(%rbp), %rdi
callq 0x1030
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x1554
movq 0x2c3d(%rip), %rdi      # 0x3fd0
leaq -0x98(%rbp), %rsi
callq 0x1586
movq %rax, %rdi
callq 0x1040
leaq -0x98(%rbp), %rdi
callq 0x1030
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1536
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1536
movq 0x2bfc(%rip), %rdi      # 0x3fd0
leaq -0x38(%rbp), %rsi
callq 0x1586
movq %rax, %rdi
callq 0x1040
leaq -0x68(%rbp), %rdi
callq 0x1030
leaq -0x38(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
jmp 0x141a
jmp 0x141a
jmp 0x1409
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1030
jmp 0x141d
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x1030
leaq -0x38(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O2/shammellee[P]mdl/mdl.cpp
// Function: command_init()
void command_init()
{
  command_add_flag(MDL_CMD_BASE);
  command_add_flag("--restrict-filenames");
  command_add_flag("--no-overwrites");
  command_add_flag("--ignore-errors");
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0xb72b(%rip), %rsi      # 0x112a0
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0x5350
movq %rbx, %rdi
callq 0x5b1c
leaq 0x70(%rsp), %rdi
callq 0x54d8
leaq 0x5523(%rip), %rsi      # 0xb0be
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6b2a
leaq 0x50(%rsp), %rdi
callq 0x5b1c
leaq 0x50(%rsp), %rdi
callq 0x54d8
leaq 0x550e(%rip), %rsi      # 0xb0d3
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6b2a
leaq 0x30(%rsp), %rdi
callq 0x5b1c
leaq 0x30(%rsp), %rdi
callq 0x54d8
leaq 0x54f4(%rip), %rsi      # 0xb0e3
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6b2a
leaq 0x10(%rsp), %rdi
callq 0x5b1c
leaq 0x10(%rsp), %rdi
callq 0x54d8
addq $0x90, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x5c4a
jmp 0x5c3d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x5c4a
jmp 0x5c3d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x5c4a
movq %rax, %rbx
jmp 0x5c4f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x54d8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/shammellee[P]mdl/mdl.cpp
// Function: command_call()
void command_call()
{
  command_add_flag("--batch-file " + manifest_file_path);

  cout << "\e[33mCommand:\e[m " << final_command << endl;

  if(dry_run) return;

  cout << "Download initiated..." << endl;

  system(final_command.c_str());
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x5490(%rip), %rsi      # 0xb0f3
leaq 0xb87e(%rip), %rdx      # 0x114e8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x6ba3
movq %rbx, %rdi
callq 0x5b1c
movq %rsp, %rdi
callq 0x54d8
movq 0xb334(%rip), %rdi      # 0x10fc0
leaq 0x546e(%rip), %rsi      # 0xb101
callq 0x5260
leaq 0xb789(%rip), %rsi      # 0x11428
movq %rax, %rdi
callq 0x5240
movq %rax, %rdi
callq 0x5130
cmpb $0x0, 0xb76a(%rip)      # 0x11420
jne 0x5cdf
movq 0xb301(%rip), %rdi      # 0x10fc0
leaq 0x544d(%rip), %rsi      # 0xb113
callq 0x5260
movq %rax, %rdi
callq 0x5130
movq 0xb74e(%rip), %rdi      # 0x11428
callq 0x5210
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x54d8
movq %rbx, %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/cyamonide[P]md2html/./src/main.cpp
// Function: main
int main(int argc, char const *argv[])
{
    Md2html m;

    if (argc >= 3)
    {
        m.setInputPath(argv[1]);
        m.setOutputPath(argv[2]);
    }
    else if (argc == 2)
    {
        m.setInputPath(argv[1]);
        m.setOutputPath("out.html");
    }
    else
    {
        return 1;
    }

    m.start();

    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x578, %rsp            # imm = 0x578
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x90(%rsp), %rdi
callq 0x12100
cmpl $0x3, %ebp
jl 0x5047
movq 0x8(%rbx), %rsi
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51a8
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x12252
leaq 0x70(%rsp), %rdi
callq 0x4548
movq 0x10(%rbx), %rsi
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51a8
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x12280
leaq 0x50(%rsp), %rdi
jmp 0x50a8
cmpl $0x2, %ebp
jne 0x50be
movq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51a8
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12252
leaq 0x30(%rsp), %rdi
callq 0x4548
leaq 0x11184(%rip), %rsi     # 0x16206
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51a8
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12280
leaq 0x10(%rsp), %rdi
callq 0x4548
xorl %ebx, %ebx
leaq 0x90(%rsp), %rdi
callq 0x12526
jmp 0x50c1
pushq $0x1
popq %rbx
leaq 0x90(%rsp), %rdi
callq 0x123f4
movl %ebx, %eax
addq $0x578, %rsp            # imm = 0x578
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x5106
jmp 0x510f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x5106
jmp 0x510f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x5106
jmp 0x510f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4548
jmp 0x5112
jmp 0x510f
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x123f4
movq %rbx, %rdi
callq 0x44a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::~Md2html()
Md2html::~Md2html()
{
    buffer.push_front("");
    closeAllTags();
    flushBuffer();
    fin.close();
    fout.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x3e4e(%rip), %rsi      # 0x16255
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51a8
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x14be0
leaq 0x10(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x124a6
movq %rbx, %rdi
callq 0x124b8
leaq 0xe0(%rbx), %r14
movq %r14, %rdi
callq 0x4080
leaq 0x2e8(%rbx), %r15
movq %r15, %rdi
callq 0x43e0
movq %r15, %rdi
callq 0x4400
movq %r14, %rdi
callq 0x40b0
leaq 0xc0(%rbx), %rdi
callq 0x4548
leaq 0xa0(%rbx), %rdi
callq 0x4548
leaq 0x50(%rbx), %rdi
callq 0x1474e
movq %rbx, %rdi
callq 0x143ce
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x51e3
// File: /workspace/github_cpp_makefile_star2_O2/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::start()
void Md2html::start()
{
    buffer.push_front("");

    while (getNextLine())
    {
        resolveNextLine();
        writeBuffer();
    }

    buffer.push_front("");
    closeAllTags();
    flushBuffer();
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x3d20(%rip), %rsi      # 0x16255
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51a8
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x14be0
leaq 0x10(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x125da
testb %al, %al
je 0x12579
movq %rbx, %rdi
callq 0x12652
movq %rbx, %rdi
callq 0x130ac
jmp 0x1255b
leaq 0x3cd5(%rip), %rsi      # 0x16255
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x51a8
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x14be0
leaq 0x10(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x124a6
movq %rbx, %rdi
callq 0x124b8
addq $0x30, %rsp
popq %rbx
retq
jmp 0x125c0
jmp 0x125cf
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4548
jmp 0x125d2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x44a0
// File: /workspace/github_cpp_makefile_star2_O2/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::closeLastTag()
bool Md2html::closeLastTag()
{
    if (buffer.size() == 1)
    {
        return false;
    }
    else if (state.size() == 0)
    {
        return false;
    }
    else
    {
        buffer[1] += ct(state.top().type);
        state.pop();
    }

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
callq 0x14442
cmpq $0x1, %rax
je 0x1322a
leaq 0x50(%r14), %rbx
movq %rbx, %rdi
callq 0x14fb8
testq %rax, %rax
je 0x1322a
movq 0x80(%r14), %rsi
cmpq 0x88(%r14), %rsi
jne 0x131d6
movq 0x98(%r14), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0x28, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x43b0
movq %rsp, %rdi
movq %r15, %rsi
callq 0xebe5
addq $0x10, %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1506a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x4510
movq %rsp, %rdi
callq 0x4548
leaq 0x20(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x1500a
movb $0x1, %al
jmp 0x1322c
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4548
jmp 0x13246
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x44a0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/stl-arr-fcns.cc
// Function: main
int main() 
{
	print("hi world!"); // calls first version of print
	cout << endl;

    // j is converted to a pointer to the first element in j
    // the second argument is a pointer to one past the end of j
    int j[2] = {0, 1};  
    print(begin(j), end(j));  // library begin and end functions
	cout << endl;

	// equivalent call, directly calculate the begin and end pointers
	print(j, j + 2); 
	cout << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xdaf(%rip), %rdi       # 0x2006
callq 0x11cc
movq 0x2d75(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
callq 0x1030
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq -0x18(%rbp), %r14
movq %rax, -0x8(%r14)
leaq -0x20(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x11fd
movq %rbx, %rdi
callq 0x1030
movq %r15, %rdi
movq %r14, %rsi
callq 0x11fd
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::iteration_proxy_value<nlohmann::detail::iter_impl<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>>>::key() const
const string_type& key() const
    {
        assert(anchor.m_object != nullptr);

        switch (anchor.m_object->type())
        {
            // use integer array index as key
            case value_t::array:
            {
                if (array_index != array_index_last)
                {
                    int_to_string( array_index_str, array_index );
                    array_index_last = array_index;
                }
                return array_index_str;
            }

            // use key from the object
            case value_t::object:
                return anchor.key();

            // use an empty key for all primitive types
            default:
                return empty_str;
        }
    }

// Assembly:
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x3e10
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x3dfe
cmpl $0x2, %eax
jne 0x3e07
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x3df8
leaq 0x30(%rbx), %rdi
callq 0xc6da
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
jmp 0x3e0b
movq %rbx, %rdi
popq %rbx
jmp 0xc70c
addq $0x50, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0xc268(%rip), %rdi      # 0x1007f
leaq 0x993e(%rip), %rsi      # 0xd75c
leaq 0xc275(%rip), %rcx      # 0x1009a
movl $0xd18, %edx            # imm = 0xD18
callq 0x3190
nop
// File: /workspace/github_cpp_makefile_star2_O2/linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::input_adapter::input_adapter<char*, 0>(char*, char*)
input_adapter(IteratorType first, IteratorType last)
    {
#ifndef NDEBUG
        // assertion to check that the iterator range is indeed contiguous,
        // see http://stackoverflow.com/a/35008842/266378 for more discussion
        const auto is_contiguous = std::accumulate(
                                       first, last, std::pair<bool, int>(true, 0),
                                       [&first](std::pair<bool, int> res, decltype(*first) val)
        {
            res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
            return res;
        }).first;
        assert(is_contiguous);
#endif

        // assertion to check that each element is 1 byte long
        static_assert(
            sizeof(typename iterator_traits<IteratorType>::value_type) == 1,
            "each element in the iterator range must have the size of 1 byte");

        const auto len = static_cast<size_t>(std::distance(first, last));
        if (JSON_HEDLEY_LIKELY(len > 0))
        {
            // there is at least one element: use the address of first
            ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
        }
        else
        {
            // the address of first cannot be used: use nullptr
            ia = std::make_shared<input_buffer_adapter>(nullptr, len);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rsi, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x46c0
testb $0x1, %al
je 0x4213
movq 0x20(%rsp), %rax
subq %rax, %r14
movq %r14, 0x10(%rsp)
leaq 0x18(%rsp), %rsi
je 0x4200
movq %rax, (%rsi)
movq %rsp, %rdi
leaq 0x10(%rsp), %rdx
callq 0x471e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x496c
leaq 0x8(%rsp), %rdi
callq 0x499a
addq $0x28, %rsp
popq %rbx
popq %r14
retq
andq $0x0, (%rsi)
movq %rsp, %rdi
leaq 0x10(%rsp), %rdx
callq 0x473f
jmp 0x41e3
leaq 0x9534(%rip), %rdi      # 0xd74e
leaq 0x953b(%rip), %rsi      # 0xd75c
leaq 0x9545(%rip), %rcx      # 0xd76d
movl $0x10a5, %edx           # imm = 0x10A5
callq 0x3190
jmp 0x4236
jmp 0x4236
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x499a
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::iter_impl<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>>::key() const
const typename object_t::key_type& key() const
    {
        assert(m_object != nullptr);

        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
        {
            return m_it.object_iterator->first;
        }

        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc780
cmpb $0x1, (%rax)
jne 0xc732
movq 0x8(%rdi), %rax
addq $0x20, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x3aa5(%rip), %rsi      # 0x101e9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3cf0
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0x946a
xorl %ebp, %ebp
leaq 0xa4e7(%rip), %rsi      # 0x16c58
leaq -0x5da0(%rip), %rdx     # 0x69d8
movq %rbx, %rdi
callq 0x33b0
leaq 0x38ff(%rip), %rdi      # 0x10086
leaq 0xfce(%rip), %rsi       # 0xd75c
leaq 0x39c7(%rip), %rcx      # 0x1015c
movl $0x26be, %edx           # imm = 0x26BE
callq 0x3190
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3120
testb %bpl, %bpl
jne 0xc7b6
jmp 0xc7be
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::iter_impl<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*() const
reference operator*() const
    {
        assert(m_object != nullptr);

        switch (m_object->m_type)
        {
            case value_t::object:
            {
                assert(m_it.object_iterator != m_object->m_value.object->end());
                return m_it.object_iterator->second;
            }

            case value_t::array:
            {
                assert(m_it.array_iterator != m_object->m_value.array->end());
                return *m_it.array_iterator;
            }

            case value_t::null:
                JSON_THROW(invalid_iterator::create(214, "cannot get value"));

            default:
            {
                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
                {
                    return *m_object;
                }

                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xc89c
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0xc87e
cmpl $0x2, %ecx
je 0xc851
testl %ecx, %ecx
je 0xc8bb
cmpq $0x0, 0x18(%rdi)
je 0xc893
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x2666(%rip), %rsi      # 0xee76
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3cf0
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0x946a
xorl %ebp, %ebp
leaq 0xa41b(%rip), %rsi      # 0x16c58
leaq -0x5e6c(%rip), %rdx     # 0x69d8
movq %rbx, %rdi
callq 0x33b0
jmp 0xc909
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rcx), %rax
jne 0xc893
leaq 0x25da(%rip), %rdi      # 0xee40
leaq 0xeef(%rip), %rsi       # 0xd75c
leaq 0x399f(%rip), %rcx      # 0x10213
movl $0x2558, %edx           # imm = 0x2558
callq 0x3190
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0xc909
addq $0x40, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x37e3(%rip), %rdi      # 0x10086
leaq 0xeb2(%rip), %rsi       # 0xd75c
leaq 0x3962(%rip), %rcx      # 0x10213
movl $0x254c, %edx           # imm = 0x254C
callq 0x3190
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
leaq 0x25a9(%rip), %rsi      # 0xee76
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3cf0
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0x946a
xorl %ebp, %ebp
leaq 0xa35e(%rip), %rsi      # 0x16c58
leaq -0x5f29(%rip), %rdx     # 0x69d8
movq %rbx, %rdi
callq 0x33b0
leaq 0x24f8(%rip), %rdi      # 0xee08
leaq 0xe45(%rip), %rsi       # 0xd75c
leaq 0x38f5(%rip), %rcx      # 0x10213
movl $0x2552, %edx           # imm = 0x2552
callq 0x3190
jmp 0xc92c
jmp 0xc940
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3120
testb %bpl, %bpl
jne 0xc943
jmp 0xc94b
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::computeHexPi()
uint32_t Blowfish::computeHexPi() {

    double s1 = series(hexStart, 1);
    double s2 = series(hexStart, 4);
    double s3 = series(hexStart, 5);
    double s4 = series(hexStart, 6);

    double pi = (4.0 * s1) - (2.0 * s2) - s3 - s4;
    pi = pi - (int)pi + 1.0;

    uint32_t pihex= 0;

    for (int i=0; i < 8; i++) {
    	pi *= 16;
    	uint32_t hVal = floor(pi);
    	pihex <<= 4;
    	pihex |= hVal;
    	pi -= hVal;
    }

    hexStart += 8;

    return pihex;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %esi
pushq $0x1
popq %rdx
callq 0x2732
movapd %xmm0, (%rsp)
movl 0x8(%rbx), %esi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x2732
movsd %xmm0, 0x18(%rsp)
movl 0x8(%rbx), %esi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x2732
movsd %xmm0, 0x10(%rsp)
movl 0x8(%rbx), %esi
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x2732
movapd (%rsp), %xmm1
mulsd 0xa3c(%rip), %xmm1      # 0x3008
movsd 0x18(%rsp), %xmm2
addsd %xmm2, %xmm2
subsd %xmm2, %xmm1
subsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm1
addsd 0xa18(%rip), %xmm1      # 0x3010
movapd %xmm1, %xmm0
xorl %ebp, %ebp
pushq $0x8
popq %r14
subl $0x1, %r14d
jb 0x263a
mulsd 0xa08(%rip), %xmm0      # 0x3018
movapd %xmm0, (%rsp)
callq 0x2150
cvttsd2si %xmm0, %rax
shll $0x4, %ebp
orl %eax, %ebp
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x2602
addl $0x8, 0x8(%rbx)
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::pack32BitWord(unsigned char*, unsigned int)
uint32_t Blowfish::pack32BitWord( uint8_t* input, uint32_t startVal ){
    uint32_t result = 0;
    for( unsigned int i = startVal; i < startVal + 4; i++ ){
        result <<= 8;
        result |= input[ i ];
    }
    return result; 
}

// Assembly:
movl %edx, %ecx
addl $0x4, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x2664
shll $0x8, %eax
movzbl (%rsi,%rcx), %edi
orl %edi, %eax
incq %rcx
jmp 0x2651
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::encrypt(unsigned char*)
void Blowfish::encrypt(uint8_t* text){
    
    uint32_t xL, xR, temp;
    xL = pack32BitWord( text, 0 );
    xR = pack32BitWord( text, 4 );
        
    for( int i = 0; i <= 15; i++ ){
        
        xL ^= pArray[ i ];
        xR ^= F( xL );
        
        temp = xL;
        xL = xR;
        xR = temp;
    }
    
    temp = xL;
    xL = xR;
    xR = temp;
    
    xR ^= pArray[ 16 ];
    xL ^= pArray[ 17 ];
    
    //merge into xR and xL into xL
    uint64_t final = 0;
    final |= xL;
    final <<= 32;
    final |= xR;
    //now final is the ciphertext, need to convert to ascii
    
    text[ 0 ] = final >> 56;
    text[ 1 ] = final >> 48;
    text[ 2 ] = final >> 40;
    text[ 3 ] = final >> 32;
    text[ 4 ] = final >> 24;
    text[ 5 ] = final >> 16;
    text[ 6 ] = final >> 8;
    text[ 7 ] = final;
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbp
movq %rdi, %r14
xorl %edx, %edx
callq 0x264a
movl %eax, %ebx
pushq $0x4
popq %rdx
movq %rbp, %rsi
callq 0x264a
movl %eax, %ecx
movl $0x403, %r15d           # imm = 0x403
cmpq $0x413, %r15            # imm = 0x413
je 0x26b6
xorl (%r14,%r15,4), %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %ecx, %r12d
callq 0x26fa
xorl %r12d, %eax
incq %r15
movl %ebx, %ecx
movl %eax, %ebx
jmp 0x2690
xorl 0x104c(%r14), %ebx
xorl 0x1050(%r14), %ecx
movl %ecx, %eax
shrl $0x18, %eax
movb %al, (%rbp)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x1(%rbp)
movb %ch, 0x2(%rbp)
movb %cl, 0x3(%rbp)
movl %ebx, %eax
shrl $0x18, %eax
movb %al, 0x4(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x5(%rbp)
movb %bh, 0x6(%rbp)
movb %bl, 0x7(%rbp)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::series(unsigned int, unsigned int)
double Blowfish::series(uint32_t d, uint32_t j) {

    double sum = 0;
    for ( unsigned int k = 0; k < d; k++ ) {
        sum += (binaryExp(16, (d - k), (8 * k + j))) / (8 * k + j);
        sum = sum - (int)sum;
    }

    for ( unsigned int k = d; k < d + 100; k++ ) {
        sum += pow(16.0, (double) d - k) / (8 * k + j);
        sum = sum - (int)sum;
    }

    return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movl %esi, %ebx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
pushq $0x10
popq %rbp
movl %edx, %r15d
movl %esi, %edx
movl %esi, %r12d
subl $0x1, %r12d
jb 0x279e
movl %r15d, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl %ebp, %esi
callq 0x2816
divsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
addl $0x8, %r15d
movl %r12d, %edx
jmp 0x2758
leal 0x64(%rbx), %ebp
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
leal (%r14,%rbx,8), %r14d
cmpl %ebp, %ebx
jae 0x2804
movl %ebx, %eax
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x839(%rip), %xmm0      # 0x3008
callq 0x20c0
movl %r14d, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movapd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
incl %ebx
addl $0x8, %r14d
jmp 0x27b2
movaps 0x10(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::binaryExp(int, int, double)
double Blowfish::binaryExp(int b, int n, double mod) {

    if (mod == 1.0) {
        return 0;
    }
    
    // Largest power of 2 less than n
    double t = pow(2, floor(log2(n)));

    double r = 1;
    while (t >= 1) {
        if (n >= t) {
            r = fmod(b * r, mod);
            n = n - t;
        }
        
        t = t / 2;

        if (t >= 1) {
            r = fmod(r * r, mod);
        }
    }

    return r;
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd 0x7ea(%rip), %xmm1      # 0x3010
jne 0x282b
jp 0x282b
retq
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, %ebp
movsd %xmm1, 0x10(%rsp)
movl %edx, %edi
callq 0x28e9
callq 0x2150
callq 0x20c0
cvtsi2sd %ebp, %xmm1
movsd %xmm1, 0x18(%rsp)
movapd %xmm0, %xmm1
movsd 0x7ae(%rip), %xmm2      # 0x3010
movapd %xmm2, %xmm0
ucomisd %xmm2, %xmm1
jb 0x28e2
cvtsi2sd %ebx, %xmm3
ucomisd %xmm1, %xmm3
jb 0x28af
mulsd 0x18(%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd %xmm3, 0x20(%rsp)
callq 0x2110
movsd 0x775(%rip), %xmm2      # 0x3010
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm3
subsd %xmm1, %xmm3
cvttsd2si %xmm3, %ebx
mulsd 0x769(%rip), %xmm1      # 0x3020
ucomisd %xmm2, %xmm1
jb 0x2866
mulsd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
callq 0x2110
movsd 0x736(%rip), %xmm2      # 0x3010
movsd 0x8(%rsp), %xmm1
jmp 0x2866
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ethanmick[P]Blowfish482/Profile.cpp
// Function: print_uint8_hex(unsigned char*, unsigned int, char const*)
void print_uint8_hex(uint8_t* buffer, uint32_t size, const char* label) {
    printf("%s: ", label);
    for ( unsigned int i = 0; i < size; i++ ) {
        printf("%.2X ", buffer[ i ]);
        //cout << (uint32_t) buffer[ i ] << " ";
    }
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x738(%rip), %rdi       # 0x3040
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2040
movl %ebp, %r15d
leaq 0x729(%rip), %r14       # 0x3045
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x2938
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
incq %r12
jmp 0x291f
pushq $0xa
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	vector<char> line;
	for(int i=1;i<argc;i++)
	{
		if(argv[i][0] == '-')
		{
			switch(argv[i][1])
			{
				case 'f':  //file
					execfile(argv[i]+2);
					break;

				case 'e': //evaluate
					execute(argv[i]+2);
					break;
					
				case 'h' : //help
					printf("Valid options: -f (executes file), -e (evaluates input) \n");
					break;

				default:
					conoutf("unkown option!");
					break;
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movslq %edi, %r13
pushq $0x1
popq %r14
pushq $0x1
popq %r15
leaq 0xd9d3(%rip), %r12      # 0x11004
cmpq %r13, %r14
jge 0x3688
movq (%rbx,%r14,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x3683
movzbl 0x1(%rdi), %eax
cmpl $0x65, %eax
je 0x366e
cmpl $0x68, %eax
je 0x3660
cmpl $0x66, %eax
jne 0x3679
addq $0x2, %rdi
movl %r15d, %esi
callq 0x7115
jmp 0x3683
leaq 0xd9ac(%rip), %rdi      # 0x11013
callq 0x22f0
jmp 0x3683
addq $0x2, %rdi
callq 0x6f39
jmp 0x3683
movq %r12, %rdi
xorl %eax, %eax
callq 0x350f
incq %r14
jmp 0x3631
leaq -0x40(%rbp), %rdi
callq 0x36e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x36e0
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: clearoverride(ident&)
void clearoverride(ident &i)
{
    if(!(i.flags&IDF_OVERRIDDEN)) return;
    switch(i.type)
    {
        case ID_ALIAS:
            if(i.valtype==VAL_STR) 
            {
                if(!i.val.s[0]) break;
                delete[] i.val.s;
            }
            cleancode(i);
            i.valtype = VAL_STR;
            i.val.s = newstring("");
            break;
        case ID_VAR:
            *i.storage.i = i.overrideval.i;
            i.changed();
            break;
        case ID_FVAR:
            *i.storage.f = i.overrideval.f;
            i.changed();
            break;
        case ID_SVAR:
            delete[] *i.storage.s;
            *i.storage.s = i.overrideval.s;
            i.changed();
            break;
    }
    i.flags &= ~IDF_OVERRIDDEN;
}

// Assembly:
testb $0x10, 0x38(%rdi)
je 0x3899
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x388f
leaq 0xd83c(%rip), %rcx      # 0x1104c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x28(%rbx), %eax
movq 0x20(%rbx), %rcx
movl %eax, (%rcx)
jmp 0x384f
movq 0x20(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3839
callq 0xf9a8
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
jmp 0x384f
movss 0x28(%rbx), %xmm0
movq 0x20(%rbx), %rax
movss %xmm0, (%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x388f
callq *%rax
jmp 0x388f
cmpl $0x3, 0x10(%rbx)
jne 0x3870
movq 0x20(%rbx), %rdi
cmpb $0x0, (%rdi)
je 0x388f
callq 0xf9a8
movq %rbx, %rdi
callq 0x389a
movl $0x3, 0x10(%rbx)
leaq 0xe489(%rip), %rdi      # 0x11d0f
callq 0xd0ec
movq %rax, 0x20(%rbx)
andb $-0x11, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: cleancode(ident&)
static inline void cleancode(ident &id)
{
    if(id.code)
    {
        id.code[0] -= 0x100;
        if(int(id.code[0]) < 0x100) delete[] id.code;
        id.code = NULL;
    }
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x38ce
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rdi), %rdi
cmpl $0xff, (%rdi)
jg 0x38c3
callq 0xf9a8
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: addcommand(char const*, void (*)(), char const*)
bool addcommand(const char *name, identfun fun, const char *args)
{
    uint argmask = 0;
    int numargs = 0;
    bool limit = true;
    for(const char *fmt = args; *fmt; fmt++) switch(*fmt)
    {
        case 'i': case 'b': case 'f': case 't': case 'N': case 'D': if(numargs < MAXARGS) numargs++; break;
        case 's': case 'e': case 'r': case '$': if(numargs < MAXARGS) { argmask |= 1<<numargs; numargs++; } break;
        case '1': case '2': case '3': case '4': if(numargs < MAXARGS) fmt -= *fmt-'0'+1; break;
        case 'C': case 'V': limit = false; break;
        default: fatal("builtin %s declared with illegal type: %s", name, args); break;
    }
    if(limit && numargs > MAXCOMARGS) fatal("builtin %s declared with too many args: %d", name, numargs);
    addident(ident(ID_COMMAND, name, args, argmask, (void *)fun));
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movb $0x1, %r14b
leaq 0xd72e(%rip), %r13      # 0x11060
xorl %ebx, %ebx
xorl %r12d, %r12d
movq %rdx, -0x38(%rbp)
movzbl (%r15), %eax
leal -0x31(%rax), %ecx
cmpl $0x4, %ecx
jb 0x39a9
leal -0x62(%rax), %ecx
cmpl $0x7, %ecx
jbe 0x3991
leal -0x72(%rax), %ecx
cmpl $0x2, %ecx
jb 0x39b8
cmpl $0x24, %eax
je 0x39b8
cmpl $0x43, %eax
je 0x39c7
cmpl $0x44, %eax
je 0x399b
cmpl $0x4e, %eax
je 0x399b
cmpl $0x56, %eax
je 0x39c7
cmpl $0x74, %eax
je 0x399b
testl %eax, %eax
je 0x39d2
leaq 0xdf6f(%rip), %rdi      # 0x118ef
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
xorl %eax, %eax
callq 0x34f3
jmp 0x39ca
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
xorl %eax, %eax
cmpl $0x19, %r12d
setl %al
addl %eax, %r12d
jmp 0x39ca
cmpl $0x18, %r12d
jg 0x39ca
subq %rax, %r15
addq $0x2f, %r15
jmp 0x39ca
cmpl $0x18, %r12d
jg 0x39ca
btsl %r12d, %ebx
incl %r12d
jmp 0x39ca
xorl %r14d, %r14d
incq %r15
jmp 0x393b
cmpl $0xd, %r12d
setge %al
testb %al, %r14b
je 0x39f3
leaq 0xdf34(%rip), %rdi      # 0x11919
movq -0x30(%rbp), %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x34f3
leaq -0x80(%rbp), %rdi
movl $0x3, (%rdi)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0x20(%rdi)
movl %ebx, 0x28(%rdi)
movq -0x40(%rbp), %rax
movq %rax, 0x30(%rdi)
andl $0x0, 0x38(%rdi)
callq 0x3a61
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: addident(ident const&)
static inline ident *addident(const ident &id)
{
    if(!initedidents)
    {
        if(!identinits) identinits = new vector<ident>;
        identinits->add(id);
        return NULL;
    }
    ident &def = idents.access(id.name, id);
    def.index = identmap.length();
    return identmap.add(&def);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x161d2(%rip)     # 0x19c43
je 0x3aa7
leaq 0x8(%rbx), %rsi
leaq 0x15bf2(%rip), %rdi     # 0x19670
movq %rbx, %rdx
callq 0xd588
leaq 0x15c03(%rip), %rdi     # 0x19690
movl 0x15c09(%rip), %ecx     # 0x1969c
movl %ecx, 0x3c(%rax)
leaq -0x10(%rbp), %rsi
movq %rax, (%rsi)
callq 0xd618
movq (%rax), %rax
jmp 0x3ad5
movq 0x1619a(%rip), %rdi     # 0x19c48
testq %rdi, %rdi
jne 0x3acb
pushq $0x10
popq %rdi
callq 0xf974
movq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x1617d(%rip)     # 0x19c48
movq %rbx, %rsi
callq 0xd520
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: pusharg(ident&, tagval const&, identstack&)
static inline void pusharg(ident &id, const tagval &v, identstack &stack)
{
    stack.val = id.val;
    stack.valtype = id.valtype;
    stack.next = id.stack;
    id.stack = &stack;
    id.setval(v);
    cleancode(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
movq %rax, (%rdx)
movl 0x10(%rdi), %eax
movl %eax, 0x8(%rdx)
movq 0x28(%rdi), %rax
movq %rax, 0x10(%rdx)
movq %rdx, 0x28(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x10(%rdi)
movq (%rsi), %rax
movq %rax, 0x20(%rdi)
popq %rbp
jmp 0x389a
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: poparg(ident&)
static inline void poparg(ident &id)
{
    if(!id.stack) return;
    identstack *stack = id.stack;
    if(id.valtype == VAL_STR) delete[] id.val.s;
    id.setval(*stack);
    cleancode(id);
    id.stack = stack->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x3ba9
movq %rdi, %rbx
cmpl $0x3, 0x10(%rdi)
jne 0x3b8b
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3b8b
callq 0xf9a8
movl 0x8(%r14), %eax
movl %eax, 0x10(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x389a
movq 0x10(%r14), %rax
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: newident(char const*, int)
ident *newident(const char *name, int flags)
{
    ident *id = idents.access(name);
    if(!id)
    {
        if(checknumber(name)) 
        {
            debugcode("number %s is not a valid identifier name", name);
            return dummyident;
        }
        id = addident(ident(ID_ALIAS, newstring(name), flags));
    }
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
leaq -0x18(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x15a6d(%rip), %rdi     # 0x19670
callq 0xd11c
testq %rax, %rax
jne 0x3c63
movq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x3c6c
testb %al, %al
je 0x3c37
leaq 0xdbac(%rip), %rdi      # 0x117d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3cc9
movq 0x15a6b(%rip), %rax     # 0x196a0
jmp 0x3c63
movq %r14, %rdi
callq 0xd0ec
leaq -0x58(%rbp), %rdi
movl $0x4, (%rdi)
movq %rax, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movl %ebx, 0x38(%rdi)
callq 0x3a61
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: checknumber(char const*)
static inline bool checknumber(const char *s)
{
    if(isdigit(s[0])) return true;
    else switch(s[0])
    {
        case '+': case '-': return isdigit(s[1]) || (s[1] == '.' && isdigit(s[2]));
        case '.': return isdigit(s[1]) != 0;
        default: return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsbl (%rdi), %ecx
leal -0x30(%rcx), %edx
movb $0x1, %al
cmpl $0xa, %edx
jb 0x3cc7
movzbl %cl, %ecx
cmpl $0x2b, %ecx
je 0x3c8f
cmpl $0x2e, %ecx
je 0x3cb0
cmpl $0x2d, %ecx
jne 0x3cac
movsbl 0x1(%rdi), %ecx
leal -0x30(%rcx), %edx
cmpl $0xa, %edx
jb 0x3cc7
cmpb $0x2e, %cl
jne 0x3cac
movabsq $0x2, %rax
jmp 0x3cba
xorl %eax, %eax
jmp 0x3cc7
movabsq $0x1, %rax
movsbl (%rdi,%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
setb %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: debugcode(char const*, ...)
static void debugcode(const char *fmt, ...)
{
    if(nodebug) return;

    va_list args;
    va_start(args, fmt);
    conoutfv(CON_ERROR, fmt, args);
    va_end(args);

    debugalias();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x3cfe
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xa8(%rbp)
cmpl $0x0, 0x159b0(%rip)     # 0x196d8
jne 0x3d61
movq %rdi, %r10
leaq -0xd0(%rbp), %rax
leaq -0x20(%rbp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
pushq $0x4
popq %rdi
movq %r10, %rsi
callq 0x34ff
callq 0x9ef7
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: writeident(char const*, int)
ident *writeident(const char *name, int flags)
{
    ident *id = newident(name, flags);
    if(id->index < MAXARGS && !(aliasstack->usedargs&(1<<id->index)))
    {
        pusharg(*id, nullval, aliasstack->argstack[id->index]);
        aliasstack->usedargs |= 1<<id->index;
    }
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x3be8
movq %rax, %rbx
movslq 0x3c(%rax), %rax
cmpq $0x18, %rax
jg 0x3dba
movq 0x1549f(%rip), %rcx     # 0x19228
movl 0x10(%rcx), %edx
btl %eax, %edx
jb 0x3dba
imulq $0x18, %rax, %rdx
addq 0x18(%rcx), %rdx
leaq 0x15910(%rip), %rsi     # 0x196b0
movq %rbx, %rdi
callq 0x3b34
movb 0x3c(%rbx), %cl
pushq $0x1
popq %rax
shll %cl, %eax
movq 0x15471(%rip), %rcx     # 0x19228
orl %eax, 0x10(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: resetvar(char*)
void resetvar(char *name)
{
    ident *id = idents.access(name);
    if(!id) return;
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else clearoverride(*id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x15857(%rip), %rdi     # 0x19670
callq 0xd170
testq %rax, %rax
je 0x3e45
testb $0x8, 0x38(%rax)
jne 0x3e33
movq %rax, %rdi
callq 0x37ea
jmp 0x3e45
movq 0x8(%rax), %rsi
leaq 0xd9bb(%rip), %rdi      # 0x117f9
xorl %eax, %eax
callq 0x3cc9
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: setalias(char const*, tagval&)
static void setalias(const char *name, tagval &v)
{
    ident *id = idents.access(name);
    if(id) 
    {
        if(id->type == ID_ALIAS) 
        {
            if(id->index < MAXARGS) setarg(*id, v); else setalias(*id, v);
        }
        else
        {
            debugcode("cannot redefine builtin %s with an alias", id->name);
            freearg(v);
        }
    }
    else if(checknumber(name)) 
    {
        debugcode("cannot alias number %s", name);
        freearg(v);
    }
    else
    {
        addident(ident(ID_ALIAS, newstring(name), v, identflags));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
leaq -0x18(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x157d8(%rip), %rdi     # 0x19670
callq 0xd11c
testq %rax, %rax
je 0x3ec1
cmpl $0x4, (%rax)
jne 0x3edd
cmpl $0x18, 0x3c(%rax)
jg 0x3f36
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9f9e
jmp 0x3f41
movq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x3c6c
testb %al, %al
je 0x3ef9
leaq 0xdd89(%rip), %rdi      # 0x11c61
movq %r14, %rsi
jmp 0x3ee8
movq 0x8(%rax), %rsi
leaq 0xdd50(%rip), %rdi      # 0x11c38
xorl %eax, %eax
callq 0x3cc9
movq %rbx, %rdi
callq 0x3745
jmp 0x3f41
movq %r14, %rdi
callq 0xd0ec
leaq -0x58(%rbp), %rdi
movl $0x4, (%rdi)
movq %rax, 0x8(%rdi)
movl 0x8(%rbx), %eax
movl %eax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
andq $0x0, 0x28(%rdi)
movl 0x15783(%rip), %eax     # 0x196a8
movl %eax, 0x38(%rdi)
movq (%rbx), %rax
movq %rax, 0x20(%rdi)
callq 0x3a61
jmp 0x3f41
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa016
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: setvar(char const*, int, bool, bool)
void setvar(const char *name, int i, bool dofunc, bool doclamp)
{
    GETVAR(id, name, );
    OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
    if(doclamp) *id->storage.i = clamp(i, id->minval, id->maxval);
    else *id->storage.i = i;
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %r14d
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x15656(%rip), %rdi     # 0x19670
callq 0xd11c
testq %rax, %rax
je 0x4029
cmpl $0x0, (%rax)
je 0x4034
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x1566e(%rip), %edx     # 0x196a8
andl $0x10, %edx
movl 0x38(%rax), %ecx
movl %ecx, %esi
andl $0x2, %esi
orl %edx, %esi
jne 0x4053
testb $0x10, %cl
je 0x406c
andl $-0x13, %ecx
jmp 0x4069
testb $0x1, %cl
jne 0x409e
testb $0x10, %cl
jne 0x406c
movq 0x20(%rax), %rdx
movl (%rdx), %edx
movl %edx, 0x28(%rax)
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
testb %r15b, %r15b
je 0x4086
movl 0x10(%rax), %ecx
movl 0x18(%rax), %edx
cmpl %edx, %r14d
cmovll %r14d, %edx
cmpl %edx, %ecx
cmovgl %ecx, %edx
movl %edx, %r14d
movq 0x20(%rax), %rcx
movl %r14d, (%rcx)
testb %bl, %bl
je 0x4029
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x4029
callq *%rax
jmp 0x4029
movq 0x8(%rax), %rsi
leaq 0xd772(%rip), %rdi      # 0x1181b
xorl %eax, %eax
callq 0x3cc9
jmp 0x4029
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: setfvar(char const*, float, bool, bool)
void setfvar(const char *name, float f, bool dofunc, bool doclamp)
{
    _GETVAR(id, ID_FVAR, name, );
    OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
    if(doclamp) *id->storage.f = clamp(f, id->minvalf, id->maxvalf);
    else *id->storage.f = f;
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movl %esi, %ebx
movss %xmm0, -0x14(%rbp)
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x15598(%rip), %rdi     # 0x19670
callq 0xd11c
testq %rax, %rax
je 0x4175
cmpl $0x1, (%rax)
jne 0x4175
movl 0x155b3(%rip), %edx     # 0x196a8
andl $0x10, %edx
movl 0x38(%rax), %ecx
movl %ecx, %esi
andl $0x2, %esi
orl %edx, %esi
jne 0x410e
testb $0x10, %cl
je 0x412b
andl $-0x13, %ecx
jmp 0x4128
testb $0x1, %cl
jne 0x4163
testb $0x10, %cl
jne 0x412b
movq 0x20(%rax), %rdx
movss (%rdx), %xmm0
movss %xmm0, 0x28(%rax)
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
testb %r14b, %r14b
je 0x4145
movss 0x10(%rax), %xmm0
movss -0x14(%rbp), %xmm1
minss 0x18(%rax), %xmm1
maxss %xmm1, %xmm0
jmp 0x414a
movss -0x14(%rbp), %xmm0
movq 0x20(%rax), %rcx
movss %xmm0, (%rcx)
testb %bl, %bl
je 0x4175
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x4175
callq *%rax
jmp 0x4175
movq 0x8(%rax), %rsi
leaq 0xd6ad(%rip), %rdi      # 0x1181b
xorl %eax, %eax
callq 0x3cc9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Fohlen[P]cubescript-standalone/command.cpp
// Function: setsvar(char const*, char const*, bool)
void setsvar(const char *name, const char *str, bool dofunc)
{
    _GETVAR(id, ID_SVAR, name, );
    OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
    *id->storage.s = newstring(str);
    if(dofunc) id->changed();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x154d5(%rip), %rdi     # 0x19670
callq 0xd11c
testq %rax, %rax
je 0x4247
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x4247
movl 0x154ed(%rip), %ecx     # 0x196a8
andl $0x10, %ecx
movl 0x38(%r14), %eax
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
jne 0x41fb
testb $0x10, %al
je 0x41e8
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x41e1
callq 0xf9a8
movl 0x38(%r14), %eax
andl $-0x11, %eax
movl %eax, 0x38(%r14)
movq 0x20(%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4215
callq 0xf9a8
jmp 0x4215
testb $0x1, %al
jne 0x4235
movq 0x20(%r14), %rcx
movq (%rcx), %rdi
testb $0x10, %al
jne 0x41ef
movq %rdi, 0x28(%r14)
orl $0x10, %eax
movl %eax, 0x38(%r14)
movq %r15, %rdi
callq 0xd0ec
movq 0x20(%r14), %rcx
movq %rax, (%rcx)
testb %bl, %bl
je 0x4247
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x4247
callq *%rax
jmp 0x4247
movq 0x8(%r14), %rsi
leaq 0xd5db(%rip), %rdi      # 0x1181b
xorl %eax, %eax
callq 0x3cc9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq