LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::filter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void PerfectMatchingSet::filter(const PerfectMatching& p, int n) {
    vector<Pm>* newData = new vector<Pm>();
    for (PerfectMatchingSet::iterator it = this->begin(); it != this->end(); ++it) {
        if (numInCommon(p, *it) == n) {
            newData->push_back(*it);
        }
    }

    delete this->data;
    this->data = newData;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x2250
movq %rax, %r14
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%rbx), %r13
movq (%r13), %r12
cmpq 0x8(%r13), %r12
je 0x5955
movq %r15, %rdi
movq %r12, %rsi
callq 0x57fc
cmpl %ebp, %eax
jne 0x594c
movq %r14, %rdi
movq %r12, %rsi
callq 0x5c86
addq $0x20, %r12
movq (%rbx), %r13
jmp 0x592c
movq %r13, %rdi
callq 0x5c64
pushq $0x18
popq %rsi
movq %r13, %rdi
callq 0x2260
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::filter(TruthBooth const&, bool)
void PerfectMatchingSet::filter(const Tb& m, bool isMatch) {
    vector<Pm>* newData = new vector<Pm>();
    for (PerfectMatchingSet::iterator it = this->begin(); it != this->end(); ++it) {
        if (isMatch == ((*it)[m.index] == m.charAtIndex)) {
            newData->push_back(*it);
        }
    }

    delete this->data;
    this->data = newData;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x2250
movq %rax, %r14
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%rbx), %r12
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0x59db
movslq (%r15), %rax
movq (%r13), %rcx
movb (%rcx,%rax), %al
cmpb 0x4(%r15), %al
setne %al
cmpb %bpl, %al
je 0x59d5
movq %r14, %rdi
movq %r13, %rsi
callq 0x5c86
movq (%rbx), %r12
addq $0x20, %r13
jmp 0x59aa
movq %r12, %rdi
callq 0x5c64
pushq $0x18
popq %rsi
movq %r12, %rdi
callq 0x2260
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::populateAll()
void PerfectMatchingSet::populateAll() {
    Pm p = "0123456789";
    do {
        this->add(p);
    } while (next_permutation(p.begin(), p.end()));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x160a(%rip), %rsi      # 0x7025
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x4034
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58c2
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq %rdi, %rsi
callq 0x4767
testb %al, %al
jne 0x5a2d
leaq 0x8(%rsp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/chrischute[P]are-you-the-one/src/PerfectMatchingSet.cpp
// Function: PerfectMatchingSet::populateFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PerfectMatchingSet::populateFromFile(string filename) {
    Pm s;
    ifstream inputFile(filename);

    while (inputFile >> s) {
        this->add(s);
    }

    inputFile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2330
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x22a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5ad3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58c2
jmp 0x5aad
leaq 0x28(%rsp), %rdi
callq 0x2060
leaq 0x28(%rsp), %rdi
callq 0x2070
leaq 0x8(%rsp), %rdi
callq 0x20e0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5b05
movq %rax, %rbx
jmp 0x5b12
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2070
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movslq %esi, %r14
leaq (,%r14,8), %rax
testl %r14d, %r14d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq (%rbx), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rcx
movq %rcx, %rax
subq %rbx, %rax
sarq $0x5, %rax
xorl %edx, %edx
divq %r14
movq %rax, %r12
movq %rdx, %r13
xorl %r15d, %r15d
shlq $0x5, %r12
cmpq %rcx, %rbx
je 0x5be4
leaq (%rbx,%r12), %rax
xorl %ebp, %ebp
testq %r13, %r13
setg %bpl
shll $0x5, %ebp
addq %rax, %rbp
pushq $0x8
popq %rdi
callq 0x2250
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x5850
decq %r13
movq 0x8(%rsp), %rax
movq %r14, (%rax,%r15,8)
incq %r15
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq %rbp, %rbx
jmp 0x5b93
cmpl %r15d, 0x4(%rsp)
jne 0x5bff
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18ad(%rip), %rdi      # 0x74b3
leaq 0x18b5(%rip), %rsi      # 0x74c2
leaq 0x18c5(%rip), %rcx      # 0x74d9
pushq $0x72
popq %rdx
callq 0x2140
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2260
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x1c56(%rip), %rsi      # 0x4049
leaq 0x20(%rsp), %rdx
callq 0x2080
movq 0x4bdc(%rip), %r14      # 0x6fe0
movq %rsp, %r15
leaq 0x20(%rsp), %r12
pushq $0xa
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x244a
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2cc6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2290
movq %r12, %rdi
callq 0x20b0
jmp 0x240f
movq %rsp, %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2483
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20b0
jmp 0x247b
jmp 0x2478
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %rsp, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
cmpb $0x0, 0x10(%rbx)
jne 0x2676
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movl 0x14(%rax), %ecx
movl 0x14(%rdi), %edx
testb $0x1, %sil
je 0x265c
cmpl %edx, %ecx
jl 0x2660
movq %rax, %rdi
jmp 0x2667
cmpl %edx, %ecx
jle 0x2657
movq %rdi, (%rbx)
movq %rax, 0x8(%rbx)
movl %ebp, %esi
callq 0x2631
movq 0x8(%rbx), %rbx
xorl %esi, %esi
jmp 0x263a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r14
cmpb $0x0, 0x10(%rsi)
je 0x26d7
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d4a
leaq 0x197f(%rip), %rsi      # 0x4049
movq %rax, %rdi
callq 0x2270
jmp 0x27b2
movq (%r14), %rsi
leaq 0x38(%rsp), %rdi
callq 0x267d
leaq 0x40(%rsp), %rbp
movq 0x10(%rbp), %r13
leaq 0x1954(%rip), %r15      # 0x4048
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0x2739
leaq 0x28(%r13), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2d98
leaq 0x20(%r13), %rsi
movq %rbx, %rdi
callq 0x2d4a
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
movq %r12, %rdi
callq 0x20b0
movq %r13, %rdi
callq 0x20f0
movq %rax, %r13
jmp 0x26f9
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x267d
leaq 0x10(%rsp), %r13
movq 0x10(%r13), %r12
leaq 0x18f3(%rip), %r14      # 0x404a
leaq 0x68(%rsp), %r15
cmpq %r13, %r12
je 0x279e
leaq 0x28(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d98
leaq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x2d4a
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x20f0
movq %rax, %r12
jmp 0x275c
leaq 0x8(%rsp), %rdi
callq 0x2eaa
leaq 0x38(%rsp), %rdi
callq 0x2eaa
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27ee
jmp 0x27cb
movq %rax, %r14
jmp 0x280a
movq %rax, %r14
jmp 0x27e2
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x2eaa
jmp 0x2800
movq %rax, %r14
jmp 0x2800
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x38(%rsp), %rdi
callq 0x2eaa
movq %rbx, %rdi
callq 0x2eaa
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1814(%rip), %rsi      # 0x4049
leaq 0x7(%rsp), %rdx
callq 0x2080
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %ebp, %ebp
leaq 0x6(%rsp), %r15
cmpq %rbp, %r13
je 0x2875
movb (%r12,%rbp), %al
movb %al, 0x6(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d4a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2290
incq %rbp
jmp 0x284d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
addq $0x10, %rbx
cmpl $0x3, %edx
jle 0x28d5
movq %rbx, %rdi
movl %edx, %esi
callq 0x2250
leaq 0x178f(%rip), %rsi      # 0x404c
movq %rax, %rdi
callq 0x2160
movsbl %bpl, %esi
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
xorl %r14d, %r14d
testl %edx, %edx
cmovgl %edx, %r14d
movsbl %bpl, %ebp
subl $0x1, %r14d
jb 0x28f4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x21b0
jmp 0x28e2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2100
movq (%r14), %rax
movb (%rax), %cl
pushq $0x1
popq %rbp
pushq $0x1
popq %r12
movl %ebp, %edx
movsbl %cl, %esi
cmpq %r12, 0x8(%r14)
jbe 0x2952
cmpb %cl, (%rax,%r12)
jne 0x293c
incl %edx
jmp 0x294d
movq %r15, %rdi
callq 0x289a
movq (%r14), %rax
movb (%rax,%r12), %cl
movl %ebp, %edx
incq %r12
jmp 0x2929
leaq 0x8(%rsp), %rdi
callq 0x289a
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2220
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2988
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29b8
movq (%rbx), %rdi
callq 0x299d
movq 0x8(%rbx), %rdi
callq 0x299d
movq %rbx, %rdi
popq %rbx
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2493
movq %r15, %rdi
callq 0x250f
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x2e1a
testb %bpl, %bpl
je 0x2a07
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x2631
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x267d
movq %r15, %rdi
callq 0x299d
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x281a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x28f9
movq %rsp, %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x2eaa
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20b0
jmp 0x2a6a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2eaa
jmp 0x2a83
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2e1a
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/lionell[P]huffman-rle/main.cc
// Function: main
int main() {
  string text = read();

  string without = run(text, false);
  write(without, "out.txt");
  string with = run(text, true);
  write(with, "opt.txt");

  cout << without.length() << " chars w/o optimization" << endl;
  cout << with.length() << " chars with optimization" << endl;
  cout << setprecision(3) << 100. - (100. * with.length() / without.length()) << "% benefit";
  return 0;
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0x23cc
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x29c1
leaq 0x1543(%rip), %rsi      # 0x404e
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2080
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2a8b
leaq 0x70(%rsp), %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x29c1
leaq 0x1507(%rip), %rsi      # 0x4056
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2080
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2a8b
leaq 0x50(%rsp), %rdi
callq 0x20b0
movq 0x38(%rsp), %rsi
movq 0x444d(%rip), %rdi      # 0x6fd0
callq 0x20e0
leaq 0x14cf(%rip), %rsi      # 0x405e
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
movq 0x18(%rsp), %rsi
movq 0x4425(%rip), %rbx      # 0x6fd0
movq %rbx, %rdi
callq 0x20e0
leaq 0x14bc(%rip), %rsi      # 0x4076
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x8(%rbx,%rax)
movsd 0x18(%rsp), %xmm0
movsd 0x1438(%rip), %xmm1     # 0x4020
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x143d(%rip), %xmm2     # 0x4030
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movsd 0x1435(%rip), %xmm0     # 0x4040
mulsd %xmm0, %xmm3
movsd 0x38(%rsp), %xmm4
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
subpd %xmm2, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
addsd %xmm4, %xmm1
divsd %xmm1, %xmm3
subsd %xmm3, %xmm0
movq %rbx, %rdi
callq 0x2230
leaq 0x1450(%rip), %rsi      # 0x408f
movq %rax, %rdi
callq 0x2160
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x30(%rsp), %rdi
callq 0x20b0
leaq 0x90(%rsp), %rdi
callq 0x20b0
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20b0
jmp 0x2c9d
jmp 0x2c9a
jmp 0x2c90
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x2ca2
movq %rax, %rbx
jmp 0x2ca7
movq %rax, %rbx
jmp 0x2cb1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x30(%rsp), %rdi
callq 0x20b0
leaq 0x90(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
movq 0x10(%rdi), %r12
subq 0x8(%rdi), %r12
movq %rdx, %rbx
movl 0x18(%rdx), %eax
cvtsi2sd %rax, %xmm0
movq %rsi, %r15
sqrtsd %xmm0, %xmm0
mulsd 0x8(%rdx), %xmm0
movsd 0x1aa6(%rip), %xmm1     # 0x4030
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdx)
callq 0x3190
movsd 0x1a90(%rip), %xmm6     # 0x4030
movsd (%r14), %xmm2
movapd 0x1a73(%rip), %xmm1     # 0x4020
xorpd %xmm2, %xmm1
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm6
movq 0x8(%r14), %rax
movq (%r15), %rcx
movabsq $0xffffffff0, %rdx      # imm = 0xFFFFFFFF0
andq %r12, %rdx
xorl %esi, %esi
xorpd %xmm0, %xmm0
cmpq %rsi, %rdx
je 0x263a
ucomisd %xmm0, %xmm6
movl (%rax,%rsi), %edi
movsd (%rcx,%rdi,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 0x261c
movsd 0x8(%rax,%rsi), %xmm5
mulsd %xmm1, %xmm5
addsd %xmm5, %xmm4
mulsd 0x10(%rbx), %xmm4
subsd %xmm4, %xmm2
ucomisd %xmm6, %xmm0
jbe 0x262f
mulsd 0x10(%rbx), %xmm3
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm2
movsd %xmm2, (%rcx,%rdi,8)
addq $0x10, %rsi
jmp 0x25d3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm6
jbe 0x2652
movsd 0x20(%rbx), %xmm1
addsd %xmm6, %xmm1
movsd %xmm1, 0x20(%rbx)
xorl %eax, %eax
ucomisd %xmm6, %xmm0
setae %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mattcha[P]sgd-svm/sgd_svm_train.cpp
// Function: train(Dataset&, Weight&, Param&)
int train(Dataset &dataset, Weight &weight, Param &param)
{
    uint32_t ins_num = dataset.ins_vec.size();

    for (uint32_t i_iter = 0; i_iter < param.iteration; ++i_iter) {
        param.right = 0;
        param.loss_hinge = 0;
        param.loss_l2 = 0;

        for (uint32_t i_ins = 0; i_ins < ins_num; ++i_ins) {
            ++ param.step;

            int r_idx = rand() % (ins_num - i_ins);
            Instance inst = dataset.ins_vec[i_ins + r_idx];
            dataset.ins_vec[i_ins + r_idx] = dataset.ins_vec[i_ins];
            dataset.ins_vec[i_ins] = inst;

            param.right += step_train(inst, weight, param);
        }
        fprintf(stderr, "iter : %-5u   accurate : %-8f  hinge loss : %-8f   l2 loss : %-8f\n", 
                i_iter, param.right*100.0/ins_num, param.loss_hinge/ins_num, param.loss_l2/ins_num);
    }

    fprintf(stderr, "finish training\n");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r12
movq 0x8(%rdi), %rax
movq %rdi, -0x30(%rbp)
subq (%rdi), %rax
movq %rsi, -0x60(%rbp)
movabsq $0x1fffffffe0, %rcx     # imm = 0x1FFFFFFFE0
andq %rax, %rcx
movq %rcx, -0x70(%rbp)
shrq $0x5, %rax
leaq 0x20(%rdx), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x40(%rbp)
xorl %ebx, %ebx
leaq -0x90(%rbp), %r14
movq %rdx, -0x68(%rbp)
cmpl (%r12), %ebx
jae 0x27dc
movq %rbx, -0x58(%rbp)
movq -0x48(%rbp), %rax
andl $0x0, 0x10(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq -0x50(%rbp), %rax
movl %eax, %r15d
xorl %r13d, %r13d
movq $0x0, -0x38(%rbp)
cmpq %r13, -0x70(%rbp)
je 0x2786
incl 0x18(%r12)
callq 0x2030
xorl %edx, %edx
movl %r15d, %ebx
divl %r15d
movq -0x38(%rbp), %rax
leal (%rax,%rdx), %r12d
shlq $0x5, %r12
movq -0x30(%rbp), %r15
movq (%r15), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x2a94
movq (%r15), %rax
leaq (%rax,%r13), %rsi
addq %rax, %r12
movq %r12, %rdi
movq -0x68(%rbp), %r12
callq 0x2aae
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x2aae
movq %r14, %rdi
movq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x2555
addl %eax, 0x30(%r12)
leaq -0x88(%rbp), %rdi
callq 0x2ae4
incq -0x38(%rbp)
addq $0x20, %r13
movl %ebx, %r15d
decl %r15d
jmp 0x26f1
movq 0x384b(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
movl 0x30(%r12), %eax
cvtsi2sd %rax, %xmm0
mulsd 0x1896(%rip), %xmm0     # 0x4038
movsd -0x40(%rbp), %xmm3
divsd %xmm3, %xmm0
movsd 0x20(%r12), %xmm1
movsd 0x28(%r12), %xmm2
divsd %xmm3, %xmm1
divsd %xmm3, %xmm2
leaq 0x18e1(%rip), %rsi      # 0x40a9
movq -0x58(%rbp), %rbx
movl %ebx, %edx
movb $0x3, %al
callq 0x2160
incl %ebx
jmp 0x26c1
movq 0x37f5(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x18ff(%rip), %rdi      # 0x40ec
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x2200
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2ae4
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
jne 0x2851
movq 0x379e(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x18b9(%rip), %rdi      # 0x40fd
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x2200
jmp 0x2886
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x18b0(%rip), %rsi      # 0x4111
callq 0x2120
testq %rax, %rax
jne 0x288e
movq 0x3766(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x1897(%rip), %rsi      # 0x4113
movq %r12, %rdx
xorl %eax, %eax
callq 0x2160
pushq $-0x1
popq %rax
jmp 0x2917
movq %rax, %r14
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x3, %r12
movsd 0x8(%r15), %xmm0
movl (%r15), %edx
leaq 0x1882(%rip), %rsi      # 0x412e
movq %rax, %rdi
movl %r12d, %ecx
movb $0x1, %al
callq 0x2160
movl %r12d, %r13d
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
leaq 0x186e(%rip), %r12      # 0x4138
cmpq %r15, %r13
je 0x28f9
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0x28e0
jnp 0x28f4
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
movb $0x1, %al
callq 0x2160
xorpd %xmm1, %xmm1
incq %r15
jmp 0x28ca
movq 0x36d8(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x1835(%rip), %rdi      # 0x413f
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x2200
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, -0x40(%rbp)
movaps %xmm0, -0x30(%rbp)
andq $0x0, -0x20(%rbp)
cmpl $0x5, %edi
jne 0x29dc
movq 0x8(%rbx), %rdi
callq 0x2190
movl %eax, -0x88(%rbp)
movq 0x10(%rbx), %rdi
callq 0x2140
movsd %xmm0, -0x80(%rbp)
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r14
andl $0x0, -0x70(%rbp)
leaq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x237c
testl %eax, %eax
jne 0x29fb
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x2664
leaq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %r14, %rdi
callq 0x2820
xorl %ebx, %ebx
testl %eax, %eax
jne 0x2a19
leaq -0x30(%rbp), %rdi
callq 0x2cf0
leaq -0x50(%rbp), %rdi
callq 0x2d2e
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x35f5(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x1760(%rip), %rsi      # 0x4150
xorl %eax, %eax
callq 0x2160
pushq $0x1
jmp 0x2a37
movq 0x35d6(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
movq 0x8(%rbx), %rdx
leaq 0x1771(%rip), %rsi      # 0x4181
xorl %eax, %eax
callq 0x2160
jmp 0x2a35
movq 0x35b8(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x176c(%rip), %rdi      # 0x4196
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x2200
pushq $-0x1
popq %rbx
jmp 0x29bc
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2cf0
leaq -0x50(%rbp), %rdi
callq 0x2d2e
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mattcha[P]sgd-svm/sgd_svm.cpp
// Function: inner_product(Instance const&, Weight const&)
double inner_product(const Instance &instance, const Weight &weight)
{
    uint32_t fea_size = instance.f_vec.size();
    double product = 0.0;

    for (uint32_t i = 0; i < fea_size; ++i) {
        const Feature &fea = instance.f_vec[i];
        product += fea.val * weight.w_vec[fea.idx];
    }

    return product;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
subq %rax, %rdi
movq (%rsi), %rcx
movabsq $0xffffffff0, %rdx      # imm = 0xFFFFFFFF0
andq %rdi, %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x31d2
movsd 0x8(%rax,%rsi), %xmm1
movl (%rax,%rsi), %edi
mulsd (%rcx,%rdi,8), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rsi
jmp 0x31b5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mattcha[P]sgd-svm/sgd_svm.cpp
// Function: load_line(char const*, Instance&, unsigned int&)
int load_line(
        const char* line,
        Instance &instance,
        uint32_t &max_feature)
{
    double label;
    uint32_t fea_idx;
    double fea_val;

    stringstream ss(line);
    string field;
    if (getline(ss, field, ' ')) 
        label = atof(field.c_str());    
    else {
        fprintf(stderr, "read label fail [%s]\n",
                field.c_str());
        return -1;
    }
    instance.y_label = label;
    //cout << label << " ";

    while (true) {
        if (getline(ss, field, ':')) {
            fea_idx = atoi(field.c_str());
            //cout << fea_idx << ":";
        }
        else
            break;

        if (fea_idx > max_feature)
            max_feature = fea_idx;

        if (getline(ss, field, ' ')) {
            fea_val = atof(field.c_str());
            //cout << fea_val << " ";
        }
        else
            break;

        Feature fea;
        fea.idx = fea_idx;
        fea.val = fea_val;
        instance.f_vec.push_back(fea);
    }

    //cout << endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x3364
leaq -0x1e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
pushq $0x18
popq %rdx
callq 0x21a0
leaq -0x50(%rbp), %rdi
callq 0x2080
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x32e2
leaq -0x50(%rbp), %r15
movq (%r15), %rdi
callq 0x2140
movsd %xmm0, (%rbx)
addq $0x8, %rbx
leaq -0x1e8(%rbp), %r12
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rsi
pushq $0x3a
popq %rdx
callq 0x21f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3302
movq -0x50(%rbp), %rdi
callq 0x2190
movl %eax, %r14d
movq -0x30(%rbp), %rax
cmpl (%rax), %r14d
jbe 0x32a6
movq -0x30(%rbp), %rax
movl %r14d, (%rax)
movq %r12, %rdi
movq %r15, %rsi
pushq $0x20
popq %rdx
callq 0x21f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3302
movq -0x50(%rbp), %rdi
callq 0x2140
movl %r14d, -0x60(%rbp)
movsd %xmm0, -0x58(%rbp)
movq %rbx, %rdi
leaq -0x60(%rbp), %rsi
callq 0x33a0
jmp 0x326e
movq 0x2cef(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
movq -0x50(%rbp), %rdx
leaq 0xeca(%rip), %rsi       # 0x41c1
xorl %eax, %eax
callq 0x2160
pushq $-0x1
popq %r13
leaq -0x50(%rbp), %rdi
callq 0x2080
leaq -0x1e8(%rbp), %rdi
callq 0x20b0
movl %r13d, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3343
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
jmp 0x335b
movq %rax, %rbx
jmp 0x335b
jmp 0x3343
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
leaq -0x1e8(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cvttss2si 0x8(%rdi), %esi
movq 0x30(%rdi), %rdi
cvttss2si 0xc(%rbx), %edx
xorl %ecx, %ecx
callq 0x3662
movups 0x18(%rbx), %xmm3
movups 0x1c(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd 0x10(%rbx), %xmm2
shufps $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
mulps %xmm2, %xmm3
addps %xmm1, %xmm3
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
mulps %xmm2, %xmm0
movaps %xmm3, %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movups %xmm1, 0x8(%rbx)
movss 0x1a45(%rip), %xmm1     # 0x4004
ucomiss %xmm3, %xmm1
jbe 0x25cd
movl $0x3f800000, 0x8(%rbx)  # imm = 0x3F800000
jmp 0x2613
movq 0x30(%rbx), %rdi
movaps %xmm3, (%rsp)
callq 0x33d6
movss 0x1a22(%rip), %xmm1     # 0x4004
cvtsi2ss %eax, %xmm0
movb $0x1, %bpl
movaps (%rsp), %xmm2
ucomiss %xmm0, %xmm2
jb 0x2626
movq 0x30(%rbx), %rdi
callq 0x33d6
movss 0x1a01(%rip), %xmm1     # 0x4004
decl %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x8(%rbx)
movss 0x10(%rbx), %xmm0
xorps 0x19f6(%rip), %xmm0     # 0x4010
mulss 0x20(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
xorl %ebp, %ebp
movss 0xc(%rbx), %xmm0
ucomiss %xmm0, %xmm1
ja 0x267d
movq 0x30(%rbx), %rdi
movss %xmm0, (%rsp)
callq 0x33d2
cvtsi2ss %eax, %xmm0
movss (%rsp), %xmm1
ucomiss %xmm0, %xmm1
jae 0x266e
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3662
testb %bpl, %bpl
je 0x26ad
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x30(%rbx), %rdi
callq 0x33d2
decl %eax
cvtsi2ss %eax, %xmm1
movss %xmm1, 0xc(%rbx)
movss 0x14(%rbx), %xmm0
xorps 0x1982(%rip), %xmm0     # 0x4010
mulss 0x20(%rbx), %xmm0
movss %xmm0, 0x14(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si %xmm1, %edx
movq %rbx, %rcx
callq 0x3662
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27a8
leaq 0x43f7(%rip), %rax      # 0x6c28
movq %rax, (%rbx)
movaps 0x1805(%rip), %xmm0     # 0x4040
movups %xmm0, 0x18(%rbx)
movq 0x476a(%rip), %rax      # 0x6fb0
movl 0x1f8(%rax), %eax
movl %eax, 0x2c(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26c6
movss %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
callq 0x2790
movss (%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26cc
movss %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
callq 0x2796
movss (%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rbx)
movq 0x38(%rbx), %rdi
callq 0x2790
mulss 0x4(%rsp), %xmm0
mulss 0x18(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movq 0x38(%rbx), %rdi
callq 0x2796
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 0x3662
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x280a
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27a8
leaq 0x42f9(%rip), %rax      # 0x6c28
movq %rax, (%rbx)
movaps 0x1707(%rip), %xmm0     # 0x4040
movups %xmm0, 0x18(%rbx)
movq 0x466c(%rip), %rax      # 0x6fb0
movl 0x1f8(%rax), %eax
movl %eax, 0x2c(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26c6
movss %xmm0, 0x14(%rsp)
movq 0x38(%rbx), %rdi
callq 0x2790
movss 0x14(%rsp), %xmm1
addss %xmm0, %xmm1
addss (%rsp), %xmm1
movss %xmm1, 0x8(%rbx)
movq 0x38(%rbx), %rdi
callq 0x26cc
movss %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
callq 0x2796
movss (%rsp), %xmm1
addss %xmm0, %xmm1
addss 0x10(%rsp), %xmm1
movss %xmm1, 0xc(%rbx)
movq 0x38(%rbx), %rdi
callq 0x2790
addss 0xc(%rsp), %xmm0
mulss 0x4(%rsp), %xmm0
mulss 0x18(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movq 0x38(%rbx), %rdi
callq 0x2796
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 0x3662
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x280a
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4571(%rip), %rax      # 0x6fb8
movl (%rax), %ebp
movq 0x30(%rdi), %rdi
callq 0x33d6
subl %eax, %ebp
pushq $0x2
popq %r15
movl %ebp, %eax
cltd
idivl %r15d
movl %eax, %ebp
movq 0x4541(%rip), %rax      # 0x6fa8
movl (%rax), %r14d
movq 0x30(%rbx), %rdi
callq 0x33d2
subl %eax, %r14d
movl %r14d, %eax
cltd
idivl %r15d
cvtsi2ss %eax, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
cvtsi2ss %ebp, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq 0x4535(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
movl 0x2c(%rbx), %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2070
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b00
leaq 0x411c(%rip), %rax      # 0x6cd8
movq %rax, (%rbx)
movd %ebp, %xmm0
movd %r14d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
unpcklpd 0x1499(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
movups %xmm0, 0x8(%rbx)
callq 0x3308
movq %rax, %rdi
callq 0x3304
cvtsi2ss %eax, %xmm0
divss 0x14ac(%rip), %xmm0     # 0x40a0
cvtss2sd %xmm0, %xmm0
addsd 0x14b0(%rip), %xmm0     # 0x40b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rbx)
callq 0x3308
movq %rax, %rdi
callq 0x3304
cvtsi2ss %eax, %xmm0
divss 0x147e(%rip), %xmm0     # 0x40a0
cvtss2sd %xmm0, %xmm0
addsd 0x148a(%rip), %xmm0     # 0x40b8
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rbx)
movq 0x4372(%rip), %rax      # 0x6fb0
movl 0xb8(%rax), %eax
movl %eax, 0x2c(%rbx)
movsd 0x1431(%rip), %xmm0     # 0x4080
movsd %xmm0, 0x20(%rbx)
andl $0x0, 0x54(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3662
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b68
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b4e
leaq 0x403f(%rip), %rax      # 0x6cd8
movq %rax, (%rbx)
movsd 0x13ec(%rip), %xmm0     # 0x4090
movsd %xmm0, 0x10(%rbx)
callq 0x3308
movq %rax, %rdi
callq 0x3304
cvtsi2ss %eax, %xmm0
divss 0x13e2(%rip), %xmm0     # 0x40a4
cvtss2sd %xmm0, %xmm0
addsd 0x13e2(%rip), %xmm0     # 0x40b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rbx)
callq 0x3308
movq %rax, %rdi
callq 0x3304
cvtsi2ss %eax, %xmm0
divss 0x13b4(%rip), %xmm0     # 0x40a4
cvtss2sd %xmm0, %xmm0
addsd 0x13bc(%rip), %xmm0     # 0x40b8
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rbx)
movq 0x42a4(%rip), %rax      # 0x6fb0
movl 0xb8(%rax), %eax
movl %eax, 0x2c(%rbx)
movsd 0x1363(%rip), %xmm0     # 0x4080
movsd %xmm0, 0x20(%rbx)
andl $0x0, 0x54(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x3662
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b68
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x41a5(%rip), %rax      # 0x6fb8
movl (%rax), %ebp
movq 0x30(%rdi), %rdi
callq 0x33d6
subl %eax, %ebp
pushq $0x2
popq %r15
movl %ebp, %eax
cltd
idivl %r15d
movl %eax, %ebp
movq 0x4175(%rip), %rax      # 0x6fa8
movl (%rax), %r14d
movq 0x30(%rbx), %rdi
callq 0x33d2
subl %eax, %r14d
movl %r14d, %eax
cltd
idivl %r15d
movl %eax, %r14d
movq 0x4185(%rip), %r15      # 0x6fd8
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x20b0
cvtsi2ss %r14d, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
cvtsi2ss %ebp, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq (%r15), %rdi
movl 0x2c(%rbx), %esi
callq 0x2070
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3fd3(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x2090
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
ja 0x303c
leaq 0x10bd(%rip), %rax      # 0x40dc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpl $0x0, 0x8(%rbx)
jne 0x308c
movq 0x18(%rbx), %rdi
movss 0x106e(%rip), %xmm1     # 0x40a8
jmp 0x309a
cmpl $0x20, %eax
je 0x304b
cmpl $0x1b, %eax
jne 0x308c
movb $0x0, (%rbx)
jmp 0x308c
cmpl $0x0, 0x8(%rbx)
jne 0x308c
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x38c8
cmpl $0x0, 0x8(%rbx)
jne 0x308c
movq 0x18(%rbx), %rdi
movss 0x1067(%rip), %xmm0     # 0x40d4
jmp 0x3081
cmpl $0x0, 0x8(%rbx)
jne 0x308c
movq 0x18(%rbx), %rdi
movss 0x1057(%rip), %xmm0     # 0x40d8
xorps %xmm1, %xmm1
jmp 0x309d
cmpl $0x0, 0x8(%rbx)
je 0x308e
popq %rbx
retq
movq 0x18(%rbx), %rdi
movss 0x1036(%rip), %xmm1     # 0x40d0
xorps %xmm0, %xmm0
popq %rbx
jmp 0x39a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0xc(%rdi)
callq 0x21e0
movq 0x3f0a(%rip), %rax      # 0x6fc8
movl $0xa, (%rax)
movq 0x3f0d(%rip), %r15      # 0x6fd8
movq (%r15), %rdi
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x20a0
movq (%r15), %rdi
movl %r14d, %esi
callq 0x20c0
xorl %edi, %edi
callq 0x20e0
callq 0x2160
callq 0x2050
pushq $0x6
popq %r15
movl %r14d, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2040
pushq $0x2
popq %rbp
movl %ebp, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2040
pushq $0x3
popq %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2040
pushq $0x4
popq %r14
movl %r14d, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2040
pushq $0x5
popq %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2040
movl %r15d, %edi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x33d6
cltd
idivl %ebp
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x33d2
leal (%rax,%rax,2), %eax
cltd
idivl %r14d
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x2fae
movl $0x3e8, %ebp            # imm = 0x3E8
cmpb $0x1, (%rbx)
jne 0x31da
movq %rbx, %rdi
callq 0x2ffa
movq %rbx, %rdi
callq 0x31ee
movq %rbx, %rdi
callq 0x31f8
callq 0x2200
movq %rbx, %rdi
callq 0x321c
movl $0x12c, %edi            # imm = 0x12C
callq 0x21d0
movl 0x3f8d(%rip), %ecx      # 0x7144
leal 0x136(%rcx), %eax
movl %eax, 0x3f81(%rip)      # 0x7144
cmpl $0x2b3, %ecx            # imm = 0x2B3
jl 0x317d
xorl %edx, %edx
divl %ebp
movl %edx, 0x3f6f(%rip)      # 0x7144
incl 0xc(%rbx)
jmp 0x317d
callq 0x2080
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2170