LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sehe[P]spirit-v2-json/json.cpp
// Function: JSON::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Value parse(std::string const& input) {
        auto f(begin(input)), saved = f, l(end(input));

        Value parsed;
        if (!tryParseJson(f, l, parsed))
        {
            std::cerr << "whoops at position #" << std::distance(saved, f) << "\n";
        }

        return parsed;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
movq %rsp, %rdi
movq %r14, (%rdi)
movq 0x8(%rsi), %rsi
addq %r14, %rsi
movl $0x0, (%rbx)
movq %rbx, %rdx
callq 0x872b
testb %al, %al
jne 0x5723
movq 0x40905(%rip), %rdi     # 0x45ff0
leaq 0x2c0be(%rip), %rsi     # 0x317b0
movl $0x14, %edx
callq 0x4290
movq (%rsp), %rsi
subq %r14, %rsi
movq 0x408e6(%rip), %rdi     # 0x45ff0
callq 0x4220
leaq 0x2ceca(%rip), %rsi     # 0x325e0
movl $0x1, %edx
movq %rax, %rdi
callq 0x4290
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4e6a
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O1/sehe[P]spirit-v2-json/json.cpp
// Function: JSON::readFrom[abi:cxx11](std::istream&)
Value readFrom(std::istream& is)
    {
        is.unsetf(std::ios::skipws);
        boost::spirit::istream_iterator it(is), pte;

        Value parsed;
        if (!tryParseJson(it, pte, parsed))
        {
            std::cerr << "whoops"; // TODO
        }

        return parsed;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x18(%rsi,%rax) # imm = 0xFFFFEFFF
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x1b680
xorl %eax, %eax
movq %rax, 0x10(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movl $0x0, (%rbx)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x89aa
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x1da34
testb %bpl, %bpl
jne 0x57cc
movq 0x40835(%rip), %rdi     # 0x45ff0
leaq 0x2c003(%rip), %rsi     # 0x317c5
movl $0x6, %edx
callq 0x4290
movq %rsp, %rdi
callq 0x1da34
leaq 0x38(%rsp), %rdi
callq 0x1da34
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x57fc
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1da34
movq %rbx, %rdi
callq 0x4e6a
movq %rsp, %rdi
callq 0x1da34
leaq 0x38(%rsp), %rdi
callq 0x1da34
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O1/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: preprocessing_sorting(std::unordered_map<unsigned long, std::pair<unsigned long, bool>, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, std::pair<unsigned long, bool>>>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&)
std::vector<cdf_coord> preprocessing_sorting(std::unordered_map<uint64_t, hash_coord>& count_, std::vector<uint64_t>& xs, std::vector<uint64_t>& ys)
// Solve the task with sorting
{
    std::vector<cdf_coord> final_(count_.size());
    unsigned index = 0;
    for (auto elem: count_)
        final_[index++] = std::make_pair(elem.first, 0);
    return final_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0x4c72
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x366c
movq (%rbx), %rcx
xorl %edx, %edx
movq 0x8(%rax), %rsi
movl %edx, %edi
incl %edx
shlq $0x4, %rdi
movq %rsi, (%rcx,%rdi)
movq $0x0, 0x8(%rcx,%rdi)
movq (%rax), %rax
testq %rax, %rax
jne 0x364b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: solveWithSorting(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
void solveWithSorting(std::vector<cdf_coord>& cdf)
{
    auto start = high_resolution_clock::now();
    std::sort(cdf.begin(), cdf.end(), [](auto left, auto right) {
       return left.first < right.first; 
    });
    auto stop = high_resolution_clock::now();
    std::cout << "Solving with Sorting took: " << duration_cast<milliseconds>(stop - start).count() << " ms" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3040
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x3738
movq %r14, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x48ee
cmpq $0x101, %r12            # imm = 0x101
jl 0x372d
leaq 0x100(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4bce
cmpq %r14, %r12
je 0x3738
addq $0x108, %r15            # imm = 0x108
movups (%r12), %xmm0
movq -0x10(%r12), %rcx
movq (%r12), %rax
movq %r12, %rdx
cmpq %rcx, %rax
jae 0x371b
movq %r15, %rdx
movq %rcx, -0x8(%rdx)
movq -0x28(%rdx), %rcx
movq -0x10(%rdx), %rsi
movq %rsi, (%rdx)
addq $-0x10, %rdx
cmpq %rcx, %rax
jb 0x36ff
addq $-0x8, %rdx
movups %xmm0, (%rdx)
addq $0x10, %r12
addq $0x10, %r15
cmpq %r14, %r12
jne 0x36e6
jmp 0x3738
movq %r15, %rdi
movq %r14, %rsi
callq 0x4bce
callq 0x3040
movq %rax, %r14
movq 0x6871(%rip), %r15      # 0x9fb8
leaq 0x39ef(%rip), %rsi      # 0x713d
movl $0x1b, %edx
movq %r15, %rdi
callq 0x31e0
subq %rbx, %r14
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x3190
movq %rax, %rbx
leaq 0x39cb(%rip), %rsi      # 0x7159
movl $0x3, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O1/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: collectChain(unsigned long)
std::vector<uint64_t> collectChain(uint64_t index) 
// Collect the chain into a vector
{
    std::vector<uint64_t> ret;
    for (uint32_t ptr = adj[index]; ptr; ptr = list[ptr].next)
        ret.push_back(list[ptr].sum);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x69a8(%rip), %rax      # 0xa1b8
movl (%rax,%rsi,8), %r14d
testq %r14, %r14
je 0x3857
shlq $0x4, %r14
movq 0x69ac(%rip), %rdx      # 0xa1d0
addq %r14, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3841
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3849
movq %rbx, %rdi
callq 0x591e
movq 0x6980(%rip), %rax      # 0xa1d0
movl 0x8(%rax,%r14), %r14d
jmp 0x3814
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3879
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: solveWithCdf(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
void solveWithCdf(std::vector<cdf_coord>& cdf)
// Insertion sort for partially sorted cdf
{
    
    auto start = high_resolution_clock::now();
    int size = cdf.size();
    for (unsigned index = 1, limit = cdf.size(); index < limit; ++index) {
        unsigned ptr = index;
        cdf_coord curr = cdf[index];
        while ((ptr > 0) && (cdf[ptr - 1].first > curr.first)) {
            cdf[ptr] = cdf[ptr - 1];
            --ptr;
        }
        cdf[ptr] = curr;
    }
    
    auto stop = high_resolution_clock::now();
    std::cout << "Solving with CDF approximation took: " << duration_cast<milliseconds>(stop - start).count() << " ms" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x3040
movq %rax, %rbx
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
movabsq $0xfffffffe0, %rdx      # imm = 0xFFFFFFFE0
testq %rdx, %rcx
je 0x3f50
shrq $0x4, %rcx
movl %ecx, %ecx
leaq 0x18(%rax), %rdx
movl $0x1, %esi
movq %rsi, %rdi
shlq $0x4, %rdi
movups (%rax,%rdi), %xmm0
movq (%rax,%rdi), %rdi
movq %rdx, %r8
movq %rsi, %r9
movq %r9, %r10
decq %r9
movl %r9d, %r11d
shlq $0x4, %r11
movq (%rax,%r11), %r14
cmpq %rdi, %r14
jbe 0x3f39
addq %rax, %r11
movq %r14, -0x8(%r8)
movq 0x8(%r11), %r10
movq %r10, (%r8)
addq $-0x10, %r8
testl %r9d, %r9d
jne 0x3f09
xorl %r10d, %r10d
movl %r10d, %edi
shlq $0x4, %rdi
movups %xmm0, (%rax,%rdi)
incq %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jne 0x3ef4
callq 0x3040
movq %rax, %r14
movq 0x6059(%rip), %r15      # 0x9fb8
leaq 0x329c(%rip), %rsi      # 0x7202
movl $0x25, %edx
movq %r15, %rdi
callq 0x31e0
subq %rbx, %r14
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq %r15, %rdi
callq 0x3190
movq %rax, %rbx
leaq 0x31b3(%rip), %rsi      # 0x7159
movl $0x3, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O1/stoianmihail[P]XY-sorting/algorithm.cpp
// Function: generator(unsigned long)
static std::vector<uint64_t> generator(uint64_t maxValue)
// generates a sorted array of MAX_N unsigned ints without duplicates
{
    std::vector<uint64_t> numbers;
    std::generate_n(std::back_inserter(numbers), 10000, randomNumberBetween(1, maxValue));
    std::sort(std::begin(numbers), std::end(numbers));
    return numbers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2740, %rsp           # imm = 0x2740
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x13a8(%rsp), %rdi
callq 0x5192
leaq 0x13a8(%rsp), %rdi
callq 0x3210
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
movl $0x3, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x2, %ecx
movq %rcx, 0x10(%rsp,%rax,8)
incq %rax
cmpq $0x272, %rax            # imm = 0x272
jne 0x44e3
movq $0x270, 0x13a0(%rsp) # imm = 0x270
leaq 0x13a8(%rsp), %rdi
callq 0x3180
leaq 0x13a8(%rsp), %r14
leaq 0x10(%rsp), %rsi
movl $0x1398, %edx           # imm = 0x1398
movq %r14, %rdi
callq 0x3150
movl $0x2711, %ebp           # imm = 0x2711
leaq 0x13b8(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4dfa
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4576
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4581
movq %rbx, %rdi
movq %r12, %rdx
callq 0x5056
decl %ebp
cmpl $0x1, %ebp
ja 0x454c
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x45c1
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x529c
movq %r14, %rdi
movq %r15, %rsi
callq 0x5385
movq %rbx, %rax
addq $0x2740, %rsp           # imm = 0x2740
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45e8
movq %rax, %r14
leaq 0x13a8(%rsp), %rdi
callq 0x3180
jmp 0x45f5
movq %rax, %rdi
callq 0x4def
jmp 0x45f2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4609
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x31d0
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/bench/simpat/simpat_srv.c
// Function: main
int main(int argc, char *argv[])
{
  /* scdc.log_init("log_FILE", sys.stdout, sys.stderr)*/

  scdc_init(SCDC_INIT_DEFAULT);

  simpat_init();

  scdc_nodeport_t np = SCDC_NODEPORT_NULL;

  if (argc <= 1)
  {
    SIMPAT_TRACE("setup: none");

  } else if (strcmp(argv[1], "uds") == 0)
  {
    SIMPAT_TRACE("setup: UDS");

    const char *socketname = (argc <= 2)?"simpat":argv[2];

    np = scdc_nodeport_open("uds:socketname:max_connections", socketname, 2);

  } else if (strcmp(argv[1], "tcp") == 0)
  {
    SIMPAT_TRACE("setup: TCP");

    np = scdc_nodeport_open("tcp:max_connections", 2);

  } else if (strcmp(argv[1], "mpi") == 0)
  {
    SIMPAT_TRACE("setup: MPI");

    np = scdc_nodeport_open("mpi");

  } else SIMPAT_TRACE("unknown mode: %s", argv[1]);

  SIMPAT_TRACE("start");
  scdc_nodeport_start(np, SCDC_NODEPORT_START_ASYNC_UNTIL_CANCEL);

  printf("Press <ENTER> to quit!\n");
  getchar();

  SIMPAT_TRACE("stop");
  scdc_nodeport_stop(np);

  SIMPAT_TRACE("release");
  scdc_nodeport_close(np);

  simpat_release();

  scdc_release();

  /*scdc.log_release()*/

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x50101(%rip), %rdi     # 0x5c55d
xorl %eax, %eax
callq 0xc649
xorl %eax, %eax
callq 0xc604
cmpl $0x1, %ebp
jg 0xc48e
leaq 0x4eb8e(%rip), %rdi     # 0x5b004
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
jmp 0xc579
movq 0x8(%rbx), %r14
leaq 0x505e7(%rip), %rsi     # 0x5ca80
movq %r14, %rdi
callq 0xb750
testl %eax, %eax
je 0xc4e4
leaq 0x505cb(%rip), %rsi     # 0x5ca77
movq %r14, %rdi
callq 0xb750
testl %eax, %eax
je 0xc50a
leaq 0x4ebda(%rip), %rsi     # 0x5b099
movq %r14, %rdi
callq 0xb750
testl %eax, %eax
je 0xc550
leaq 0x4ebe5(%rip), %rdi     # 0x5b0bb
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
jmp 0xc47f
leaq 0x4eb38(%rip), %rdi     # 0x5b023
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
cmpl $0x2, %ebp
jne 0xc537
leaq 0x4eb39(%rip), %rsi     # 0x5b041
jmp 0xc53b
leaq 0x4eb56(%rip), %rdi     # 0x5b067
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
leaq 0x4eb5c(%rip), %rdi     # 0x5b085
movl $0x2, %esi
xorl %eax, %eax
callq 0xcc10
jmp 0xc576
movq 0x10(%rbx), %rsi
leaq 0x4eb06(%rip), %rdi     # 0x5b048
movl $0x2, %edx
xorl %eax, %eax
callq 0xcc10
jmp 0xc576
leaq 0x4eb46(%rip), %rdi     # 0x5b09d
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
leaq 0x4eb2a(%rip), %rdi     # 0x5b099
xorl %eax, %eax
callq 0xcc10
movq %rax, %rbx
leaq 0x4eb5f(%rip), %rdi     # 0x5b0df
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
movl $0x4, %esi
movq %rbx, %rdi
callq 0xcd24
leaq 0x4eb86(%rip), %rdi     # 0x5b12b
callq 0xb840
callq 0xb730
leaq 0x4eb42(%rip), %rdi     # 0x5b0f8
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
movq %rbx, %rdi
callq 0xcd55
leaq 0x4eb3a(%rip), %rdi     # 0x5b110
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb740
movq %rbx, %rdi
callq 0xcd02
xorl %eax, %eax
callq 0xc623
callq 0xc74e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/Timer.cpp
// Function: Timer::getElapsedTimeInMicroSec()
double Timer::getElapsedTimeInMicroSec()
{
#ifdef WIN32
    if(!stopped)
        QueryPerformanceCounter(&endCount);

    startTimeInMicroSec = startCount.QuadPart * (1000000.0 / frequency.QuadPart);
    endTimeInMicroSec = endCount.QuadPart * (1000000.0 / frequency.QuadPart);
#else
    if(!stopped)
        gettimeofday(&endCount, NULL);

    startTimeInMicroSec = (startCount.tv_sec * 1000000.0) + startCount.tv_usec;
    endTimeInMicroSec = (endCount.tv_sec * 1000000.0) + endCount.tv_usec;
#endif

    return endTimeInMicroSec - startTimeInMicroSec;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x130d
leaq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x1120
cvtsi2sdq 0x18(%rbx), %xmm1
cvtsi2sdq 0x20(%rbx), %xmm0
movsd 0x3ce7(%rip), %xmm2     # 0x5008
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
xorps %xmm0, %xmm0
cvtsi2sdq 0x28(%rbx), %xmm0
cvtsi2sdq 0x30(%rbx), %xmm3
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, 0x8(%rbx)
subsd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: createRandomMatrix()
m4 createRandomMatrix(){
    return m4(
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100),
                     rnd(100),rnd(100),rnd(100),rnd(100)
                     );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x1040
movl %eax, 0x4(%rsp)
callq 0x1040
movl %eax, (%rsp)
callq 0x1040
movl %eax, 0x24(%rsp)
callq 0x1040
movl %eax, 0x20(%rsp)
callq 0x1040
movl %eax, 0x1c(%rsp)
callq 0x1040
movl %eax, 0x18(%rsp)
callq 0x1040
movl %eax, 0x14(%rsp)
callq 0x1040
movl %eax, 0x10(%rsp)
callq 0x1040
movl %eax, 0xc(%rsp)
callq 0x1040
movl %eax, 0x8(%rsp)
callq 0x1040
movl %eax, %ebp
callq 0x1040
movl %eax, %r14d
callq 0x1040
movl %eax, %r15d
callq 0x1040
movl %eax, %r12d
callq 0x1040
movl %eax, %r13d
callq 0x1040
cvtsi2ss %eax, %xmm1
cvtsi2ss %r13d, %xmm2
cvtsi2ss %r12d, %xmm3
cvtsi2ss %r15d, %xmm4
cvtsi2ss %r14d, %xmm5
cvtsi2ss %ebp, %xmm6
cvtsi2ssl 0x8(%rsp), %xmm0
cvtsi2ssl 0xc(%rsp), %xmm7
cvtsi2ssl 0x10(%rsp), %xmm8
cvtsi2ssl 0x14(%rsp), %xmm9
cvtsi2ssl 0x18(%rsp), %xmm10
cvtsi2ssl 0x1c(%rsp), %xmm11
cvtsi2ssl 0x20(%rsp), %xmm12
cvtsi2ssl 0x24(%rsp), %xmm13
cvtsi2ssl (%rsp), %xmm14
xorps %xmm15, %xmm15
movups %xmm15, (%rbx)
movups %xmm15, 0x10(%rbx)
movups %xmm15, 0x20(%rbx)
movups %xmm15, 0x30(%rbx)
movss 0x2ea9(%rip), %xmm15    # 0x5054
mulss %xmm15, %xmm1
mulss %xmm15, %xmm2
mulss %xmm15, %xmm3
mulss %xmm15, %xmm4
mulss %xmm15, %xmm5
mulss %xmm15, %xmm6
mulss %xmm15, %xmm0
movss %xmm0, (%rsp)
mulss %xmm15, %xmm7
mulss %xmm15, %xmm8
mulss %xmm15, %xmm9
mulss %xmm15, %xmm10
mulss %xmm15, %xmm11
mulss %xmm15, %xmm12
mulss %xmm15, %xmm13
xorps %xmm0, %xmm0
cvtsi2ssl 0x4(%rsp), %xmm0
mulss %xmm15, %xmm14
mulss %xmm15, %xmm0
movss 0x2e3e(%rip), %xmm15    # 0x5050
mulss %xmm15, %xmm1
movss %xmm1, 0x4(%rsp)
mulss %xmm15, %xmm2
mulss %xmm15, %xmm3
mulss %xmm15, %xmm4
mulss %xmm15, %xmm5
mulss %xmm15, %xmm6
movss (%rsp), %xmm1
mulss %xmm15, %xmm1
mulss %xmm15, %xmm7
mulss %xmm15, %xmm8
mulss %xmm15, %xmm9
mulss %xmm15, %xmm10
mulss %xmm15, %xmm11
mulss %xmm15, %xmm12
mulss %xmm15, %xmm13
mulss %xmm15, %xmm14
mulss %xmm15, %xmm0
movss %xmm0, (%rbx)
movss %xmm14, 0x4(%rbx)
movss %xmm13, 0x8(%rbx)
movss %xmm12, 0xc(%rbx)
movss %xmm11, 0x10(%rbx)
movss %xmm10, 0x14(%rbx)
movss %xmm9, 0x18(%rbx)
movss %xmm8, 0x1c(%rbx)
movss %xmm7, 0x20(%rbx)
movss %xmm1, 0x24(%rbx)
movss %xmm6, 0x28(%rbx)
movss %xmm5, 0x2c(%rbx)
movss %xmm4, 0x30(%rbx)
movss %xmm3, 0x34(%rbx)
movss %xmm2, 0x38(%rbx)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x3c(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testTranslation(long)
double testTranslation(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);

    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::translate(m1,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x209d
leaq 0x468f(%rip), %rdi      # 0x70e0
callq 0x12d4
testq %rbx, %rbx
jle 0x2b1f
movss 0x10(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
movss 0x18(%rsp), %xmm5
movss 0x1c(%rsp), %xmm4
addss %xmm2, %xmm2
addss %xmm3, %xmm3
addss %xmm5, %xmm5
addss (%rsp), %xmm2
addss 0x4(%rsp), %xmm3
addss 0x8(%rsp), %xmm5
addss %xmm4, %xmm4
addss 0xc(%rsp), %xmm4
movss 0x25b2(%rip), %xmm0     # 0x5058
movss 0x20(%rsp), %xmm1
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
movss 0x24(%rsp), %xmm2
mulss %xmm0, %xmm2
addss %xmm3, %xmm2
movss 0x28(%rsp), %xmm3
mulss %xmm0, %xmm3
addss %xmm5, %xmm3
mulss 0x2c(%rsp), %xmm0
addss %xmm4, %xmm0
movss 0x30(%rsp), %xmm7
movss 0x34(%rsp), %xmm6
movss 0x38(%rsp), %xmm5
movss 0x3c(%rsp), %xmm4
addss %xmm0, %xmm4
addss %xmm3, %xmm5
addss %xmm2, %xmm6
addss %xmm1, %xmm7
decq %rbx
jne 0x2af2
movss %xmm7, 0x30(%rsp)
movss %xmm6, 0x34(%rsp)
movss %xmm5, 0x38(%rsp)
movss %xmm4, 0x3c(%rsp)
leaq 0x45ba(%rip), %rbx      # 0x70e0
movq %rbx, %rdi
callq 0x12e6
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1350
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testScale(long)
double testScale(long count){
    m4 m1 = createRandomMatrix();
    v3 v1 = v3(1, 2, 3);
    
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::scale(m1,v1);
    }
    t.stop();
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x209d
leaq 0x458e(%rip), %rdi      # 0x70e0
callq 0x12d4
testq %rbx, %rbx
jle 0x2bf2
movss 0x10(%rsp), %xmm7
movss 0x14(%rsp), %xmm6
movss 0x18(%rsp), %xmm5
movss 0x1c(%rsp), %xmm4
movss 0x20(%rsp), %xmm3
movss 0x24(%rsp), %xmm2
movss 0x28(%rsp), %xmm1
movss 0x2c(%rsp), %xmm0
movss 0x24bf(%rip), %xmm8     # 0x5058
addss %xmm7, %xmm7
addss %xmm6, %xmm6
addss %xmm5, %xmm5
addss %xmm4, %xmm4
mulss %xmm8, %xmm3
mulss %xmm8, %xmm2
mulss %xmm8, %xmm1
mulss %xmm8, %xmm0
decq %rbx
jne 0x2b99
movss %xmm7, 0x10(%rsp)
movss %xmm6, 0x14(%rsp)
movss %xmm5, 0x18(%rsp)
movss %xmm4, 0x1c(%rsp)
movss %xmm3, 0x20(%rsp)
movss %xmm2, 0x24(%rsp)
movss %xmm1, 0x28(%rsp)
movss %xmm0, 0x2c(%rsp)
leaq 0x44e7(%rip), %rbx      # 0x70e0
movq %rbx, %rdi
callq 0x12e6
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x1350
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testTranspose(long)
double testTranspose(long count){
    m4 m1 = createRandomMatrix();

    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::transpose(m1);
    }
    t.stop();
    if (rand()==0){ // force compiler to not optimize loop away
        std::cout<<m1[rand()%3][rand()%3]<<std::endl;
    }

    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209d
leaq 0x4166(%rip), %rdi      # 0x70e0
callq 0x12d4
testq %rbx, %rbx
jle 0x308c
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x30(%rsp), %xmm3
movss 0x40(%rsp), %xmm5
movss 0x14(%rsp), %xmm1
movss 0x18(%rsp), %xmm10
movss 0x34(%rsp), %xmm2
movss 0x44(%rsp), %xmm4
movss 0x28(%rsp), %xmm11
movss 0x48(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x1c(%rsp), %xmm8
movss 0x2c(%rsp), %xmm7
movss 0x3c(%rsp), %xmm6
movss 0x8(%rsp), %xmm0
movaps %xmm3, %xmm13
movaps %xmm5, %xmm9
movss %xmm1, 0x8(%rsp)
movaps %xmm2, %xmm15
movaps %xmm4, %xmm12
movaps %xmm10, %xmm3
movaps %xmm11, %xmm2
movss 0xc(%rsp), %xmm14
movaps %xmm8, %xmm5
movaps %xmm7, %xmm4
movss %xmm6, 0xc(%rsp)
movaps %xmm14, %xmm6
movaps %xmm12, %xmm7
movaps %xmm9, %xmm8
movaps %xmm15, %xmm11
movaps %xmm13, %xmm10
movaps %xmm0, %xmm1
decq %rbx
jne 0x2fdf
movss 0x8(%rsp), %xmm1
movss %xmm1, 0x20(%rsp)
movss %xmm3, 0x30(%rsp)
movss %xmm5, 0x40(%rsp)
movss %xmm0, 0x14(%rsp)
movss %xmm2, 0x34(%rsp)
movss %xmm4, 0x44(%rsp)
movss %xmm13, 0x18(%rsp)
movss %xmm15, 0x28(%rsp)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x48(%rsp)
movss %xmm9, 0x1c(%rsp)
movss %xmm12, 0x2c(%rsp)
movss %xmm14, 0x3c(%rsp)
leaq 0x404d(%rip), %rdi      # 0x70e0
callq 0x12e6
callq 0x1040
testl %eax, %eax
jne 0x3138
callq 0x1040
movl %eax, %ebx
callq 0x1040
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
js 0x3149
movslq %ebx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rsp, %rcx
addq $0x10, %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq 0x3ecf(%rip), %rdi      # 0x6fd8
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x3fa1(%rip), %rdi      # 0x70e0
addq $0x50, %rsp
popq %rbx
jmp 0x1350
leaq 0x2047(%rip), %rdi      # 0x5197
leaq 0x2078(%rip), %rsi      # 0x51cf
leaq 0x208c(%rip), %rcx      # 0x51ea
movl $0x2c, %edx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testInverse(long)
double testInverse(long count){
    m4 m1 = createRandomMatrix();
    
    t.start();
    for (int i = 0; i < count; i++) {
        m1 = glm::inverse(m1);
    }
    t.stop();
    if (rand()==0){ // force compiler to not optimize loop away
        std::cout<<m1[rand()%3][rand()%3]<<std::endl;
    }

    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x209d
leaq 0x3f5a(%rip), %rdi      # 0x70e0
callq 0x12d4
testq %rbx, %rbx
jle 0x31e7
leaq 0x40(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a76
movss 0x40(%rsp), %xmm0
movss %xmm0, (%rsp)
movups 0x44(%rsp), %xmm0
movups %xmm0, 0x4(%rsp)
movups 0x54(%rsp), %xmm0
movups %xmm0, 0x14(%rsp)
movups 0x64(%rsp), %xmm0
movups %xmm0, 0x24(%rsp)
movq 0x74(%rsp), %rax
movq %rax, 0x34(%rsp)
movss 0x7c(%rsp), %xmm0
movss %xmm0, 0x3c(%rsp)
decq %rbx
jne 0x3198
leaq 0x3ef2(%rip), %rdi      # 0x70e0
callq 0x12e6
callq 0x1040
testl %eax, %eax
jne 0x328f
callq 0x1040
movl %eax, %ebx
callq 0x1040
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
js 0x32a8
movslq %ebx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rsp, %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq 0x3d78(%rip), %rdi      # 0x6fd8
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x3e4a(%rip), %rdi      # 0x70e0
callq 0x1350
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1ee8(%rip), %rdi      # 0x5197
leaq 0x1f19(%rip), %rsi      # 0x51cf
leaq 0x1f2d(%rip), %rcx      # 0x51ea
movl $0x2c, %edx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: testInverseMat3(long)
double testInverseMat3(long count){
    m4 m1 = createRandomMatrix();
    m3 m2;
    m2 = m3(m1); // note that this benchmark is actually doing less than 
    t.start();
    for (int i = 0; i < count; i++) {
        m2 = glm::inverse(m2);
    }
    t.stop();
    if (rand()==0){ // force compiler to not optimize loop away
        std::cout<<m2[rand()%3][rand()%3]<<std::endl;
    }
    return t.getElapsedTimeInMilliSec();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x209d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movss (%r14), %xmm0
movq 0x4(%r14), %rax
movss 0x10(%r14), %xmm1
movq 0x14(%r14), %rcx
movss 0x20(%r14), %xmm2
movq 0x24(%r14), %rdx
movss %xmm0, (%rsp)
movq %rax, 0x4(%rsp)
movss %xmm1, 0xc(%rsp)
movq %rcx, 0x10(%rsp)
movss %xmm2, 0x18(%rsp)
movq %rdx, 0x1c(%rsp)
leaq 0x3da5(%rip), %rdi      # 0x70e0
callq 0x12d4
testq %rbx, %rbx
jle 0x337c
leaq 0x2c(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4192
movss 0x2c(%rsp), %xmm0
movss %xmm0, (%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, 0x4(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, 0x14(%rsp)
decq %rbx
jne 0x334d
leaq 0x3d5d(%rip), %rdi      # 0x70e0
callq 0x12e6
callq 0x1040
testl %eax, %eax
jne 0x3429
callq 0x1040
movl %eax, %ebx
callq 0x1040
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
js 0x3442
movslq %ebx, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rsp,%rcx,4), %rcx
movl %eax, %eax
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq 0x3bde(%rip), %rdi      # 0x6fd8
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
leaq 0x3cb0(%rip), %rdi      # 0x70e0
callq 0x1350
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1d4e(%rip), %rdi      # 0x5197
leaq 0x1d64(%rip), %rsi      # 0x51b4
leaq 0x1dee(%rip), %rcx      # 0x5245
movl $0x2c, %edx
callq 0x1060
// File: /workspace/github_cpp_makefile_star2_O1/mortennobel[P]glMatrix-vs-GLM-Benchmark/main.cpp
// Function: runTestCase(double (*)(long), char*)
void runTestCase(double(*f)(long), char* name){
    double totalTime = 0;
    double minTime = 0;
    double maxTime = 0;
    
    for(int i = 0; i < runCount; ++i) {
        double time = f(internalRunCount);
        if(i == 0) {
            minTime = time;
            maxTime = time;
        } else {
            if(minTime > time) { minTime = time; }
            if(maxTime < time) { maxTime = time; }
        }
        totalTime += time;
    }
    
    double avg = totalTime / runCount;
    
    std::cout<<name<<" - Avg: "<<avg<<"ms, Min: "<<minTime<<"ms, Max: "<<maxTime<<"ms"<<std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x39c7(%rip), %ebp      # 0x70c0
testl %ebp, %ebp
jle 0x3771
movq %rdi, %r14
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movq 0x39a5(%rip), %rdi      # 0x70c8
callq *%r14
testl %r15d, %r15d
je 0x3745
movapd %xmm0, %xmm2
minsd 0x10(%rsp), %xmm2
ucomisd 0x8(%rsp), %xmm0
jbe 0x374f
movsd %xmm0, 0x8(%rsp)
jmp 0x374f
movsd %xmm0, 0x8(%rsp)
movapd %xmm0, %xmm2
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incl %r15d
movl 0x395a(%rip), %ebp      # 0x70c0
movapd %xmm2, %xmm1
cmpl %ebp, %r15d
jl 0x3716
jmp 0x3784
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm2, %xmm2
movsd %xmm0, (%rsp)
movsd %xmm2, 0x10(%rsp)
testq %rbx, %rbx
je 0x37ab
movq %rbx, %rdi
callq 0x1050
movq 0x383a(%rip), %rdi      # 0x6fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x10e0
jmp 0x37c9
movq 0x3826(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x1130
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq 0x37f3(%rip), %rbx      # 0x6fd8
leaq 0x18c4(%rip), %rsi      # 0x50b0
movl $0x8, %edx
movq %rbx, %rdi
callq 0x10e0
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x1110
movq %rax, %rbx
leaq 0x18a9(%rip), %rsi      # 0x50b9
movl $0x9, %edx
movq %rax, %rdi
callq 0x10e0
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x1110
movq %rax, %rbx
leaq 0x188e(%rip), %rsi      # 0x50c3
movl $0x9, %edx
movq %rax, %rdi
callq 0x10e0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1110
movq %rax, %rbx
leaq 0x1873(%rip), %rsi      # 0x50cd
movl $0x2, %edx
movq %rax, %rdi
callq 0x10e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/main.cpp
// Function: main
int main() {
	// Set a random generator seed
	// Referenced from Program 3-32 of C++ Early Objects, 9th Edition
	unsigned seed;

	seed = static_cast<unsigned>(time(nullptr));
	srand(seed);

	// Construct and begin game
	Game game;
	game.startGame();

	// Give player the option to play again
	int repeatChoice = 0;

	do {
		game.repeatMenu();
		repeatChoice = game.intValidation(1,2);

		switch(repeatChoice) {
			case 1: {
				Game repeatGame;
				repeatGame.startGame();
				break;
			}
			case 2:
				break;
			default:
				break;
		}
	} while (repeatChoice != 2);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
xorl %edi, %edi
callq 0x2160
movl %eax, %edi
callq 0x2170
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x35e0
movq %rbx, %rdi
callq 0x446c
movq %rsp, %rbx
leaq 0x90(%rsp), %r14
movq %rbx, %rdi
callq 0x79a2
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x754c
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x262c
movq %r14, %rdi
callq 0x35e0
movq %r14, %rdi
callq 0x446c
movq %r14, %rdi
callq 0x7ad2
cmpl $0x2, %ebp
jne 0x25f3
movq %rsp, %rdi
callq 0x7ad2
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x265d
jmp 0x265d
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x7ad2
jmp 0x2660
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7ad2
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/basicSatchel.cpp
// Function: BasicSatchel::printWeapons() const
void BasicSatchel::printWeapons() const {
	if (candlestick) {
		cout << "- candlestick" << endl;
	}
	if (knife) {
		cout << "- knife" << endl;
	}
	if (revolver) {
		cout << "- revolver" << endl;
	}
	if (rope) {
		cout << "- rope" << endl;
	}
	if (wrench) {
		cout << "- wrench" << endl;
	}

	if (pipe) {
		cout << "- pipe" << endl;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x14(%rdi)
jne 0x2caf
movq 0x1235c(%rip), %r14     # 0x14fd0
leaq 0xa8b9(%rip), %rsi      # 0xd534
movl $0xd, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x10(%rbx)
jne 0x2cf7
movq 0x12314(%rip), %r14     # 0x14fd0
leaq 0xa87f(%rip), %rsi      # 0xd542
movl $0x7, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x12(%rbx)
jne 0x2d3f
movq 0x122cc(%rip), %r14     # 0x14fd0
leaq 0xa83f(%rip), %rsi      # 0xd54a
movl $0xa, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x11(%rbx)
jne 0x2d87
movq 0x12284(%rip), %r14     # 0x14fd0
leaq 0xa802(%rip), %rsi      # 0xd555
movl $0x6, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x13(%rbx)
jne 0x2dcf
movq 0x1223c(%rip), %r14     # 0x14fd0
leaq 0xa7c1(%rip), %rsi      # 0xd55c
movl $0x8, %edx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpb $0x1, 0x15(%rbx)
jne 0x2e1e
movq 0x121f4(%rip), %rbx     # 0x14fd0
leaq 0xa782(%rip), %rsi      # 0xd565
movl $0x6, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/eat.cpp
// Function: Eat::action[abi:cxx11]()
std::string Eat::action() {
	cout << "You have come across " << foodItem << "." << endl;
	cout << "What would you like to do?" << endl;
	cout << "1. Do nothing. Food only slows you down." << endl;
	cout << "2. Eat it. This may be your last meal." << endl;

	return Space::action();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x11fb5(%rip), %r15     # 0x14fd0
leaq 0xa561(%rip), %rsi      # 0xd583
movl $0x15, %edx
movq %r15, %rdi
callq 0x21c0
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %r15, %rdi
callq 0x21c0
movq %rax, %r12
leaq 0xb025(%rip), %rsi      # 0xe074
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa50e(%rip), %rsi      # 0xd599
movl $0x1a, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa4ee(%rip), %rsi      # 0xd5b4
movl $0x28, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa4dc(%rip), %rsi      # 0xd5dd
movl $0x26, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xac4a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/entertain.cpp
// Function: Entertain::action[abi:cxx11]()
std::string Entertain::action() {
	cout << "You have come across " << gameItem << "." << endl;
	cout << "What would you like to do?" << endl;
	cout << "1. Do nothing. It's too dangerous." << endl;
	cout << "2. You're under a lot of pressure. Entertain yourself for a bit. "
			<< endl;

	return Space::action();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x11b9d(%rip), %r15     # 0x14fd0
leaq 0xa149(%rip), %rsi      # 0xd583
movl $0x15, %edx
movq %r15, %rdi
callq 0x21c0
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %r15, %rdi
callq 0x21c0
movq %rax, %r12
leaq 0xac0d(%rip), %rsi      # 0xe074
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa0f6(%rip), %rsi      # 0xd599
movl $0x1a, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa155(%rip), %rsi      # 0xd633
movl $0x22, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xa13d(%rip), %rsi      # 0xd656
movl $0x41, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xac4a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/game.cpp
// Function: Game::intValidation(int, int) const
int Game::intValidation(int min, int max) const {
	int input;
	cin >> input;

	// Try again if input is out of range or fails
	while (input < min || input > max || cin.fail()) {
		cout << "Input must be an integer between " << min << " and "
		     << max << "." << endl;
		cout << "Please try again: ";
		cin.clear();
		cin.ignore(256, '\n');
		cin >> input;
	}

	// Flush buffer after successful input
	cin.clear();
	cin.ignore(256, '\n');

	return input;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq 0xda7d(%rip), %rbx      # 0x14fe0
movq 0xda66(%rip), %r12      # 0x14fd0
leaq 0x8162(%rip), %r13      # 0xf6d3
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x20d0
movl 0x4(%rsp), %eax
cmpl %r14d, %eax
setl %cl
cmpl %ebp, %eax
setg %al
orb %cl, %al
jne 0x75a3
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x7659
movl $0x21, %edx
movq %r12, %rdi
leaq 0x80f9(%rip), %rsi      # 0xf6ab
callq 0x21c0
movq %r12, %rdi
movl %r14d, %esi
callq 0x2260
movq %rax, %r15
movl $0x5, %edx
movq %rax, %rdi
leaq 0x80f9(%rip), %rsi      # 0xf6cd
callq 0x21c0
movq %r15, %rdi
movl %ebp, %esi
callq 0x2260
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x6a7f(%rip), %rsi      # 0xe074
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0x12, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
xorl %esi, %esi
callq 0x2250
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20e0
jmp 0x7571
addq %rax, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2250
movq 0xd973(%rip), %rdi      # 0x14fe0
movl $0x100, %esi            # imm = 0x100
movl $0xa, %edx
callq 0x20e0
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/game.cpp
// Function: Game::~Game()
Game::~Game() {
	delete satchel;
	delete map;

	// Free memory for all rooms
	delete study;
	delete library;
	delete billiards;
	delete conservatory;
	delete ballroom;
	delete kitchen;
	delete dining;
	delete lounge;
	delete hall;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x7ae5
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7af7
movl $0x591, %esi            # imm = 0x591
callq 0x21a0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x7b06
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x7b15
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x7b24
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x7b33
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x7b42
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x7b51
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x7b60
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x7b6f
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x7b7e
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x68(%rbx), %rdi
addq $0x78, %rbx
cmpq %rbx, %rdi
je 0x7b97
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x21a0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/map.cpp
// Function: Map::clearPlayer()
void Map::clearPlayer() {
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 57; j++) {
			if (board[i][j] == '*') {
				board[i][j] = ' ';
			}
		}
	}
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x2a, (%rdi,%rcx)
jne 0x8a56
movb $0x20, (%rdi,%rcx)
incq %rcx
cmpq $0x39, %rcx
jne 0x8a4c
incq %rax
addq $0x39, %rdi
cmpq $0x19, %rax
jne 0x8a4a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/map.cpp
// Function: Map::printBoard() const
void Map::printBoard() const {
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 57; j++) {
			std::cout << board[i][j];
		}
		std::cout << std::endl;
	}
	std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %r12d, %r12d
movq 0xc398(%rip), %rbx      # 0x14fd0
leaq 0xf(%rsp), %r15
movq $-0x39, %r13
movb 0x39(%r14,%r13), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21c0
incq %r13
jne 0x8c44
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
incq %r12
addq $0x39, %r14
cmpq $0x19, %r12
jne 0x8c3d
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/quiet.cpp
// Function: Quiet::action[abi:cxx11]()
std::string Quiet::action() {
	cout << "You notice " << quietItem << " nearby." << endl;
	cout << "Would you like to use it for some peace and quiet?" << endl;
	cout << "1. Yes, it's a good time for me to relax." << endl;
	cout << "2. No, that sounds like a bad idea." << endl;

	return Space::action();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb1bd(%rip), %r15      # 0x14fd0
leaq 0x646c(%rip), %rsi      # 0x10286
movl $0xb, %edx
movq %r15, %rdi
callq 0x21c0
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
movq %r15, %rdi
callq 0x21c0
movq %rax, %r12
leaq 0x644b(%rip), %rsi      # 0x10292
movl $0x8, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6418(%rip), %rsi      # 0x1029b
movl $0x32, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6410(%rip), %rsi      # 0x102ce
movl $0x29, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x63ff(%rip), %rsi      # 0x102f8
movl $0x23, %edx
movq %r15, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
callq 0xac4a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/angelapwen[P]text-based-game/satchel.cpp
// Function: Satchel::clearContents()
void Satchel::clearContents() {
	candlestick = rope = revolver = pipe = knife = wrench = false;
	numUniqueWeapons = 0;
	cout << "Uh oh! You dropped your satchel, butterfingers!" << endl;
	cout << "Someone might be coming." << endl;
	cout << "Pick up your satchel and forget the weapons." << endl;
	cout << "Hydra will take care of them." << endl;
	cout << "\nPress enter to pick up your satchel and hide." << endl;
	getchar();
	cout << "The footsteps you heard fade away. Phew!" << endl;
	cout << "Unfortunately, however, your satchel is now empty.\n" << endl;
}

// Assembly:
pushq %rbx
movw $0x0, 0x14(%rdi)
movq $0x0, 0xc(%rdi)
movq 0xaf3a(%rip), %rbx      # 0x14fd0
leaq 0x62b1(%rip), %rsi      # 0x1034e
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x62a6(%rip), %rsi      # 0x1037e
movl $0x18, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6284(%rip), %rsi      # 0x10397
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6276(%rip), %rsi      # 0x103c4
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6259(%rip), %rsi      # 0x103e2
movl $0x2e, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
callq 0x21f0
leaq 0x6248(%rip), %rsi      # 0x10411
movl $0x28, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x6236(%rip), %rsi      # 0x1043a
movl $0x33, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
jmp 0x2100
nop