LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/fei3189[P]PLSI/./plsi.hpp
// Function: PLSI::_resize1d(std::vector<float, std::allocator<float>>&, int)
void _resize1d(vector<float> &array, int d) {
        array.resize(d, 0);
        float sum = 0;
        for (int i = 0; i < array.size(); ++i) {
            array[i] = ((float)rand()) / RAND_MAX;
            sum += array[i];
        }

        for (int i = 0; i < array.size(); ++i) {
            array[i] /= sum;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edx, %rsi
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
movq %rbx, %rdi
callq 0x4caa
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x3d3b
xorps %xmm1, %xmm1
xorl %r14d, %r14d
movss %xmm1, (%rsp)
callq 0x2080
movss (%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x22f7(%rip), %xmm0     # 0x6010
movq (%rbx), %rax
movss %xmm0, (%rax,%r14,4)
addss %xmm0, %xmm1
incq %r14
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
ja 0x3cfb
jmp 0x3d42
sarq $0x2, %rcx
xorps %xmm1, %xmm1
testq %rcx, %rcx
je 0x3d6b
movss 0x22b9(%rip), %xmm0     # 0x6008
divss %xmm1, %xmm0
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x3d55
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/mi-scope.cc
// Function: main
int main()
{
	MI obj;
	obj.Base1::print(0);
	obj.Base2::print(3.14);
	obj.Derived::print("hi");
	obj.print(std::vector<double>());
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movaps 0xdd0(%rip), %xmm0      # 0x2010
leaq -0x58(%rbp), %rbx
movups %xmm0, -0x8(%rbx)
leaq -0x60(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x131a
movsd 0xdc2(%rip), %xmm0      # 0x2020
movq %rbx, %rdi
callq 0x1378
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xdb3(%rip), %rsi       # 0x2028
leaq 0xdae(%rip), %rdx       # 0x202a
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x1492
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13d6
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x12a8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1090
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq -0x60(%rbp), %rdi
callq 0x1434
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x12d8
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x1090
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1312
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
jmp 0x130d
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x1312
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x6f16(%rip), %rsi      # 0xd106
leaq 0xd2f9(%rip), %rdx      # 0x134f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7abf
movq %rbx, %rdi
callq 0x600c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6227
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5290
movq 0xcd92(%rip), %rbx      # 0x12fc0
leaq 0x6edf(%rip), %rsi      # 0xd114
movl $0x11, %edx
movq %rbx, %rdi
callq 0x52f0
movq 0xd1e7(%rip), %rsi      # 0x13430
movq 0xd1e8(%rip), %rdx      # 0x13438
movq %rbx, %rdi
callq 0x52f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51b0
cmpb $0x0, 0xd19f(%rip)      # 0x13428
jne 0x62d2
leaq 0x6e94(%rip), %rsi      # 0xd126
movl $0x15, %edx
movq %rbx, %rdi
callq 0x52f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51b0
movq 0xd163(%rip), %rdi      # 0x13430
callq 0x5220
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5290
movq %rbx, %rdi
callq 0x5450
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x570, %rsp            # imm = 0x570
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x88(%rsp), %rdi
callq 0x1500c
cmpl $0x3, %r14d
jl 0x5555
movq 0x8(%rbx), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5724
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x15222
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5514
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x10(%rbx), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5724
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x15252
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55ee
movq 0x58(%rsp), %rsi
jmp 0x55e6
movl $0x1, %ebp
cmpl $0x2, %r14d
jne 0x55fd
movq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5724
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x15222
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55a4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x15c62(%rip), %rsi     # 0x1b216
leaq 0x15c63(%rip), %rdx     # 0x1b21e
leaq 0x8(%rsp), %rdi
callq 0xa266
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15252
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x55ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
xorl %ebp, %ebp
leaq 0x88(%rsp), %rdi
callq 0x15674
leaq 0x88(%rsp), %rdi
callq 0x154a6
movl %ebp, %eax
addq $0x570, %rsp            # imm = 0x570
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x5687
movq 0x18(%rsp), %rsi
jmp 0x5678
jmp 0x5684
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5687
movq 0x38(%rsp), %rsi
jmp 0x5678
jmp 0x5684
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5687
movq 0x58(%rsp), %rsi
jmp 0x5678
jmp 0x5684
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5687
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x5687
jmp 0x5684
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x154a6
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O1/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::~Md2html()
Md2html::~Md2html()
{
    buffer.push_front("");
    closeAllTags();
    flushBuffer();
    fin.close();
    fout.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5da5(%rip), %rdx      # 0x1b265
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xa266
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19a8a
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x154f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x16d40
testb %al, %al
jne 0x154f1
movq %rbx, %rdi
callq 0x155d2
leaq 0xe0(%rbx), %r14
movq %r14, %rdi
callq 0x4070
leaq 0x2e8(%rbx), %rdi
callq 0x43c0
movq 0xfa71(%rip), %rax      # 0x24f98
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x2e8(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x2e8(%rbx,%rcx)
leaq 0x2f0(%rbx), %rdi
callq 0x4230
leaq 0x3e0(%rbx), %rdi
callq 0x40d0
movq %r14, %rdi
callq 0x4080
movq 0xc0(%rbx), %rdi
leaq 0xd0(%rbx), %rax
cmpq %rax, %rdi
je 0x1557f
movq (%rax), %rsi
incq %rsi
callq 0x42a0
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x1559d
movq (%rax), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rbx), %rdi
callq 0x19590
movq %rbx, %rdi
callq 0x19168
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x155b8
movq %rax, %rdi
callq 0x5761
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5bd7(%rip), %rdx      # 0x1b265
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xa266
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19a8a
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x156d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x156d1
movq %rbx, %rdi
callq 0x1581a
movq %rbx, %rdi
callq 0x16ba0
movq %rbx, %rdi
callq 0x15760
testb %al, %al
jne 0x156c1
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x5b79(%rip), %rdx      # 0x1b265
movq %rdx, %rsi
callq 0xa266
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19a8a
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x15718
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x16d40
testb %al, %al
jne 0x15718
movq %rbx, %rdi
callq 0x155d2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x15738
jmp 0x15754
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x15757
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x15757
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O1/cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::getNextLine()
bool Md2html::getNextLine()
{
    string line_buf;
    if (getline(fin, line_buf))
    {
        buffer.push_front(line_buf);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0xe0(%rdi), %r14
movq 0xe0(%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4280
movsbl %al, %edx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x44c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ebp
testb $0x5, %bpl
jne 0x157cf
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x191b2
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x157e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb $0x5, %bpl
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15812
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/stl-arr-fcns.cc
// Function: print(int const*, int const*)
void print(const int *beg, const int *end) 
{
	// print every element starting at beg up to but not including end
    while (beg != end) 
        cout << *beg++ << " "; // print the current element 
		                       // and advance the pointer
}

// Assembly:
cmpq %rsi, %rdi
je 0x1279
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2d92(%rip), %r15      # 0x3fd8
leaq 0xdb7(%rip), %r12       # 0x2004
movl (%r14), %esi
addq $0x4, %r14
movq %r15, %rdi
callq 0x1090
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1070
cmpq %rbx, %r14
jne 0x124d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd7b(%rip), %rdi       # 0x2006
callq 0x11dc
movq 0x2d41(%rip), %rbx      # 0x3fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq -0x18(%rbp), %r14
movq %rax, -0x8(%r14)
leaq -0x20(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1229
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %r15, %rdi
movq %r14, %rsi
callq 0x1229
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4386
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x4374
cmpl $0x2, %eax
jne 0x437d
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x436e
leaq 0x30(%rbx), %rdi
callq 0xf039
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
addq $0x30, %rbx
jmp 0x4381
movq %rbx, %rdi
popq %rbx
jmp 0xf0fa
addq $0x50, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0xeb86(%rip), %rdi      # 0x12f13
leaq 0xc3d8(%rip), %rsi      # 0x1076c
leaq 0xeb93(%rip), %rcx      # 0x12f2e
movl $0xd18, %edx            # imm = 0xD18
callq 0x3180
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xf17f
cmpb $0x1, (%rax)
jne 0xf124
movq 0x8(%rdi), %rax
addq $0x20, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3f3c(%rip), %rsi      # 0x1307d
leaq 0x3f5e(%rip), %rdx      # 0x130a6
leaq 0x8(%rsp), %rdi
callq 0xeb60
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0xab84
xorl %ebp, %ebp
leaq 0x9aa8(%rip), %rsi      # 0x18c18
leaq -0x7743(%rip), %rdx     # 0x7a34
movq %rbx, %rdi
callq 0x33a0
leaq 0x3d94(%rip), %rdi      # 0x12f1a
leaq 0x15df(%rip), %rsi      # 0x1076c
leaq 0x3e5c(%rip), %rcx      # 0x12ff0
movl $0x26be, %edx           # imm = 0x26BE
callq 0x3180
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf1c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
jmp 0xf1c0
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xf1cd
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edx
callq 0x282c
movapd %xmm0, (%rsp)
movl 0x8(%rbx), %esi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x282c
movsd %xmm0, 0x18(%rsp)
movl 0x8(%rbx), %esi
movq %rbx, %rdi
movl $0x5, %edx
callq 0x282c
movsd %xmm0, 0x10(%rsp)
movl 0x8(%rbx), %esi
movq %rbx, %rdi
movl $0x6, %edx
callq 0x282c
movapd (%rsp), %xmm1
mulsd 0x982(%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 0x95e(%rip), %xmm1      # 0x3010
movapd %xmm1, %xmm0
xorl %ebp, %ebp
movl $0x8, %r14d
mulsd 0x952(%rip), %xmm0      # 0x3018
movapd %xmm0, (%rsp)
callq 0x2180
cvttsd2si %xmm0, %rax
shll $0x4, %ebp
orl %eax, %ebp
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
decl %r14d
jne 0x26be
addl $0x8, 0x8(%rbx)
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
cmpl $-0x5, %edx
ja 0x2727
movl %edx, %ecx
addl $0x4, %edx
xorl %edi, %edi
shll $0x8, %edi
movzbl (%rsi,%rcx), %eax
orl %edi, %eax
incq %rcx
movl %eax, %edi
cmpq %rcx, %rdx
jne 0x2714
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
shll $0x8, %edx
movzbl (%rsi,%rcx), %eax
orl %edx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x272c
xorl %ecx, %ecx
movl $0x4, %edx
movl %ecx, %r8d
shll $0x8, %r8d
movzbl (%rsi,%rdx), %ecx
orl %r8d, %ecx
incq %rdx
cmpq $0x8, %rdx
jne 0x2747
xorl %edx, %edx
movl $0xff, %r8d
movl %ecx, %r9d
movl %eax, %ecx
xorl 0x100c(%rdi,%rdx,4), %ecx
movl %ecx, %r10d
shrl $0x18, %r10d
movl %ecx, %eax
shrl $0xe, %eax
andl $0x3fc, %eax            # imm = 0x3FC
movl 0x40c(%rdi,%rax), %eax
addl 0xc(%rdi,%r10,4), %eax
movl %ecx, %r10d
shrl $0x8, %r10d
andl %r8d, %r10d
xorl 0x80c(%rdi,%r10,4), %eax
movl %ecx, %r10d
andl %r8d, %r10d
addl 0xc0c(%rdi,%r10,4), %eax
xorl %r9d, %eax
incq %rdx
cmpq $0x10, %rdx
jne 0x2766
xorl 0x104c(%rdi), %eax
xorl 0x1050(%rdi), %ecx
movl %ecx, %edx
shrl $0x18, %edx
movb %dl, (%rsi)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x1(%rsi)
movb %ch, 0x2(%rsi)
movb %cl, 0x3(%rsi)
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0x4(%rsi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x5(%rsi)
movb %ah, 0x6(%rsi)
movb %al, 0x7(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
movl %edx, %r14d
movl %esi, %ebx
testl %esi, %esi
je 0x2895
xorpd %xmm0, %xmm0
movl %ebx, %ebp
movl %r14d, %r15d
movsd %xmm0, 0x10(%rsp)
movl %r15d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x10, %esi
movl %ebp, %edx
callq 0x2920
movapd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm1
addl $0x8, %r15d
movapd %xmm1, %xmm0
decl %ebp
jne 0x2848
jmp 0x2899
xorpd %xmm1, %xmm1
cmpl $-0x65, %ebx
ja 0x2910
movl %ebx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
leal (%r14,%rbx,8), %ebp
xorl %r14d, %r14d
movapd %xmm1, 0x10(%rsp)
leal (%rbx,%r14), %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
mulsd 0x72f(%rip), %xmm0      # 0x3008
callq 0x20c0
movl %ebp, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
addsd 0x10(%rsp), %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
subsd %xmm1, %xmm0
incl %r14d
addl $0x8, %ebp
movapd %xmm0, %xmm1
cmpl $0x64, %r14d
jne 0x28b5
jmp 0x2914
movapd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x10(%rsp)
ucomisd 0x6d4(%rip), %xmm1      # 0x3010
jne 0x2944
jnp 0x2a0a
movl %edx, %ebx
movl %esi, %ebp
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
callq 0x21b0
callq 0x2180
callq 0x20c0
movapd %xmm0, %xmm1
movsd 0x6a6(%rip), %xmm0      # 0x3010
ucomisd %xmm0, %xmm1
jb 0x2a0a
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x687(%rip), %xmm2      # 0x3010
movapd %xmm2, %xmm0
xorps %xmm3, %xmm3
cvtsi2sd %ebx, %xmm3
ucomisd %xmm1, %xmm3
jb 0x29d3
mulsd 0x18(%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd %xmm3, 0x20(%rsp)
callq 0x2130
movsd 0x651(%rip), %xmm2      # 0x3010
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm3
subsd %xmm1, %xmm3
cvttsd2si %xmm3, %ebx
mulsd 0x645(%rip), %xmm1      # 0x3020
ucomisd %xmm2, %xmm1
jb 0x2a04
mulsd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
callq 0x2130
movsd 0x612(%rip), %xmm2      # 0x3010
movsd 0x8(%rsp), %xmm1
ucomisd %xmm2, %xmm1
jae 0x298d
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x618(%rip), %rdi       # 0x3040
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2050
testl %ebp, %ebp
je 0x2a5a
movl %ebp, %r15d
leaq 0x605(%rip), %r14       # 0x3045
xorl %r12d, %r12d
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r12
cmpq %r12, %r15
jne 0x2a43
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x2, %edi
jl 0x3782
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r12d
movl $0x1, %r13d
leaq 0x128f9(%rip), %r14     # 0x16013
leaq 0x128e3(%rip), %r15     # 0x16004
movq (%rbx,%r13,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x376c
movzbl 0x1(%rdi), %eax
cmpl $0x65, %eax
je 0x3757
cmpl $0x68, %eax
je 0x374d
cmpl $0x66, %eax
jne 0x3762
addq $0x2, %rdi
movl $0x1, %esi
callq 0x9155
jmp 0x376c
movq %r14, %rdi
callq 0x22d0
jmp 0x376c
addq $0x2, %rdi
callq 0x8e8a
jmp 0x376c
movq %r15, %rdi
xorl %eax, %eax
callq 0x35fb
incq %r13
cmpq %r13, %r12
jne 0x3721
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: clear_command()
void clear_command()
{
    enumerate(idents, ident, i, 
    {
        if(i.type==ID_ALIAS) 
        { 
            DELETEA(i.name);    
            i.forcenull();
            DELETEA(i.code);
        }
    });
}

// Assembly:
cmpl $0x0, 0x1adc7(%rip)     # 0x1e660
jle 0x392c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movq 0x1adb6(%rip), %rax     # 0x1e668
movq (%rax,%rbx,8), %r14
testq %r14, %r14
je 0x3913
movq %r14, %r15
movq 0x40(%r14), %r14
cmpl $0x4, (%r15)
jne 0x38b6
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x38de
callq 0x152d7
movq $0x0, 0x8(%r15)
cmpl $0x3, 0x10(%r15)
jne 0x38f3
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x38f3
callq 0x152d7
movl $0x0, 0x10(%r15)
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x38b6
callq 0x152d7
movq $0x0, 0x18(%r15)
jmp 0x38b6
incq %rbx
movslq 0x1ad43(%rip), %rax     # 0x1e660
cmpq %rax, %rbx
jl 0x38ab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39fd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x39f3
leaq 0x126f9(%rip), %rcx     # 0x1604c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x28(%rbx), %eax
movq 0x20(%rbx), %rcx
movl %eax, (%rcx)
jmp 0x3992
movq 0x20(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3978
callq 0x152d7
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
jmp 0x3992
movss 0x28(%rbx), %xmm0
movq 0x20(%rbx), %rax
movss %xmm0, (%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x39f3
callq *%rax
jmp 0x39f3
cmpl $0x3, 0x10(%rbx)
jne 0x39b3
movq 0x20(%rbx), %rdi
cmpb $0x0, (%rdi)
je 0x39f3
callq 0x152d7
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x39db
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0x39d3
callq 0x152d7
movq $0x0, 0x18(%rbx)
movl $0x3, 0x10(%rbx)
movl $0x1, %edi
callq 0x152b1
movb $0x0, (%rax)
movq %rax, 0x20(%rbx)
andb $-0x11, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
leaq -0x28(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x1a813(%rip), %rdi     # 0x1e660
callq 0x12604
testq %rax, %rax
jne 0x3e7f
movq -0x28(%rbp), %r14
movsbl (%r14), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x3e8c
leaq 0x12d62(%rip), %rdi     # 0x16bd0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3f86
movq 0x1a811(%rip), %rax     # 0x1e690
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %al, %eax
cmpl $0x2b, %eax
je 0x3e9e
cmpl $0x2e, %eax
je 0x3eb7
cmpl $0x2d, %eax
jne 0x3ec9
movsbl 0x1(%r14), %ecx
leal -0x30(%rcx), %eax
cmpl $0xa, %eax
jb 0x3e67
movl $0x2, %eax
cmpb $0x2e, %cl
je 0x3ebc
jmp 0x3ec9
movl $0x1, %eax
movsbl (%r14,%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
jbe 0x3e67
movq %r14, %rdi
callq 0x2080
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x152b1
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2130
movl $0x4, -0x68(%rbp)
movq %r12, -0x60(%rbp)
movl $0x0, -0x58(%rbp)
xorl %eax, %eax
movq %rax, -0x50(%rbp)
movq %rax, -0x40(%rbp)
movl %ebx, -0x30(%rbp)
cmpb $0x0, 0x1ad1f(%rip)     # 0x1ec33
je 0x3f4e
leaq -0x60(%rbp), %rsi
leaq 0x1a73f(%rip), %rdi     # 0x1e660
leaq -0x68(%rbp), %rdx
callq 0x129c8
leaq 0x1a74f(%rip), %rdi     # 0x1e680
movl 0x1a755(%rip), %ecx     # 0x1e68c
movl %ecx, 0x3c(%rax)
leaq -0x70(%rbp), %rsi
movq %rax, (%rsi)
callq 0x12a76
movq (%rax), %rax
jmp 0x3e7f
cmpq $0x0, 0x1ace2(%rip)     # 0x1ec38
jne 0x3f6f
movl $0x10, %edi
callq 0x1529c
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x1acc9(%rip)     # 0x1ec38
movq 0x1acc2(%rip), %rdi     # 0x1ec38
leaq -0x68(%rbp), %rsi
callq 0x12962
xorl %eax, %eax
jmp 0x3e7f
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3fbb
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, 0x1a6e3(%rip)     # 0x1e6c8
jne 0x4020
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)
movl $0x4, %edi
movq %r10, %rsi
callq 0x35eb
callq 0xda79
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e2e
movq %rax, %rbx
movslq 0x3c(%rax), %rax
cmpq $0x18, %rax
jg 0x40c9
movq 0x1a1c4(%rip), %rcx     # 0x1e210
movl 0x10(%rcx), %edx
btl %eax, %edx
jb 0x40c9
movq 0x18(%rcx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq 0x20(%rbx), %rcx
movq %rcx, (%rax)
movl 0x10(%rbx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x28(%rbx)
movl 0x1a629(%rip), %eax     # 0x1e6a8
movl %eax, 0x10(%rbx)
movq 0x1a617(%rip), %rax     # 0x1e6a0
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x40b5
addl $0xffffff00, (%rax)     # imm = 0xFFFFFF00
movq 0x18(%rbx), %rdi
cmpl $0xff, (%rdi)
jg 0x40ad
callq 0x152d7
movq $0x0, 0x18(%rbx)
movb 0x3c(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
movq 0x1a14a(%rip), %rcx     # 0x1e210
orl %eax, 0x10(%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a538(%rip), %rdi     # 0x1e660
callq 0x1266c
testq %rax, %rax
je 0x4154
testb $0x8, 0x38(%rax)
jne 0x4142
movq %rax, %rdi
callq 0x392d
jmp 0x4154
movq 0x8(%rax), %rsi
leaq 0x12aac(%rip), %rdi     # 0x16bf9
xorl %eax, %eax
callq 0x3f86
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a0cf(%rip), %rdi     # 0x1e660
callq 0x12604
testq %rax, %rax
je 0x45a0
cmpl $0x0, (%rax)
je 0x45ab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb $0x10, 0x1a0e6(%rip)    # 0x1e698
jne 0x45c6
movl 0x38(%rax), %ecx
testb $0x2, %cl
jne 0x45c6
testb $0x10, %cl
je 0x45e2
andl $-0x13, %ecx
jmp 0x45df
movl 0x38(%rax), %ecx
testb $0x1, %cl
jne 0x4614
testb $0x10, %cl
jne 0x45e2
movq 0x20(%rax), %rdx
movl (%rdx), %edx
movl %edx, 0x28(%rax)
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
testb %r15b, %r15b
je 0x45fc
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 0x45a0
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x45a0
callq *%rax
jmp 0x45a0
movq 0x8(%rax), %rsi
leaq 0x125fc(%rip), %rdi     # 0x16c1b
xorl %eax, %eax
callq 0x3f86
jmp 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a012(%rip), %rdi     # 0x1e660
callq 0x12604
testq %rax, %rax
je 0x46ea
cmpl $0x1, (%rax)
jne 0x46ea
testb $0x10, 0x1a02c(%rip)    # 0x1e698
jne 0x4680
movl 0x38(%rax), %ecx
testb $0x2, %cl
jne 0x4680
testb $0x10, %cl
je 0x46a0
andl $-0x13, %ecx
jmp 0x469d
movl 0x38(%rax), %ecx
testb $0x1, %cl
jne 0x46ba
testb $0x10, %cl
jne 0x46a0
movq 0x20(%rax), %rdx
movss (%rdx), %xmm0
movss %xmm0, 0x28(%rax)
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
testb %r14b, %r14b
je 0x46ce
movss 0x10(%rax), %xmm0
movss -0x14(%rbp), %xmm1
minss 0x18(%rax), %xmm1
maxss %xmm1, %xmm0
jmp 0x46d3
movq 0x8(%rax), %rsi
leaq 0x12556(%rip), %rdi     # 0x16c1b
xorl %eax, %eax
callq 0x3f86
jmp 0x46ea
movss -0x14(%rbp), %xmm0
movq 0x20(%rax), %rcx
movss %xmm0, (%rcx)
testb %bl, %bl
je 0x46ea
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x46ea
callq *%rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
leaq -0x30(%rbp), %rsi
movq %rdi, (%rsi)
leaq 0x19f4c(%rip), %rdi     # 0x1e660
callq 0x12604
testq %rax, %rax
je 0x47d8
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x47d8
testb $0x10, 0x19f63(%rip)    # 0x1e698
jne 0x475f
movl 0x38(%r14), %eax
testb $0x2, %al
jne 0x475f
testb $0x10, %al
je 0x4756
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x4751
callq 0x152d7
andb $-0x11, 0x38(%r14)
movq 0x20(%r14), %rax
movq (%rax), %rdi
jmp 0x477f
movl 0x38(%r14), %eax
testb $0x1, %al
jne 0x47c6
movq 0x20(%r14), %rcx
movq (%rcx), %rdi
testb $0x10, %al
jne 0x477f
movq %rdi, 0x28(%r14)
orl $0x10, %eax
movl %eax, 0x38(%r14)
jmp 0x4789
testq %rdi, %rdi
je 0x4789
callq 0x152d7
movq %r15, %rdi
callq 0x2080
leaq 0x1(%rax), %r12
movq %r12, %rdi
callq 0x152b1
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2130
movq 0x20(%r14), %rax
movq %r13, (%rax)
testb %bl, %bl
je 0x47d8
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x47d8
callq *%rax
jmp 0x47d8
movq 0x8(%r14), %rsi
leaq 0x1244a(%rip), %rdi     # 0x16c1b
xorl %eax, %eax
callq 0x3f86
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: icmd_getalias<600>::run(char*)
int clampvar(ident *id, int val, int minval, int maxval)
{
    if(val < minval) val = minval;
    else if(val > maxval) val = maxval;
    else return val;
    debugcode(id->flags&IDF_HEX ?
            (minval <= 255 ? "valid range for %s is %d..0x%X" : "valid range for %s is 0x%X..0x%X") :
            "valid range for %s is %d..%d",
        id->name, minval, maxval);
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x4aa1
movq %rax, %rbx
movq 0x1967c(%rip), %r12     # 0x1e208
movq %rax, %rdi
callq 0x2080
leaq 0x1(%rax), %r14
movq %r14, %rdi
callq 0x152b1
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movl $0x3, 0x8(%r12)
movq %r15, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: setvarchecked(ident*, int)
void setvarchecked(ident *id, int val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
        if(val < id->minval || val > id->maxval) val = clampvar(id, val, id->minval, id->maxval);
        *id->storage.i = val;
        id->changed();                                             // call trigger function if available
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x4c9e
movl 0x19a1c(%rip), %ecx     # 0x1e698
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4cab
testb $0x1, %al
jne 0x4ce5
testb $0x10, %al
jne 0x4cb5
movq 0x20(%rbx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x28(%rbx)
orl $0x10, %eax
jmp 0x4cb2
movq 0x8(%rbx), %rsi
leaq 0x11f50(%rip), %rdi     # 0x16bf9
jmp 0x4cf0
testb $0x10, %al
je 0x4cb5
andl $-0x1b, %eax
movl %eax, 0x38(%rbx)
movl 0x10(%rbx), %edx
cmpl %esi, %edx
jg 0x4cc1
cmpl %esi, 0x18(%rbx)
jge 0x4cce
movl 0x18(%rbx), %ecx
movq %rbx, %rdi
callq 0x4c14
movl %eax, %esi
movq 0x20(%rbx), %rax
movl %esi, (%rax)
movq 0x30(%rbx), %rax
addq $0x8, %rsp
testq %rax, %rax
je 0x4cfd
popq %rbx
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0x11f2b(%rip), %rdi     # 0x16c1b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f86
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: setfvarchecked(ident*, float)
void setfvarchecked(ident *id, float val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
        if(val < id->minvalf || val > id->maxvalf) val = clampfvar(id, val, id->minvalf, id->maxvalf);
        *id->storage.f = val;
        id->changed();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x4e15
movl 0x198a9(%rip), %ecx     # 0x1e698
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4e22
testb $0x1, %al
jne 0x4e62
testb $0x10, %al
jne 0x4e2c
movq 0x20(%rbx), %rcx
movss (%rcx), %xmm1
movss %xmm1, 0x28(%rbx)
orl $0x10, %eax
jmp 0x4e29
movq 0x8(%rbx), %rsi
leaq 0x11dd9(%rip), %rdi     # 0x16bf9
jmp 0x4e6d
testb $0x10, %al
je 0x4e2c
andl $-0x1b, %eax
movl %eax, 0x38(%rbx)
movss 0x10(%rbx), %xmm1
ucomiss %xmm0, %xmm1
ja 0x4e3c
ucomiss 0x18(%rbx), %xmm0
jbe 0x4e49
movss 0x18(%rbx), %xmm2
movq %rbx, %rdi
callq 0x4d00
movq 0x20(%rbx), %rax
movss %xmm0, (%rax)
movq 0x30(%rbx), %rax
addq $0x8, %rsp
testq %rax, %rax
je 0x4e7a
popq %rbx
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0x11dae(%rip), %rdi     # 0x16c1b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f86
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: setsvarchecked(ident*, char const*)
void setsvarchecked(ident *id, const char *val)
{
    if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name);
    else
    {
        OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
        *id->storage.s = newstring(val);
        id->changed();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
testb $0x8, %al
jne 0x4ec6
movq %rsi, %r14
movl 0x197fd(%rip), %ecx     # 0x1e698
andl $0x10, %ecx
movl %eax, %edx
andl $0x2, %edx
orl %ecx, %edx
je 0x4ed3
testb $0x1, %al
jne 0x4f39
movq 0x20(%rbx), %rcx
movq (%rcx), %rdi
testb $0x10, %al
jne 0x4ef0
movq %rdi, 0x28(%rbx)
orl $0x10, %eax
movl %eax, 0x38(%rbx)
jmp 0x4efa
movq 0x8(%rbx), %rsi
leaq 0x11d28(%rip), %rdi     # 0x16bf9
jmp 0x4f44
testb $0x10, %al
je 0x4ee9
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4ee5
callq 0x152d7
andb $-0x11, 0x38(%rbx)
movq 0x20(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4efa
callq 0x152d7
movq %r14, %rdi
callq 0x2080
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x152b1
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2130
movq 0x20(%rbx), %rax
movq %r12, (%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x4f53
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x8(%rbx), %rsi
leaq 0x11cd7(%rip), %rdi     # 0x16c1b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3f86
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: unescapestring(char*, char const*, char const*)
int unescapestring(char *dst, const char *src, const char *end)
{
    char *start = dst;
    while(src < end)
    {
        int c = *src++;
        if(c == '^')
        {
            if(src >= end) break;
            int e = *src++;
            switch(e)
            {
                case 'n': *dst++ = '\n'; break;
                case 't': *dst++ = '\t'; break;
                case 'f': *dst++ = '\f'; break;
                default: *dst++ = e; break;
            }
        }
        else *dst++ = c;
    }
    return dst - start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
cmpq %rdx, %rsi
jae 0x4feb
leaq 0x1(%rsi), %r8
movb (%rsi), %cl
cmpb $0x5e, %cl
jne 0x4fcc
cmpq %rdx, %r8
jae 0x4fd8
movzbl 0x1(%rsi), %ecx
addq $0x2, %rsi
cmpl $0x66, %ecx
je 0x4fe7
cmpl $0x6e, %ecx
je 0x4fe3
cmpl $0x74, %ecx
jne 0x4fcf
movb $0x9, %cl
jmp 0x4fcf
movq %r8, %rsi
movb %cl, (%rax)
incq %rax
movb $0x1, %cl
jmp 0x4fdd
xorl %ecx, %ecx
movq %r8, %rsi
testb %cl, %cl
jne 0x4f9c
jmp 0x4feb
movb $0xa, %cl
jmp 0x4fcf
movb $0xc, %cl
jmp 0x4fcf
subl %edi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: compilecode(char const*)
uint *compilecode(const char *p)
{
    vector<uint> buf;
    buf.reserve(64);
    compilemain(buf, p);
    uint *code = new uint[buf.length()];
    memcpy(code, buf.getbuf(), buf.length()*sizeof(uint));
    code[0] += 0x100;
    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movl -0x24(%rbp), %esi
addl $0x40, %esi
cmpl -0x28(%rbp), %esi
jle 0x501a
leaq -0x30(%rbp), %rdi
callq 0x12c74
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x50ab
movslq -0x24(%rbp), %rax
leaq (,%rax,4), %r14
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x152b1
movq %rax, %rbx
movq -0x30(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2130
addl $0x100, (%rbx)          # imm = 0x100
movl $0x0, -0x24(%rbp)
testq %r15, %r15
je 0x5079
movq %r15, %rdi
callq 0x152d7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x508b
jmp 0x508b
movq %rax, %rbx
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x50a3
callq 0x152d7
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Fohlen[P]cubescript-standalone/command.cpp
// Function: keepcode(unsigned int*)
void keepcode(uint *code)
{
    if(!code) return;
    switch(*code&CODE_OP_MASK)
    {
        case CODE_START:
            *code += 0x100;
            return;
    }
    switch(code[-1]&CODE_OP_MASK)
    {
        case CODE_START:
            code[-1] += 0x100;
            break;
        case CODE_OFFSET:
            code -= int(code[-1]>>8);
            *code += 0x100;
            break;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x514e
movl (%rdi), %eax
testb $0x3f, %al
je 0x5142
movl -0x4(%rdi), %eax
movl %eax, %ecx
andl $0x3f, %ecx
je 0x513e
cmpl $0x1, %ecx
jne 0x514e
shrl $0x6, %eax
andl $-0x4, %eax
subq %rax, %rdi
movl (%rdi), %eax
jmp 0x5142
addq $-0x4, %rdi
pushq %rbp
movq %rsp, %rbp
addl $0x100, %eax            # imm = 0x100
movl %eax, (%rdi)
popq %rbp
retq