LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::copyIntoChunks(int) const
PerfectMatchingSet** PerfectMatchingSet::copyIntoChunks(int numChunks) const {
    PerfectMatchingSet** chunks = new PerfectMatchingSet*[numChunks];
    long chunkSize = this->size() / numChunks;
    long numChunksWithOneExtra = this->size() % numChunks;

    int i = 0;
    for (PerfectMatchingSet::iterator beginChunk = this->begin(), endChunk = this->begin();
         beginChunk != this->end();
         beginChunk = endChunk) {
        endChunk += chunkSize;
        if (numChunksWithOneExtra-- > 0) {
            ++endChunk;
        }

        chunks[i++] = new PerfectMatchingSet(beginChunk, endChunk);
    }
    assert(i == numChunks);

    return chunks;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r15
movslq %esi, %rbx
leaq (,%rbx,8), %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq (%r15), %rax
movq (%rax), %r12
movq 0x8(%rax), %rcx
movq %rcx, %rax
subq %r12, %rax
sarq $0x5, %rax
xorl %edx, %edx
divq %rbx
xorl %r15d, %r15d
cmpq %r12, %rcx
je 0x65c3
movq %rax, %r13
movq %rdx, %rbp
movl %r14d, 0x4(%rsp)
xorl %r15d, %r15d
shlq $0x5, %r13
movq %r12, %r14
leaq (%r12,%r13), %rax
xorl %r12d, %r12d
testq %rbp, %rbp
setg %r12b
shll $0x5, %r12d
addq %rax, %r12
movl $0x8, %edi
callq 0x2240
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x618e
decq %rbp
movq 0x8(%rsp), %rax
movq %rbx, (%rax,%r15,8)
incq %r15
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpq 0x8(%rax), %r12
jne 0x656e
movl 0x4(%rsp), %r14d
cmpl %r14d, %r15d
jne 0x65dc
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xeae(%rip), %rdi       # 0x7491
leaq 0xeb6(%rip), %rsi       # 0x74a0
leaq 0xec6(%rip), %rcx       # 0x74b7
movl $0x72, %edx
callq 0x2140
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2250
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: read[abi:cxx11]()
string read() {
  string l, res = "";
  while (getline(cin, l)) {
    res += l + '\n';
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
leaq 0x1c43(%rip), %rdx      # 0x4049
movq %rdx, %rsi
callq 0x3166
leaq 0x10(%rsp), %rbp
movq 0x3bc6(%rip), %r14      # 0x5fe0
leaq 0x28(%rsp), %r15
movq %rsp, %r12
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x24a9
movq %rbp, (%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x31f6
movq 0x8(%rsp), %rsi
movl $0x1, %ecx
movq %r12, %rdi
xorl %edx, %edx
movl $0xa, %r8d
callq 0x2280
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2070
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x2422
callq 0x2150
jmp 0x2422
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x24b8
callq 0x2150
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x24f8
jmp 0x24d1
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x24e9
callq 0x2150
jmp 0x24e9
jmp 0x24e6
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x24f8
callq 0x2150
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2507
callq 0x2150
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: build(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int>>> const&)
Node *build(const map<char, int> &fs) {
  set<Node*, Cmp> s;
  for (auto const& p : fs) {
    s.insert(new Node{nullptr, nullptr, p.first, p.second});
  }
  while (s.size() > 1) {
    Node *left = *s.begin();
    s.erase(s.begin());
    Node *right = *s.begin();
    s.erase(s.begin());
    s.insert(new Node{left, right, 0, left->freq + right->freq});
  }
  return *s.begin();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x18(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x2616
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movl $0x18, %edi
callq 0x2170
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movb 0x20(%r14), %cl
movb %cl, 0x10(%rax)
movl 0x24(%r14), %ecx
movl %ecx, 0x14(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3486
movq %r14, %rdi
callq 0x21a0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x25d1
cmpq $0x2, 0x30(%rsp)
jb 0x2680
leaq 0x8(%rsp), %rbx
movq %rsp, %r14
movq 0x20(%rsp), %rsi
movq 0x20(%rsi), %r15
movq %rbx, %rdi
callq 0x35aa
movq 0x20(%rsp), %rsi
movq 0x20(%rsi), %r12
movq %rbx, %rdi
callq 0x35aa
movl $0x18, %edi
callq 0x2170
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x14(%r12), %ecx
addl 0x14(%r15), %ecx
movl %ecx, 0x14(%rax)
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3486
cmpq $0x1, 0x30(%rsp)
ja 0x2626
leaq 0x8(%rsp), %rdi
movq 0x18(%rdi), %rax
movq 0x20(%rax), %rbx
callq 0x30a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x26a7
jmp 0x26a7
jmp 0x26a7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: optimize(Node*, bool)
void optimize(Node *root, bool zero = true) {
  if (root->val) return;
  if (zero && root->zero->freq < root->one->freq) swap(root->zero, root->one);
  if (!zero && root->zero->freq > root->one->freq) swap(root->zero, root->one);
  optimize(root->zero, true);
  optimize(root->one, false);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x10(%rbx)
jne 0x2713
testb $0x1, %sil
je 0x26e8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl 0x14(%rax), %edx
cmpl 0x14(%rcx), %edx
jge 0x26e2
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
testb $0x1, %sil
jne 0x26fe
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl 0x14(%rax), %edx
cmpl 0x14(%rcx), %edx
jle 0x26fe
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x26bc
movq 0x8(%rbx), %rbx
xorl %esi, %esi
jmp 0x26c0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: convolute[abi:cxx11](Node const*)
map<char, string> convolute(const Node *root) {
  map<char, string> res;
  if (root->val != 0) {
    res[root->val] = "";
    return res;
  }
  map<char, string> zero = convolute(root->zero);
  for (auto const& p : zero) {
    res[p.first] = "0" + p.second;
  }
  map<char, string> one = convolute(root->one);
  for (auto const& p : one) {
    res[p.first] = "1" + p.second;
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
cmpb $0x0, 0x10(%rsi)
je 0x2775
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x2f66
movq 0x8(%rax), %rdx
leaq 0x18e6(%rip), %rcx      # 0x4049
movq %rax, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x21f0
jmp 0x2874
movq %rsi, (%rsp)
movq (%rsi), %rsi
leaq 0x58(%rsp), %rdi
callq 0x2715
leaq 0x60(%rsp), %rbp
movq 0x10(%rbp), %r15
cmpq %rbp, %r15
je 0x27ea
leaq 0x18(%rsp), %r14
leaq 0x18a8(%rip), %r12      # 0x4048
leaq 0x8(%rsp), %r13
leaq 0x28(%r15), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2fca
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x2f66
movq %rax, %rdi
movq %r13, %rsi
callq 0x21b0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27da
callq 0x2150
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
cmpq %rbp, %rax
jne 0x27a5
movq (%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2715
leaq 0x10(%rsp), %r13
movq 0x10(%r13), %r14
cmpq %r13, %r14
je 0x2860
leaq 0x48(%rsp), %rbp
leaq 0x1834(%rip), %r15      # 0x404a
leaq 0x38(%rsp), %r12
leaq 0x28(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2fca
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x2f66
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2850
callq 0x2150
movq %r14, %rdi
callq 0x20e0
movq %rax, %r14
cmpq %r13, %rax
jne 0x281b
leaq 0x8(%rsp), %rdi
callq 0x30ea
leaq 0x58(%rsp), %rdi
callq 0x30ea
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28b5
jmp 0x288d
movq %rax, %r15
jmp 0x28d6
movq %rax, %r15
jmp 0x28a9
movq %rax, %r15
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x28a9
callq 0x2150
leaq 0x8(%rsp), %rdi
callq 0x30ea
jmp 0x28cc
movq %rax, %r15
jmp 0x28cc
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x28cc
callq 0x2150
leaq 0x58(%rsp), %rdi
callq 0x30ea
movq %rbx, %rdi
callq 0x30ea
movq %r15, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: huffman(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<char>, std::allocator<std::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
string huffman(const string &text, map<char, string> &mapping) {
  string res = "";
  for (char c : text) {
    res += mapping[c];
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
leaq 0x1739(%rip), %rdx      # 0x4049
movq %rdx, %rsi
callq 0x3166
movq 0x8(%r15), %r13
testq %r13, %r13
je 0x2957
movq (%r15), %rbp
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
movb (%rbp,%r12), %al
movb %al, 0xf(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f66
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x2070
incq %r12
cmpq %r12, %r13
jne 0x292c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x297b
callq 0x2150
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: flush(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char, int)
void flush(stringstream &out, char c, int cnt) {
  if (cnt > 3) {
    out << cnt << "@" << c;
  } else {
    for (int j = 0; j < cnt; j++) out << c;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x3, %edx
jle 0x29d1
addq $0x10, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x2240
movq %rax, %r14
leaq 0x169e(%rip), %rsi      # 0x404c
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
leaq 0x7(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2190
jmp 0x29f6
testl %ebp, %ebp
jle 0x29f6
addq $0x10, %r14
leaq 0x6(%rsp), %r15
movb %bl, 0x6(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
decl %ebp
jne 0x29de
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: rle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string rle(const string &s) {
  stringstream out;
  char c = s[0];
  int cnt = 1;
  for (int i = 1; i < s.length(); i++) {
    if (s[i] != c) {
      flush(out, c, cnt);
      c = s[i];
      cnt = 1;
    } else cnt++;
  }
  flush(out, c, cnt);
  return out.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x20f0
movq (%r14), %rax
movb (%rax), %al
movl $0x1, %edx
cmpq $0x2, 0x8(%r14)
jb 0x2a64
movl $0x1, %r12d
movq %rsp, %r15
movq (%r14), %rcx
cmpb %al, (%rcx,%r12)
jne 0x2a44
incl %edx
jmp 0x2a5b
movsbl %al, %esi
movq %r15, %rdi
callq 0x2983
movq (%r14), %rax
movb (%rax,%r12), %al
movl $0x1, %edx
incq %r12
cmpq %r12, 0x8(%r14)
ja 0x2a37
movsbl %al, %esi
movq %rsp, %rdi
callq 0x2983
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
movq 0x352d(%rip), %rsi      # 0x5fb0
movq %rsp, %rdi
callq 0x2110
leaq 0x80(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2aac
movq %rax, %rbx
movq 0x34fa(%rip), %rsi      # 0x5fb0
movq %rsp, %rdi
callq 0x2110
leaq 0x80(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: dispose(Node*)
void dispose(Node *root) {
  if (!root->val) {
    dispose(root->zero);
    dispose(root->one);
  }
  delete root;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
jne 0x2aee
movq (%rbx), %rdi
callq 0x2ad3
movq 0x8(%rbx), %rdi
callq 0x2ad3
testq %rbx, %rbx
je 0x2afc
movq %rbx, %rdi
popq %rbx
jmp 0x2150
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/lionell[P]huffman-rle/main.cc
// Function: run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
string run(const string &text, bool opt) {
  Node *root = build(count(text));
  if (opt) optimize(root);
  map<char, string> mapping = convolute(root);
  dispose(root);
  return rle(huffman(text, mapping));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x250f
movq %r15, %rdi
callq 0x2591
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x3056
testb %bpl, %bpl
je 0x2b46
movq %r15, %rdi
movl $0x1, %esi
callq 0x26bc
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2715
movq %r15, %rdi
callq 0x2ad3
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x28e6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2a01
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b8a
callq 0x2150
leaq 0x20(%rsp), %rdi
callq 0x30ea
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bbf
callq 0x2150
jmp 0x2bbf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x30ea
jmp 0x2bd8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3056
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/mattcha[P]sgd-svm/sgd_svm_train.cpp
// Function: step_train(Instance const&, Weight&, Param&)
int step_train(const Instance &instance, Weight &weight, Param &param)
{
    uint32_t fea_size = instance.f_vec.size();
    // update eta
    param.eta = 1.0 / (param.lambda * sqrt(param.step));
    
    double y_score = inner_product(instance, weight);
    double y_label = instance.y_label;

    double loss = 1 - y_label * y_score;

    for (uint32_t fi=0; fi<fea_size; ++fi) {
        const Feature &fea = instance.f_vec[fi];
        double w_i = weight.w_vec[fea.idx];

        // compute l2 loss
        param.loss_l2 += param.lambda * w_i * w_i;

        // wrong classfy
        // iterate all instance feature
        // w = w - eta*(lambda*w - y_label*x)
        if (loss > 0) {
            w_i = w_i - param.eta*(param.lambda*w_i - y_label*fea.val);
        }
        // right classfy
        // as loss > 0
        // w = w - eta*lambda*w
        if (loss < 0) {
            w_i = w_i - param.eta*param.lambda*w_i;
        }

        weight.w_vec[fea.idx] = w_i;
    }

    if (loss > 0) {
        param.loss_hinge += loss;
    }

    if (loss <= 0) 
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %r12
movsd 0x8(%rdx), %xmm2
movl 0x18(%rdx), %eax
cvtsi2sd %rax, %xmm0
xorpd %xmm1, %xmm1
subq 0x8(%rdi), %r12
ucomisd %xmm1, %xmm0
jb 0x27e8
sqrtsd %xmm0, %xmm0
jmp 0x27f7
movsd %xmm2, -0x28(%rbp)
callq 0x20d0
movsd -0x28(%rbp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x182d(%rip), %xmm0     # 0x4030
divsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x31d4
movsd 0x1811(%rip), %xmm6     # 0x4030
movsd (%r15), %xmm1
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm6
shrq $0x4, %r12
testl %r12d, %r12d
je 0x28b2
xorpd 0x17e3(%rip), %xmm1     # 0x4020
movq 0x8(%r15), %rax
movq (%r14), %rcx
movl %r12d, %edx
addq $0x8, %rax
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm6
movl -0x8(%rax), %esi
movsd (%rcx,%rsi,8), %xmm2
movsd 0x8(%rbx), %xmm3
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
addsd 0x28(%rbx), %xmm5
movsd %xmm5, 0x28(%rbx)
jbe 0x2891
movsd (%rax), %xmm5
mulsd %xmm1, %xmm5
addsd %xmm5, %xmm4
mulsd 0x10(%rbx), %xmm4
subsd %xmm4, %xmm2
ucomisd %xmm6, %xmm0
jbe 0x28a4
mulsd 0x10(%rbx), %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm2
movsd %xmm2, (%rcx,%rsi,8)
addq $0x10, %rax
decq %rdx
jne 0x284f
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm6
jbe 0x28ca
movsd 0x20(%rbx), %xmm1
addsd %xmm6, %xmm1
movsd %xmm1, 0x20(%rbx)
xorl %eax, %eax
ucomisd %xmm6, %xmm0
setae %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mattcha[P]sgd-svm/sgd_svm_train.cpp
// Function: save_model(char const*, Weight const&, Param const&)
int save_model(const char* modelname, const Weight &weight, const Param &param)
{
    if (modelname == NULL) {
        fprintf(stderr, "model name is null\n");
        return -1;
    }

    FILE *fp = fopen(modelname, "w");
    if (fp == NULL) {
        fprintf(stderr, "open model file fail [%s]\n", modelname);
        return -1;
    }

    uint32_t w_size = weight.w_vec.size();
    fprintf(fp, "%f %u %u\n", param.lambda, param.iteration, w_size);

    for (uint32_t i=0; i<w_size; ++i) {
        if (weight.w_vec[i]==0) {
            continue;
        }
        fprintf(fp, "%u\t%f\n", i, weight.w_vec[i]);
    }

    fprintf(stderr, "save model succ\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
jne 0x2ac4
callq 0x233c
jmp 0x2af9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x163d(%rip), %rsi      # 0x4111
callq 0x2130
testq %rax, %rax
jne 0x2b00
movq 0x34f3(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x1624(%rip), %rsi      # 0x4113
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2170
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2b10
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2295
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mattcha[P]sgd-svm/sgd_svm_train.cpp
// Function: main
int main(int argc, char** argv)
{
    Dataset dataset;
    Weight weight;
    Param param;

    if (argc != 5) {
        fprintf(stderr, 
                "Usage : %s iteration lambda trainname modelname\n", argv[0]);
        return 1;
    }

    param.iteration = atoi(argv[1]);
    param.lambda = atof(argv[2]);

    char *trainname = argv[3];
    char *modelname = argv[4];

    param.step = 0;

    int ret = load_data(trainname, dataset, weight);
    if (ret != 0) {
        fprintf(stderr, "load data [%s] fail\n", argv[1]);
        return -1;
    }

    ret = train(dataset, weight, param);
    if (ret != 0) {
        fprintf(stderr, "train fail\n");
        return -1;
    }

    ret = save_model(modelname, weight, param);
    if (ret != 0) {
        fprintf(stderr, "save model fail\n");
        return -1;
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
xorl %eax, %eax
movq %rax, -0x40(%rbp)
movq %rax, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
cmpl $0x5, %edi
jne 0x2be0
movq 0x8(%rbx), %rdi
callq 0x21a0
movl %eax, -0x88(%rbp)
movq 0x10(%rbx), %rdi
callq 0x2150
movsd %xmm0, -0x80(%rbp)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r14
movl $0x0, -0x70(%rbp)
leaq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x259c
testl %eax, %eax
jne 0x2bef
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x28e0
leaq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %r14, %rdi
callq 0x2aae
xorl %ebx, %ebx
testl %eax, %eax
jne 0x2bfd
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2bc9
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x2120
leaq -0x50(%rbp), %rdi
callq 0x2e0e
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x236b
movl $0x1, %ebx
jmp 0x2bb4
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x238e
jmp 0x2c02
callq 0x23b2
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x2bb4
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2c21
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x2120
leaq -0x50(%rbp), %rdi
callq 0x2e0e
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/AGameEntity.cpp
// Function: AGameEntity::refreshPhysics()
void  AGameEntity::refreshPhysics() {
  int didBounce = false;

  _world.setEntityAt((int)_posX, (int)_posY, NULL);

  _posX += _dirX * _acceleration;
  _posY += _dirY * _acceleration;

  _dirX *= _deceleration;
  _dirY *= _deceleration;

  if (_posX < 1) {
    _posX = 1;
    _dirX = -_dirX * _bounce;
    didBounce = true;
  }
  else if (_posX >= _world.getWidth()) {
    _posX = _world.getWidth() - 1;
    _dirX = -_dirX * _bounce;
    didBounce = true;
  }

  if (_posY < 1) {
    _posY = 1;
    _dirY = -_dirY * _bounce;
    didBounce = true;
  }
  else if (_posY >= _world.getHeight()) {
    _posY = _world.getHeight() - 1;
    _dirY = -_dirY * _bounce;
    didBounce = true;
  }
  _world.setEntityAt((int)_posX, (int)_posY, this);

  if (didBounce)
    bounce();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvttss2si 0x8(%rdi), %esi
movq 0x30(%rdi), %rdi
cvttss2si 0xc(%rbx), %edx
xorl %r14d, %r14d
xorl %ecx, %ecx
callq 0x3794
movss 0x18(%rbx), %xmm1
movss 0x10(%rbx), %xmm0
movss 0x14(%rbx), %xmm2
movaps %xmm0, %xmm3
mulss %xmm1, %xmm3
addss 0x8(%rbx), %xmm3
movss %xmm3, 0x8(%rbx)
mulss %xmm2, %xmm1
addss 0xc(%rbx), %xmm1
movss %xmm1, 0xc(%rbx)
movss 0x1c(%rbx), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x10(%rbx)
mulss %xmm1, %xmm2
movss %xmm2, 0x14(%rbx)
movss 0x1a2c(%rip), %xmm1     # 0x4004
ucomiss %xmm3, %xmm1
jbe 0x25e6
movl $0x3f800000, 0x8(%rbx)  # imm = 0x3F800000
jmp 0x2633
movq 0x30(%rbx), %rdi
movss %xmm3, 0x4(%rsp)
callq 0x350a
movss 0x1a07(%rip), %xmm1     # 0x4004
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x4(%rsp), %xmm2
ucomiss %xmm0, %xmm2
jb 0x264a
movq 0x30(%rbx), %rdi
callq 0x350a
movss 0x19e4(%rip), %xmm1     # 0x4004
decl %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x8(%rbx)
movss 0x10(%rbx), %xmm0
xorps 0x19d6(%rip), %xmm0     # 0x4010
mulss 0x20(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movl $0x1, %r14d
movss 0xc(%rbx), %xmm0
ucomiss %xmm0, %xmm1
ja 0x2687
movq 0x30(%rbx), %rdi
movss %xmm0, 0x4(%rsp)
callq 0x3506
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x4(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jb 0x26a8
movq 0x30(%rbx), %rdi
callq 0x3506
decl %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss %xmm1, 0xc(%rbx)
movss 0x14(%rbx), %xmm0
xorps 0x1978(%rip), %xmm0     # 0x4010
mulss 0x20(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
movl $0x1, %r14d
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3794
testl %r14d, %r14d
je 0x26d3
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/BasicMissile.cpp
// Function: BasicMissile::BasicMissile(AShip const&, float)
BasicMissile::BasicMissile(const AShip& sender, float power) :
  AMissile(sender, power)
{
  _deceleration = 1.0001;
  _acceleration = 0.1;
  _bounce = 0.0;
  _maxSpeed = 0.7;
  _skin = ACS_BULLET;

  _posX = _sender.getPosX() + _sender.getShootX();
  _posY = _sender.getPosY() + _sender.getShootY();

  _dirX = _sender.getShootX() * power * _acceleration;
  _dirY = _sender.getShootY() * power * _acceleration;

  _world.setEntityAt((int)_posX, (int)_posY, this);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss %xmm0, 0x4(%rsp)
callq 0x27c8
leaq 0x43d7(%rip), %rax      # 0x6c28
movq %rax, (%rbx)
movabsq $0x3f8003473dcccccd, %rax # imm = 0x3F8003473DCCCCCD
movq %rax, 0x18(%rbx)
movabsq $0x3f33333300000000, %rax # imm = 0x3F33333300000000
movq %rax, 0x20(%rbx)
movq 0x4739(%rip), %rax      # 0x6fb0
movl 0x1f8(%rax), %eax
movl %eax, 0x2c(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26e6
movss %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
callq 0x27b0
movss (%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26ec
movss %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
callq 0x27b6
movss (%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rbx)
movq 0x38(%rbx), %rdi
callq 0x27b0
mulss 0x4(%rsp), %xmm0
mulss 0x18(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movq 0x38(%rbx), %rdi
callq 0x27b6
mulss 0x4(%rsp), %xmm0
mulss 0x18(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3794
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x282a
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/BasicMissile.cpp
// Function: BasicMissile::BasicMissile(AShip const&, float, float, float, float, float)
BasicMissile::BasicMissile(const AShip& sender, float power,
              float offsetX, float offsetY, float dirX, float dirY) :
  AMissile(sender, power)
{
  _deceleration = 1.0001;
  _acceleration = 0.1;
  _bounce = 0.0;
  _maxSpeed = 0.7;
  _skin = ACS_BULLET;

  _posX = _sender.getPosX() + _sender.getShootX() + offsetX;
  _posY = _sender.getPosY() + _sender.getShootY() + offsetY;

  _dirX = (_sender.getShootX() + dirX) * power * _acceleration;
  _dirY = (_sender.getShootY() + dirY) * power * _acceleration;

  _world.setEntityAt((int)_posX, (int)_posY, this);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm4, 0x8(%rsp)
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x10(%rsp)
movss %xmm1, (%rsp)
movq %rdi, %rbx
movss %xmm0, 0x4(%rsp)
callq 0x27c8
leaq 0x42c7(%rip), %rax      # 0x6c28
movq %rax, (%rbx)
movabsq $0x3f8003473dcccccd, %rax # imm = 0x3F8003473DCCCCCD
movq %rax, 0x18(%rbx)
movabsq $0x3f33333300000000, %rax # imm = 0x3F33333300000000
movq %rax, 0x20(%rbx)
movq 0x4629(%rip), %rax      # 0x6fb0
movl 0x1f8(%rax), %eax
movl %eax, 0x2c(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26e6
movss %xmm0, 0x14(%rsp)
movq 0x38(%rbx), %rdi
callq 0x27b0
movss 0x14(%rsp), %xmm1
addss %xmm0, %xmm1
addss (%rsp), %xmm1
movss %xmm1, 0x8(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26ec
movss %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
callq 0x27b6
movss (%rsp), %xmm1
addss %xmm0, %xmm1
addss 0x10(%rsp), %xmm1
movss %xmm1, 0xc(%rbx)
movq 0x38(%rbx), %rdi
callq 0x27b0
addss 0xc(%rsp), %xmm0
mulss 0x4(%rsp), %xmm0
mulss 0x18(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movq 0x38(%rbx), %rdi
callq 0x27b6
addss 0x8(%rsp), %xmm0
mulss 0x4(%rsp), %xmm0
mulss 0x18(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3794
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x282a
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/BasicMissile.cpp
// Function: BasicMissile::draw()
void BasicMissile::draw() {
  int offsetX = (COLS - _world.getWidth()) / 2;
  int offsetY = (LINES - _world.getHeight()) / 2;

  move(offsetY + _posY, offsetX + _posX);
  addch(_skin);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4530(%rip), %rax      # 0x6fb8
movl (%rax), %ebp
movq 0x30(%rdi), %rdi
callq 0x350a
subl %eax, %ebp
movl %ebp, %r14d
shrl $0x1f, %r14d
addl %ebp, %r14d
sarl %r14d
movq 0x44ff(%rip), %rax      # 0x6fa8
movl (%rax), %ebp
movq 0x30(%rbx), %rdi
callq 0x3506
subl %eax, %ebp
movl %ebp, %eax
shrl $0x1f, %eax
addl %ebp, %eax
sarl %eax
cvtsi2ss %eax, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq 0x44ef(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
movl 0x2c(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2070
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/BasicEnemy.cpp
// Function: BasicEnemy::BasicEnemy(int, int)
BasicEnemy::BasicEnemy(int x, int y) :
  AEnemy(x, y)
{
  _posX = x;
  _posY = y;

  _dirX = 0.2;
  _dirY = 1;
  _acceleration = 0.001 + (float)(Game::getInstance()->getElapsedTime()) / 100000000;
  _deceleration = 1.00001 + (float)(Game::getInstance()->getElapsedTime()) / 100000000;
  _skin = ACS_DARROW;

  _bounce = 0.4;
  _maxSpeed = 0.1;
  _lastShootTimestamp = 0;

  _world.setEntityAt((int)_posX, (int)_posY, this);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x2b40
leaq 0x40d0(%rip), %rax      # 0x6cd8
cvtsi2ss %r14d, %xmm0
movq %rax, (%rbx)
cvtsi2ss %ebp, %xmm1
movss %xmm0, 0x8(%rbx)
movss %xmm1, 0xc(%rbx)
movabsq $0x3f8000003e4ccccd, %rax # imm = 0x3F8000003E4CCCCD
movq %rax, 0x10(%rbx)
callq 0x344c
movq %rax, %rdi
callq 0x3448
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1418(%rip), %xmm0     # 0x4060
cvtss2sd %xmm0, %xmm0
addsd 0x141c(%rip), %xmm0     # 0x4070
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rbx)
callq 0x344c
movq %rax, %rdi
callq 0x3448
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x13e7(%rip), %xmm0     # 0x4060
cvtss2sd %xmm0, %xmm0
addsd 0x13f3(%rip), %xmm0     # 0x4078
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rbx)
movq 0x431b(%rip), %rax      # 0x6fb0
movl 0xb8(%rax), %eax
movl %eax, 0x2c(%rbx)
movabsq $0x3dcccccd3ecccccd, %rax # imm = 0x3DCCCCCD3ECCCCCD
movq %rax, 0x20(%rbx)
movl $0x0, 0x54(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3794
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bb2
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/BasicEnemy.cpp
// Function: BasicEnemy::BasicEnemy(BasicEnemy const&)
BasicEnemy::BasicEnemy(const BasicEnemy& game) :
  AEnemy(game)
{
  *this = game;

  _dirX = 0;
  _dirY = 1;
  _acceleration = 0.001 + (float)(Game::getInstance()->getElapsedTime()) / 10000000;
  _deceleration = 1.00001 + (float)(Game::getInstance()->getElapsedTime()) / 10000000;
  _skin = ACS_DARROW;

  _bounce = 0.4;
  _maxSpeed = 0.1;
  _lastShootTimestamp = 0;

  _world.setEntityAt((int)_posX, (int)_posY, this);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2b98
leaq 0x3fe3(%rip), %rax      # 0x6cd8
movq %rax, (%rbx)
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
movq %rax, 0x10(%rbx)
callq 0x344c
movq %rax, %rdi
callq 0x3448
cvtsi2ss %eax, %xmm0
divss 0x1345(%rip), %xmm0     # 0x4064
cvtss2sd %xmm0, %xmm0
addsd 0x1345(%rip), %xmm0     # 0x4070
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rbx)
callq 0x344c
movq %rax, %rdi
callq 0x3448
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1314(%rip), %xmm0     # 0x4064
cvtss2sd %xmm0, %xmm0
addsd 0x131c(%rip), %xmm0     # 0x4078
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rbx)
movq 0x4244(%rip), %rax      # 0x6fb0
movl 0xb8(%rax), %eax
movl %eax, 0x2c(%rbx)
movabsq $0x3dcccccd3ecccccd, %rax # imm = 0x3DCCCCCD3ECCCCCD
movq %rax, 0x20(%rbx)
movl $0x0, 0x54(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3794
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bb2
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/BasicEnemy.cpp
// Function: BasicEnemy::draw()
void  BasicEnemy::draw() {
  int offsetX = (COLS - _world.getWidth()) / 2;
  int offsetY = (LINES - _world.getHeight()) / 2;

  attron(COLOR_PAIR(2));
  move(offsetY + _posY, offsetX + _posX);
  addch(_skin);
  attroff(COLOR_PAIR(2));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x413b(%rip), %rax      # 0x6fb8
movl (%rax), %r14d
movq 0x30(%rdi), %rdi
callq 0x350a
subl %eax, %r14d
movl %r14d, %ebp
shrl $0x1f, %ebp
addl %r14d, %ebp
sarl %ebp
movq 0x410a(%rip), %rax      # 0x6fa8
movl (%rax), %r14d
movq 0x30(%rbx), %rdi
callq 0x3506
subl %eax, %r14d
movl %r14d, %r15d
shrl $0x1f, %r15d
addl %r14d, %r15d
sarl %r15d
movq 0x4117(%rip), %r14      # 0x6fd8
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x20b0
cvtsi2ss %r15d, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq (%r14), %rdi
movl 0x2c(%rbx), %esi
callq 0x2070
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Game.cpp
// Function: Game::_getKey()
void  Game::_getKey() {
  int key = getch();

  switch (key) {

    case 27:
      _running = false;
      break;

    case KEY_RIGHT:
      if (!_gameOver)
        _player1->moveImpulsion(0.5, 0);
      break;

    case KEY_LEFT:
      if (!_gameOver)
        _player1->moveImpulsion(-0.5, 0);
      break;

    case KEY_UP:
      if (!_gameOver)
        _player1->moveImpulsion(0, -0.1);
      break;

    case KEY_DOWN:
      if (!_gameOver)
        _player1->moveImpulsion(0, 0.1);
      break;

    case ' ':
      if (!_gameOver)
        _player1->shoot();
      break;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x3f45(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x2090
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
ja 0x30ca
leaq 0xfef(%rip), %rax       # 0x409c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpl $0x0, 0x8(%rbx)
jne 0x311a
movq 0x18(%rbx), %rdi
movss 0xfa0(%rip), %xmm1      # 0x4068
jmp 0x3128
cmpl $0x20, %eax
je 0x30d9
cmpl $0x1b, %eax
jne 0x311a
movb $0x0, (%rbx)
jmp 0x311a
cmpl $0x0, 0x8(%rbx)
jne 0x311a
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x3a40
cmpl $0x0, 0x8(%rbx)
jne 0x311a
movq 0x18(%rbx), %rdi
movss 0xf99(%rip), %xmm0      # 0x4094
jmp 0x310f
cmpl $0x0, 0x8(%rbx)
jne 0x311a
movq 0x18(%rbx), %rdi
movss 0xf89(%rip), %xmm0      # 0x4098
xorps %xmm1, %xmm1
jmp 0x312b
cmpl $0x0, 0x8(%rbx)
je 0x311c
popq %rbx
retq
movq 0x18(%rbx), %rdi
movss 0xf68(%rip), %xmm1      # 0x4090
xorps %xmm0, %xmm0
popq %rbx
jmp 0x3b20
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Game.cpp
// Function: Game::run()
void  Game::run() {
  static int elapsedMicroSeconds = 0;
  _elapsedTime = 0;

  initscr();
  ESCDELAY = 10;
  keypad(stdscr, TRUE);
  nodelay(stdscr, TRUE);
  curs_set(0);
  noecho();
  initColors();


  setPlayer1(_world.getWidth() / 2, _world.getHeight() * 3 / 4);
  

  // playMusic();

  while (_running) {
    _getKey();
    refreshPhysics();
    draw();
    refresh();

    popRandomEnemy();
  
    usleep(300);
    elapsedMicroSeconds += 310;
    if (elapsedMicroSeconds > 1000) {
      elapsedMicroSeconds = elapsedMicroSeconds % 1000;
      _elapsedTime++;
    }
  }

  // stopMusic();

  echo();
  endwin();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
callq 0x21e0
movq 0x3e7c(%rip), %rax      # 0x6fc8
movl $0xa, (%rax)
movq 0x3e7f(%rip), %r14      # 0x6fd8
movq (%r14), %rdi
movl $0x1, %esi
callq 0x20a0
movq (%r14), %rdi
movl $0x1, %esi
callq 0x20c0
xorl %edi, %edi
callq 0x20e0
callq 0x2160
callq 0x2050
movl $0x1, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x2, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x3, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2040
movl $0x4, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x5, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x6, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x350a
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movq 0x10(%rbx), %rdi
callq 0x3506
leal (%rax,%rax,2), %ecx
leal (%rax,%rax,2), %edx
addl $0x3, %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x2, %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3038
cmpb $0x1, (%rbx)
jne 0x3292
movq %rbx, %rdi
callq 0x3088
movq 0x10(%rbx), %rdi
callq 0x3736
movq %rbx, %rdi
callq 0x32aa
callq 0x2200
movq %rbx, %rdi
callq 0x332a
movl $0x12c, %edi            # imm = 0x12C
callq 0x21d0
movl 0x3ee9(%rip), %ecx      # 0x7144
leal 0x136(%rcx), %eax
movl %eax, 0x3edd(%rip)      # 0x7144
cmpl $0x2b3, %ecx            # imm = 0x2B3
jl 0x328d
movl %eax, %ecx
imulq $0x10624dd3, %rcx, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %eax
movl %eax, 0x3eba(%rip)      # 0x7144
incl 0xc(%rbx)
cmpb $0x0, (%rbx)
jne 0x3225
callq 0x2080
popq %rbx
popq %r14
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Game.cpp
// Function: Game::draw()
void  Game::draw() {
  _world.draw();

  _drawScore();

  if (_gameOver)
    _drawGameOver();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x350e
movq 0x3cf7(%rip), %r14      # 0x6fb8
movl (%r14), %eax
movl %eax, %esi
shrl $0x1f, %esi
addl %eax, %esi
sarl %esi
addl $-0x5, %esi
movl 0x4(%rbx), %ecx
leaq 0xdd2(%rip), %rdx       # 0x40ac
movl $0x3, %edi
xorl %eax, %eax
callq 0x21b0
cmpl $0x0, 0x8(%rbx)
je 0x3322
movq 0x3cb5(%rip), %rax      # 0x6fa8
movl (%rax), %eax
movl %eax, %edi
shrl $0x1f, %edi
addl %eax, %edi
sarl %edi
movl (%r14), %eax
movl %eax, %esi
shrl $0x1f, %esi
addl %eax, %esi
sarl %esi
addl $-0x4, %esi
leaq 0xda2(%rip), %rdx       # 0x40b6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Game.cpp
// Function: Game::popRandomEnemy()
void  Game::popRandomEnemy() {
  static int lastEnemyTimestamp = 0;

  if (_elapsedTime - lastEnemyTimestamp > min(2000 - _elapsedTime / 100, 300)) {
    lastEnemyTimestamp = _elapsedTime;
    
    new BasicEnemy(_world.getWidth() * (rand() % 100) / 100, 1);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq 0xc(%rdi), %rax
movl %eax, %ecx
subl 0x3e0e(%rip), %ecx      # 0x7148
imulq $-0x51eb851f, %rax, %rdx # imm = 0xAE147AE1
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x25, %rdx
addl %esi, %edx
movl $0xfffff95c, %esi       # imm = 0xFFFFF95C
cmpl %esi, %edx
cmovgel %esi, %edx
addl $0x7d0, %edx            # imm = 0x7D0
cmpl %edx, %ecx
jle 0x33c9
movq %rdi, %r14
movl %eax, 0x3ddd(%rip)      # 0x7148
movl $0x58, %edi
callq 0x2110
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x350a
movl %eax, %ebp
callq 0x2060
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
imull %ebp, %eax
cltq
imulq $0x51eb851f, %rax, %rsi # imm = 0x51EB851F
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x25, %rsi
addl %eax, %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2bf0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/World.cpp
// Function: World::_createMap()
void          World::_createMap() {
  this->_map = new AGameEntity**[_width];

  for (int i = 0; i < _width; i++) {
    this->_map[i] = new AGameEntity*[_height];

    for (int j = 0; j < _height; j++)
      this->_map[i][j] = NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
testq %r15, %r15
jle 0x34e9
movslq 0x4(%rbx), %rax
leaq (,%rax,8), %r14
testq %rax, %rax
cmovsq %r12, %r14
movl %eax, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x2030
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
testl %r12d, %r12d
jle 0x34e1
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x34c9
incq %r13
cmpq %r15, %r13
jne 0x34b2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/World.cpp
// Function: World::draw()
void          World::draw() {
  erase();

  int offsetX = (COLS - _width) / 2;
  int offsetY = (LINES - _height) / 2;

  drawRectangle(offsetX, offsetY, _width, _height);

  for (int i = 0; i < _width; i++)
    for (int j = 0; j < _height; j++)
      if (getEntityAt(i, j))
        getEntityAt(i, j)->draw();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2150
movq 0x3a90(%rip), %rax      # 0x6fb8
movl (%rax), %eax
movl (%rbx), %r13d
movl 0x4(%rbx), %ebp
subl %r13d, %eax
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
movq 0x3a61(%rip), %rax      # 0x6fa8
movl (%rax), %eax
subl %ebp, %eax
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
movq 0x3a79(%rip), %r15      # 0x6fd8
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x20b0
movq (%r15), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3598
movq (%r15), %rdi
movq 0x3a25(%rip), %rax      # 0x6fb0
movl 0x1e0(%rax), %esi
movl %ebp, %edx
callq 0x2180
movq (%r15), %rdi
leal (%r14,%r13), %edx
movl %r12d, %esi
movl %edx, 0x4(%rsp)
callq 0x2140
cmpl $-0x1, %eax
je 0x35c7
movq (%r15), %rdi
movq 0x39f6(%rip), %rax      # 0x6fb0
movl 0x1e0(%rax), %esi
movl %ebp, %edx
callq 0x2180
movq (%r15), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x35f2
movq (%r15), %rdi
movq 0x39cc(%rip), %rax      # 0x6fb0
movl 0x1c4(%rax), %esi
movl %r13d, %edx
callq 0x20f0
movq (%r15), %rdi
addl %r12d, %ebp
movl %ebp, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3622
movq (%r15), %rdi
movq 0x399f(%rip), %rax      # 0x6fb0
movl 0x1c4(%rax), %esi
incl %r13d
movl %r13d, %edx
callq 0x20f0
movq (%r15), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x364a
movq (%r15), %rdi
movq 0x3971(%rip), %rax      # 0x6fb0
movl 0x1b0(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl %r12d, %esi
movl 0x4(%rsp), %r12d
movl %r12d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3677
movq (%r15), %rdi
movq 0x3944(%rip), %rax      # 0x6fb0
movl 0x1ac(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x369e
movq (%r15), %rdi
movq 0x391d(%rip), %rax      # 0x6fb0
movl 0x1b4(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x36c5
movq (%r15), %rdi
movq 0x38f6(%rip), %rax      # 0x6fb0
movl 0x1a8(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x21a0
cmpl $0x0, (%rbx)
jle 0x3713
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rbx)
jle 0x3708
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x36fc
movq (%rdi), %rax
callq *0x10(%rax)
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x36e5
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x36dc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/World.cpp
// Function: World::refreshPhysics()
void          World::refreshPhysics() {
  for (int i = 0; i < _width; i++)
    for (int j = 0; j < _height; j++)
      if (getEntityAt(i, j)) {
        getEntityAt(i, j)->think();
        getEntityAt(i, j)->refreshPhysics();
      }
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x3793
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rbx)
jle 0x3783
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x3777
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
callq 0x256c
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x374f
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x3746
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/World.cpp
// Function: World::setEntityAt(int, int, AGameEntity*)
void    World::setEntityAt(int x, int y, AGameEntity* entity) {
  if (x < 0 || y < 0 || x >= _width || y >= _height) {
    entity->collide();
    return;
  }  

  if (!entity) {
    this->_map[x][y] = NULL;
    return;
  }

  if (this->_map[x][y]) {
    this->_map[x][y]->collide();
    entity->collide();
  }
  else
  	this->_map[x][y] = entity;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %edx, %eax
orl %esi, %eax
js 0x37c7
cmpl %esi, (%rdi)
jle 0x37c7
cmpl %edx, 0x4(%rdi)
jle 0x37c7
movq 0x8(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
testq %rbx, %rbx
je 0x37d1
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x37db
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x20(%rax)
movq $0x0, (%rax,%rcx,8)
jmp 0x37df
movq %rbx, (%rax,%rcx,8)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Player.cpp
// Function: Player::Player()
Player::Player() :
  AShip(100, 100, 100, 0, -1, 53)
{
  _deceleration = 0.997;
  _acceleration = 0.06;
  _bounce = 0.5;
  _maxSpeed = 1.6;
  _skin = ACS_UARROW;

  _world.setEntityAt((int)_posX, (int)_posY, this);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x85d(%rip), %xmm0      # 0x4050
movss 0x8e1(%rip), %xmm2      # 0x40dc
xorps %xmm1, %xmm1
movl $0x64, %esi
movl $0x64, %edx
movl $0x35, %ecx
callq 0x271c
leaq 0x3517(%rip), %rax      # 0x6d30
movq %rax, (%rbx)
movabsq $0x3f7f3b643d75c28f, %rax # imm = 0x3F7F3B643D75C28F
movq %rax, 0x18(%rbx)
movabsq $0x3fcccccd3f000000, %rax # imm = 0x3FCCCCCD3F000000
movq %rax, 0x20(%rbx)
movq 0x3771(%rip), %rax      # 0x6fb0
movl 0xb4(%rax), %eax
movl %eax, 0x2c(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3794
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x27a2
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Player.cpp
// Function: Player::Player(int, int)
Player::Player(int x, int y) :
  AShip(100, 100, 100, 0, -1, 53)
{
  _posX = x;
  _posY = y;

  _deceleration = 0.997;
  _acceleration = 0.06;
  _bounce = 0.5;
  _maxSpeed = 1.6;
  _skin = ACS_UARROW;

  _world.setEntityAt((int)_posX, (int)_posY, this);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movss 0x7c2(%rip), %xmm0      # 0x4050
movss 0x846(%rip), %xmm2      # 0x40dc
xorps %xmm1, %xmm1
movl $0x64, %esi
movl $0x64, %edx
movl $0x35, %ecx
callq 0x271c
leaq 0x347c(%rip), %rax      # 0x6d30
movq %rax, (%rbx)
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
movss %xmm0, 0x8(%rbx)
xorps %xmm1, %xmm1
cvtsi2ss %ebp, %xmm1
movss %xmm1, 0xc(%rbx)
movabsq $0x3f7f3b643d75c28f, %rax # imm = 0x3F7F3B643D75C28F
movq %rax, 0x18(%rbx)
movabsq $0x3fcccccd3f000000, %rax # imm = 0x3FCCCCCD3F000000
movq %rax, 0x20(%rbx)
movq 0x36bd(%rip), %rax      # 0x6fb0
movl 0xb4(%rax), %eax
movl %eax, 0x2c(%rbx)
movq 0x30(%rbx), %rdi
cvttss2si %xmm0, %esi
cvttss2si %xmm1, %edx
movq %rbx, %rcx
callq 0x3794
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x27a2
movq %r14, %rdi
callq 0x2210