LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
leaq 0x5e(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2330
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x51e4(%rip), %rsi      # 0x8039
callq 0x2270
jmp 0x2e5c
leaq 0x5e(%rsp), %rdi
callq 0x21f0
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2180
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2340
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3800
testb $0x1, %al
jne 0x2ea3
jmp 0x2f1c
leaq 0x38(%rsp), %rdi
callq 0x3840
movb (%rax), %al
movb %al, 0x2f(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x2f(%rsp), %rsi
callq 0x3bc0
movq %rax, 0x8(%rsp)
jmp 0x2ec9
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x2250
jmp 0x2eda
jmp 0x2edc
leaq 0x38(%rsp), %rdi
callq 0x3940
jmp 0x2e8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5e(%rsp), %rdi
callq 0x21f0
jmp 0x2f3c
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x20f0
jmp 0x2f3c
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x2f32
movq 0x18(%rsp), %rdi
callq 0x20f0
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl %edx, 0x8(%rsp)
cmpl $0x3, 0x8(%rsp)
jle 0x2f9b
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movl 0x8(%rsp), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x50b5(%rip), %rsi      # 0x803c
callq 0x21a0
movq %rax, %rdi
movsbl 0xf(%rsp), %esi
callq 0x2220
jmp 0x2fcf
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x2fcd
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movsbl 0xf(%rsp), %esi
callq 0x2220
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2fa3
jmp 0x2fcf
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2120
movq 0x1c8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2200
movb (%rax), %al
movb %al, 0x3f(%rsp)
movl $0x1, 0x38(%rsp)
movl $0x1, 0x34(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1c8(%rsp), %rdi
callq 0x22b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x30e9
movq 0x1c8(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x2200
movsbl (%rax), %eax
movsbl 0x3f(%rsp), %ecx
cmpl %ecx, %eax
je 0x30cc
movsbl 0x3f(%rsp), %esi
movl 0x38(%rsp), %edx
leaq 0x40(%rsp), %rdi
callq 0x2f50
jmp 0x3090
movq 0x1c8(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x2200
movb (%rax), %al
movb %al, 0x3f(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0x30d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2130
jmp 0x3126
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x30d9
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x3035
movsbl 0x3f(%rsp), %esi
movl 0x38(%rsp), %edx
leaq 0x40(%rsp), %rdi
callq 0x2f50
jmp 0x30fe
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2190
jmp 0x310f
leaq 0x40(%rsp), %rdi
callq 0x2130
movq 0x18(%rsp), %rax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x28(%rsp), %rdi
callq 0x2320
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpb $0x0, 0x10(%rax)
jne 0x315f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3130
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3130
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3179
movq 0x8(%rsp), %rdi
callq 0x2170
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0x8(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
andb $0x1, %al
movb %al, 0xc7(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2620
movq 0x18(%rsp), %rdi
callq 0x2710
movq %rax, 0x20(%rsp)
jmp 0x31da
leaq 0x88(%rsp), %rdi
callq 0x3960
movq 0x20(%rsp), %rax
movq %rax, 0xb8(%rsp)
testb $0x1, 0xc7(%rsp)
je 0x3235
movq 0xb8(%rsp), %rdi
movl $0x1, %esi
callq 0x2a10
jmp 0x3235
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x3960
jmp 0x32d9
movq 0xb8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x2ac0
movq 0xb8(%rsp), %rdi
callq 0x3130
jmp 0x3256
movq 0xc8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x2e10
jmp 0x326f
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2fe0
jmp 0x3280
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x48(%rsp), %rdi
callq 0x3eb0
movq 0x10(%rsp), %rax
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x32cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x48(%rsp), %rdi
callq 0x3eb0
movq 0x80(%rsp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2b9f
movq 0x8456(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x4549(%rip), %rsi      # 0x70d5
movb $0x0, %al
callq 0x2220
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c9f
movq -0x10(%rbp), %rdi
leaq 0x453f(%rip), %rsi      # 0x70e9
callq 0x21b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2be2
movq 0x8417(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x451c(%rip), %rsi      # 0x70eb
movb $0x0, %al
callq 0x2220
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c9f
movq -0x18(%rbp), %rdi
callq 0x30f0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movl (%rax), %edx
movl -0x2c(%rbp), %ecx
leaq 0x44fb(%rip), %rsi      # 0x7106
movb $0x1, %al
callq 0x2220
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x2c80
movq -0x18(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x3110
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2c40
jp 0x2c40
jmp 0x2c75
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x3110
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %edx
movsd (%rax), %xmm0
leaq 0x44a2(%rip), %rsi      # 0x7110
movb $0x1, %al
callq 0x2220
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c19
movq 0x8351(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x4486(%rip), %rsi      # 0x7117
movb $0x0, %al
callq 0x2220
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2fb0
movl %eax, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x5ba2
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2ff0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x3110
movsd -0x38(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5b3f
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
callq 0x2c50
movq -0x30(%rbp), %rax
leaq 0x4eb2(%rip), %rcx      # 0x7c28
movq %rcx, (%rax)
movl $0x3f800347, 0x1c(%rax) # imm = 0x3F800347
movl $0x3dcccccd, 0x18(%rax) # imm = 0x3DCCCCCD
movl $0x0, 0x20(%rax)
movl $0x3f333333, 0x24(%rax) # imm = 0x3F333333
movq 0x5214(%rip), %rcx      # 0x7fb0
movl 0x1f8(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq 0x38(%rax), %rdi
callq 0x2990
movss %xmm0, -0x28(%rbp)
jmp 0x2db5
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2bd0
movss %xmm0, -0x34(%rbp)
jmp 0x2dc9
movq -0x30(%rbp), %rax
movss -0x34(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movq 0x38(%rax), %rdi
callq 0x29b0
movss %xmm0, -0x38(%rbp)
jmp 0x2df0
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2bf0
movss %xmm0, -0x3c(%rbp)
jmp 0x2e04
movq -0x30(%rbp), %rax
movss -0x3c(%rbp), %xmm1
movss -0x38(%rbp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rax)
movq 0x38(%rax), %rdi
callq 0x2bd0
movss %xmm0, -0x40(%rbp)
jmp 0x2e2b
movq -0x30(%rbp), %rax
movss -0x40(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm1, %xmm0
movss 0x18(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x10(%rax)
movq 0x38(%rax), %rdi
callq 0x2bf0
movss %xmm0, -0x44(%rbp)
jmp 0x2e5b
movq -0x30(%rbp), %rcx
movss -0x44(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm1, %xmm0
movss 0x18(%rcx), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rcx)
movq 0x30(%rcx), %rdi
cvttss2si 0x8(%rcx), %esi
cvttss2si 0xc(%rcx), %edx
callq 0x4670
jmp 0x2e90
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2cf0
movq -0x20(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm3, -0x20(%rbp)
movss %xmm4, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
callq 0x2c50
movq -0x40(%rbp), %rax
leaq 0x4d1e(%rip), %rcx      # 0x7c28
movq %rcx, (%rax)
movl $0x3f800347, 0x1c(%rax) # imm = 0x3F800347
movl $0x3dcccccd, 0x18(%rax) # imm = 0x3DCCCCCD
movl $0x0, 0x20(%rax)
movl $0x3f333333, 0x24(%rax) # imm = 0x3F333333
movq 0x5080(%rip), %rcx      # 0x7fb0
movl 0x1f8(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq 0x38(%rax), %rdi
callq 0x2990
movss %xmm0, -0x38(%rbp)
jmp 0x2f49
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2bd0
movss %xmm0, -0x44(%rbp)
jmp 0x2f5d
movq -0x40(%rbp), %rax
movss -0x44(%rbp), %xmm1
movss -0x38(%rbp), %xmm0
addss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movq 0x38(%rax), %rdi
callq 0x29b0
movss %xmm0, -0x48(%rbp)
jmp 0x2f8d
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2bf0
movss %xmm0, -0x4c(%rbp)
jmp 0x2fa1
movq -0x40(%rbp), %rax
movss -0x4c(%rbp), %xmm1
movss -0x48(%rbp), %xmm0
addss %xmm1, %xmm0
movss -0x1c(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rax)
movq 0x38(%rax), %rdi
callq 0x2bd0
movss %xmm0, -0x50(%rbp)
jmp 0x2fd1
movq -0x40(%rbp), %rax
movss -0x50(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
addss %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm1, %xmm0
movss 0x18(%rax), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x10(%rax)
movq 0x38(%rax), %rdi
callq 0x2bf0
movss %xmm0, -0x54(%rbp)
jmp 0x300a
movq -0x40(%rbp), %rcx
movss -0x54(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
addss %xmm1, %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm1, %xmm0
movss 0x18(%rcx), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rcx)
movq 0x30(%rcx), %rdi
cvttss2si 0x8(%rcx), %esi
cvttss2si 0xc(%rcx), %edx
callq 0x4670
jmp 0x3048
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2cf0
movq -0x30(%rbp), %rdi
callq 0x2210
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x4ead(%rip), %rcx      # 0x7fb8
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0x4280
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x4e70(%rip), %rcx      # 0x7fa8
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x30(%rax), %rdi
callq 0x4260
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
addss 0xc(%rax), %xmm0
cvttss2si %xmm0, %edi
cvtsi2ssl -0xc(%rbp), %xmm0
addss 0x8(%rax), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq -0x18(%rbp), %rax
movq 0x4e4e(%rip), %rcx      # 0x7fd8
movq (%rcx), %rdi
movl 0x2c(%rax), %esi
callq 0x2070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3240
movq -0x30(%rbp), %rax
leaq 0x48f8(%rip), %rcx      # 0x7cd8
movq %rcx, (%rax)
cvtsi2ssl -0xc(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
cvtsi2ssl -0x10(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movl $0x3e4ccccd, 0x10(%rax) # imm = 0x3E4CCCCD
movl $0x3f800000, 0x14(%rax) # imm = 0x3F800000
callq 0x40a0
movq %rax, -0x28(%rbp)
jmp 0x3410
movq -0x28(%rbp), %rdi
callq 0x4080
movl %eax, -0x34(%rbp)
jmp 0x341e
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
cvtsi2ss %ecx, %xmm0
movss 0x1c17(%rip), %xmm1     # 0x5048
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1c17(%rip), %xmm1     # 0x5058
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
callq 0x40a0
movq %rax, -0x40(%rbp)
jmp 0x3459
movq -0x40(%rbp), %rdi
callq 0x4080
movl %eax, -0x44(%rbp)
jmp 0x3467
movq -0x30(%rbp), %rcx
movl -0x44(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss 0x1bce(%rip), %xmm1     # 0x5048
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1bd6(%rip), %xmm1     # 0x5060
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rcx)
movq 0x4b12(%rip), %rax      # 0x7fb0
movl 0xb8(%rax), %eax
movl %eax, 0x2c(%rcx)
movl $0x3ecccccd, 0x20(%rcx) # imm = 0x3ECCCCCD
movl $0x3dcccccd, 0x24(%rcx) # imm = 0x3DCCCCCD
movl $0x0, 0x54(%rcx)
movq 0x30(%rcx), %rdi
cvttss2si 0x8(%rcx), %esi
cvttss2si 0xc(%rcx), %edx
callq 0x4670
jmp 0x34d1
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3330
movq -0x18(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x32b0
movq -0x28(%rbp), %rdi
leaq 0x47ac(%rip), %rax      # 0x7cd8
movq %rax, (%rdi)
movq -0x10(%rbp), %rsi
callq 0x3640
jmp 0x353a
movq -0x28(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x3f800000, 0x14(%rax) # imm = 0x3F800000
callq 0x40a0
movq %rax, -0x30(%rbp)
jmp 0x3557
movq -0x30(%rbp), %rdi
callq 0x4080
movl %eax, -0x34(%rbp)
jmp 0x3565
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
cvtsi2ss %ecx, %xmm0
movss 0x1ad4(%rip), %xmm1     # 0x504c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1ad0(%rip), %xmm1     # 0x5058
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
callq 0x40a0
movq %rax, -0x40(%rbp)
jmp 0x35a0
movq -0x40(%rbp), %rdi
callq 0x4080
movl %eax, -0x44(%rbp)
jmp 0x35ae
movq -0x28(%rbp), %rcx
movl -0x44(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss 0x1a8b(%rip), %xmm1     # 0x504c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1a8f(%rip), %xmm1     # 0x5060
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rcx)
movq 0x49cb(%rip), %rax      # 0x7fb0
movl 0xb8(%rax), %eax
movl %eax, 0x2c(%rcx)
movl $0x3ecccccd, 0x20(%rcx) # imm = 0x3ECCCCCD
movl $0x3dcccccd, 0x24(%rcx) # imm = 0x3DCCCCCD
movl $0x0, 0x54(%rcx)
movq 0x30(%rcx), %rdi
cvttss2si 0x8(%rcx), %esi
cvttss2si 0xc(%rcx), %edx
callq 0x4670
jmp 0x3618
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3330
movq -0x18(%rbp), %rdi
callq 0x2210
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x481d(%rip), %rcx      # 0x7fb8
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0x4280
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x47e0(%rip), %rcx      # 0x7fa8
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x30(%rax), %rdi
callq 0x4260
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movq 0x47e9(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x20b0
movq -0x18(%rbp), %rax
cvtsi2ssl -0x10(%rbp), %xmm0
addss 0xc(%rax), %xmm0
cvttss2si %xmm0, %edi
cvtsi2ssl -0xc(%rbp), %xmm0
addss 0x8(%rax), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq -0x18(%rbp), %rax
movq 0x47a8(%rip), %rcx      # 0x7fd8
movq (%rcx), %rdi
movl 0x2c(%rax), %esi
callq 0x2070
movq 0x4796(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x44dd(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
callq 0x2090
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1b, %eax
je 0x3b58
jmp 0x3b13
movl -0x10(%rbp), %eax
subl $0x20, %eax
je 0x3bf7
jmp 0x3b21
movl -0x10(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0x3bd3
jmp 0x3b31
movl -0x10(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0x3baf
jmp 0x3b3d
movl -0x10(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x3b8b
jmp 0x3b49
movl -0x10(%rbp), %eax
subl $0x105, %eax            # imm = 0x105
je 0x3b64
jmp 0x3c10
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0x3c10
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3b86
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movss 0x1502(%rip), %xmm0     # 0x5080
xorps %xmm1, %xmm1
callq 0x4c70
jmp 0x3c10
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3bad
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movss 0x14d7(%rip), %xmm0     # 0x507c
xorps %xmm1, %xmm1
callq 0x4c70
jmp 0x3c10
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3bd1
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
xorps %xmm0, %xmm0
movss 0x14ac(%rip), %xmm1     # 0x5078
callq 0x4c70
jmp 0x3c10
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3bf5
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
xorps %xmm0, %xmm0
movss 0x1460(%rip), %xmm1     # 0x5050
callq 0x4c70
jmp 0x3c10
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x3c0e
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4b00
jmp 0x3c10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0xc(%rax)
callq 0x21e0
movq 0x4381(%rip), %rax      # 0x7fc8
movl $0xa, (%rax)
movq 0x4384(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movl $0x1, %esi
callq 0x20a0
movq 0x4370(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movl $0x1, %esi
callq 0x20c0
xorl %edi, %edi
callq 0x20e0
callq 0x2160
callq 0x3d60
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4280
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x10(%rax), %rdi
callq 0x4260
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
imull $0x3, %eax, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %edx
callq 0x3a70
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
je 0x3d42
movq -0x18(%rbp), %rdi
callq 0x3ae0
movq -0x18(%rbp), %rdi
callq 0x3dd0
movq -0x18(%rbp), %rdi
callq 0x3df0
callq 0x2200
movq -0x18(%rbp), %rdi
callq 0x3e30
movl $0x12c, %edi            # imm = 0x12C
callq 0x21d0
movl 0x443c(%rip), %eax      # 0x8144
addl $0x136, %eax            # imm = 0x136
movl %eax, 0x4431(%rip)      # 0x8144
cmpl $0x3e8, 0x4427(%rip)    # imm = 0x3E8
jle 0x3d40
movl 0x441f(%rip), %eax      # 0x8144
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movl %edx, 0x440d(%rip)      # 0x8144
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x3cc6
callq 0x2080
callq 0x2170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kube[P]gradius/Game.cpp
// Function: initColors()
static void initColors() {
  start_color();
  init_pair(1, COLOR_CYAN, COLOR_BLACK);
  init_pair(2, COLOR_CYAN, COLOR_BLACK);
  init_pair(3, COLOR_RED, COLOR_BLACK);
  init_pair(4, COLOR_CYAN, COLOR_BLACK);
  init_pair(5, COLOR_CYAN, COLOR_BLACK);
  init_pair(6, COLOR_CYAN, COLOR_BLACK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x2040
popq %rbp
retq
nop
// File: kube[P]gradius/Game.cpp
// Function: Game::draw()
void  Game::draw() {
  _world.draw();

  _drawScore();

  if (_gameOver)
    _drawGameOver();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x10(%rax), %rdi
callq 0x4290
movq -0x10(%rbp), %rdi
callq 0x3910
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x3e29
movq -0x10(%rbp), %rdi
callq 0x3960
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0xc(%rax), %ecx
subl 0x42fb(%rip), %ecx      # 0x8148
movl %ecx, -0x18(%rbp)
movl 0xc(%rax), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl $0x7d0, %edi            # imm = 0x7D0
subl %eax, %edi
movl $0x12c, %esi            # imm = 0x12C
callq 0x4020
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jle 0x3f18
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x42c2(%rip)      # 0x8148
movl $0x58, %edi
callq 0x2110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rdi
callq 0x4280
movl %eax, -0x24(%rbp)
jmp 0x3ea9
callq 0x2060
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movl -0x24(%rbp), %eax
movslq %ecx, %rdx
imulq $0x51eb851f, %rdx, %rdx # imm = 0x51EB851F
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x25, %rdx
addl %esi, %edx
imull $0x64, %edx, %edx
subl %edx, %ecx
imull %ecx, %eax
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x25, %rcx
movl %ecx, %esi
addl %eax, %esi
movl $0x1, %edx
callq 0x33b0
jmp 0x3efa
jmp 0x3f18
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x58, %esi
callq 0x2130
jmp 0x3f1e
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2210
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x41bf
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x41af
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x417c
jmp 0x41b1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x412a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2150
movq -0x20(%rbp), %rcx
movq 0x3d04(%rip), %rax      # 0x7fb8
movl (%rax), %eax
subl (%rcx), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, -0xc(%rbp)
movq 0x3cde(%rip), %rax      # 0x7fa8
movl (%rax), %eax
subl 0x4(%rcx), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl (%rax), %edx
movl 0x4(%rax), %ecx
callq 0x4370
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x435c
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x434f
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x45a0
cmpq $0x0, %rax
je 0x4342
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x45a0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x4344
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4309
jmp 0x4351
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x42f7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x4667
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x465a
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x45a0
cmpq $0x0, %rax
je 0x464d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x45a0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x45a0
movq %rax, %rdi
callq 0x2730
jmp 0x464f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x45fd
jmp 0x465c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x45eb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x46b1
cmpl $0x0, -0x10(%rbp)
jl 0x46b1
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x46b1
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0x46c0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x4746
cmpq $0x0, -0x18(%rbp)
jne 0x46e5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x4746
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x472a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x4746
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x64, %edx
movss 0x8c7(%rip), %xmm0      # 0x5038
xorps %xmm1, %xmm1
movss 0x938(%rip), %xmm2      # 0x50b4
movl $0x35, %ecx
movl %edx, %esi
callq 0x2ab0
movq -0x20(%rbp), %rcx
leaq 0x359d(%rip), %rax      # 0x7d30
movq %rax, (%rcx)
movl $0x3f7f3b64, 0x1c(%rcx) # imm = 0x3F7F3B64
movl $0x3d75c28f, 0x18(%rcx) # imm = 0x3D75C28F
movl $0x3f000000, 0x20(%rcx) # imm = 0x3F000000
movl $0x3fcccccd, 0x24(%rcx) # imm = 0x3FCCCCCD
movq 0x37f7(%rip), %rax      # 0x7fb0
movl 0xb4(%rax), %eax
movl %eax, 0x2c(%rcx)
movq 0x30(%rcx), %rdi
cvttss2si 0x8(%rcx), %esi
cvttss2si 0xc(%rcx), %edx
callq 0x4670
jmp 0x47d7
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2b70
movq -0x10(%rbp), %rdi
callq 0x2210
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x64, %edx
movss 0x811(%rip), %xmm0      # 0x5038
xorps %xmm1, %xmm1
movss 0x882(%rip), %xmm2      # 0x50b4
movl $0x35, %ecx
movl %edx, %esi
callq 0x2ab0
movq -0x28(%rbp), %rcx
leaq 0x34e7(%rip), %rax      # 0x7d30
movq %rax, (%rcx)
cvtsi2ssl -0xc(%rbp), %xmm0
movss %xmm0, 0x8(%rcx)
cvtsi2ssl -0x10(%rbp), %xmm0
movss %xmm0, 0xc(%rcx)
movl $0x3f7f3b64, 0x1c(%rcx) # imm = 0x3F7F3B64
movl $0x3d75c28f, 0x18(%rcx) # imm = 0x3D75C28F
movl $0x3f000000, 0x20(%rcx) # imm = 0x3F000000
movl $0x3fcccccd, 0x24(%rcx) # imm = 0x3FCCCCCD
movq 0x372d(%rip), %rax      # 0x7fb0
movl 0xb4(%rax), %eax
movl %eax, 0x2c(%rcx)
movq 0x30(%rcx), %rdi
cvttss2si 0x8(%rcx), %esi
cvttss2si 0xc(%rcx), %edx
callq 0x4670
jmp 0x48a1
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2b70
movq -0x18(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: kube[P]gradius/Player.cpp
// Function: Player::draw()
void  Player::draw() {
  int offsetX = (COLS - _world.getWidth()) / 2;
  int offsetY = (LINES - _world.getHeight()) / 2;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x35ed(%rip), %rcx      # 0x7fb8
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0x4280
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x35b0(%rip), %rcx      # 0x7fa8
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x30(%rax), %rdi
callq 0x4260
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movq 0x35b9(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x20b0
movq -0x18(%rbp), %rax
cvtsi2ssl -0x10(%rbp), %xmm0
addss 0xc(%rax), %xmm0
cvttss2si %xmm0, %edi
cvtsi2ssl -0xc(%rbp), %xmm0
addss 0x8(%rax), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq -0x18(%rbp), %rax
movq 0x3578(%rip), %rcx      # 0x7fd8
movq (%rcx), %rdi
movl 0x2c(%rax), %esi
callq 0x2070
movq 0x3566(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kube[P]gradius/Player.cpp
// Function: Player::moveImpulsion(float, float)
void  Player::moveImpulsion(float x, float y) {
  _dirX += x;
  _dirY += y;

  _dirX = abs(_dirX) > _maxSpeed ? _dirX / abs(_dirX) * _maxSpeed : _dirX;
  _dirY = abs(_dirY) > _maxSpeed ? _dirY / abs(_dirY) * _maxSpeed : _dirY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
addss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rax)
movss -0x10(%rbp), %xmm0
addss 0x14(%rax), %xmm0
movss %xmm0, 0x14(%rax)
movss 0x10(%rax), %xmm0
callq 0x4c30
movq -0x18(%rbp), %rax
ucomiss 0x24(%rax), %xmm0
jbe 0x4cf4
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movss 0x10(%rax), %xmm0
callq 0x4c30
movq -0x18(%rbp), %rax
movaps %xmm0, %xmm1
movss -0x20(%rbp), %xmm0
divss %xmm1, %xmm0
mulss 0x24(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x4d02
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x10(%rax)
movss 0x14(%rax), %xmm0
callq 0x4c30
movq -0x18(%rbp), %rax
ucomiss 0x24(%rax), %xmm0
jbe 0x4d58
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x14(%rax), %xmm0
callq 0x4c30
movq -0x18(%rbp), %rax
movaps %xmm0, %xmm1
movss -0x28(%rbp), %xmm0
divss %xmm1, %xmm0
mulss 0x24(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
jmp 0x4d66
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::Reference::report() const
void report() const
    {
        size_t refLen = mRefSeq.size();
        std::cerr << "Reference length: " << refLen << ".\n";
        std::cerr << "Dict size: " << mUniqueKmers.size() << " ("
                << 2 * (refLen - mK + 1) - mUniqueKmers.size()
                << " duplicate kmers).\n";
        std::cerr << "ORF length in codons: " << mWTCodons.size() << ".\n";
        std::cerr << "ORF segments:";
        char prefix = ' ';
        // leave final sentinel out of description
        for ( auto itr = mORF.begin(), end = mORF.end()-1; itr != end; ++itr )
        {
            std::cerr << prefix << itr->mBegin + 1 << ':' << itr->mEnd + 1;
            prefix = ',';
        }
        std::cerr << ".\n";
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x8, %rdi
callq 0x17530
movq %rax, 0x58(%rsp)
movq 0x27628(%rip), %rdi     # 0x2cff0
leaq 0x1bff2(%rip), %rsi     # 0x219c1
callq 0x4290
movq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x4070
movq %rax, %rdi
leaq 0x1c009(%rip), %rsi     # 0x219f4
callq 0x4290
movq 0x275f9(%rip), %rdi     # 0x2cff0
leaq 0x1bfd6(%rip), %rsi     # 0x219d4
callq 0x4290
movq 0x30(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x38, %rdi
callq 0xbfc0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4070
movq %rax, %rdi
leaq 0x1bfb3(%rip), %rsi     # 0x219e0
callq 0x4290
movq 0x30(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movl (%rdi), %ecx
subq %rcx, %rax
addq $0x1, %rax
shlq %rax
movq %rax, 0x18(%rsp)
addq $0x38, %rdi
callq 0xbfc0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
subq %rax, %rsi
callq 0x4070
movq %rax, %rdi
leaq 0x1bf6c(%rip), %rsi     # 0x219e3
callq 0x4290
movq 0x2756d(%rip), %rdi     # 0x2cff0
leaq 0x1bf6d(%rip), %rsi     # 0x219f7
callq 0x4290
movq 0x30(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x90, %rdi
callq 0x18600
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x4070
movq %rax, %rdi
leaq 0x1bf38(%rip), %rsi     # 0x219f4
callq 0x4290
movq 0x27528(%rip), %rdi     # 0x2cff0
leaq 0x1bf3f(%rip), %rsi     # 0x21a0e
callq 0x4290
movq 0x30(%rsp), %rdi
movb $0x20, 0x57(%rsp)
addq $0x78, %rdi
callq 0xa800
movq 0x30(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x78, %rdi
callq 0xa830
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0xbfd0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xc020
testb $0x1, %al
jne 0x5b28
jmp 0x5b99
movq 0x274c1(%rip), %rdi     # 0x2cff0
movsbl 0x57(%rsp), %esi
callq 0x42e0
movq %rax, (%rsp)
leaq 0x48(%rsp), %rdi
callq 0xc060
movq (%rsp), %rdi
movq (%rax), %rsi
addq $0x1, %rsi
callq 0x4070
movq %rax, %rdi
movl $0x3a, %esi
callq 0x42e0
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xc060
movq 0x8(%rsp), %rdi
movq 0x8(%rax), %rsi
addq $0x1, %rsi
callq 0x4070
movb $0x2c, 0x57(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xc070
jmp 0x5b13
movq 0x27450(%rip), %rdi     # 0x2cff0
leaq 0x1be4d(%rip), %rsi     # 0x219f4
callq 0x4290
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AminoAcidNamer::AminoAcidNamer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AminoAcidNamer( std::string const& codonTranslation )
    : mLabels(codonTranslation)
    { if ( codonTranslation.size() != NCODONS )
        FatalErr("Codon translation string must have exactly " << NCODONS
                    << " characters.");
      auto beg = mLabels.begin(), end = mLabels.end();
      std::sort(beg,end);
      mLabels.resize(size_t(std::unique(beg,end)-beg));
      end = mLabels.end();
      for ( size_t idx = 0; idx != NCODONS; ++idx )
        mCodonToAA[idx] = std::lower_bound(beg,end,codonTranslation[idx])-beg; }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0xa8(%rsp), %rsi
callq 0x4120
movq 0xa8(%rsp), %rdi
callq 0x41c0
cmpq $0x40, %rax
je 0x5c90
movq 0x273e1(%rip), %rdi     # 0x2cff0
leaq 0x1be06(%rip), %rsi     # 0x21a1c
callq 0x4290
movq %rax, 0x28(%rsp)
jmp 0x5c22
movq 0x28(%rsp), %rdi
movl $0x40, %esi
callq 0x4350
movq %rax, 0x20(%rsp)
jmp 0x5c38
movq 0x20(%rsp), %rdi
leaq 0x1b831(%rip), %rsi     # 0x21475
callq 0x4290
movq %rax, 0x18(%rsp)
jmp 0x5c50
movq 0x18(%rsp), %rdi
movq 0x2734c(%rip), %rsi     # 0x2cfa8
callq 0x42b0
jmp 0x5c63
movl $0x1, %edi
callq 0x42f0
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
callq 0x41b0
jmp 0x5e07
movq 0x30(%rsp), %rdi
callq 0x4230
movq 0x30(%rsp), %rdi
movq %rax, 0x90(%rsp)
callq 0x41a0
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x1a670
jmp 0x5ce5
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x1a6f0
movq %rax, 0x10(%rsp)
jmp 0x5d1f
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1a6b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4390
jmp 0x5d4a
movq 0x30(%rsp), %rdi
callq 0x41a0
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x88(%rsp)
movq $0x0, 0x50(%rsp)
cmpq $0x40, 0x50(%rsp)
je 0x5dff
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x42d0
movq %rax, %rdx
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1a740
movq %rax, (%rsp)
jmp 0x5dbf
movq (%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1a6b0
movq %rax, %rdx
movq 0x30(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x5d6f
addq $0xb8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0x4510
nopw %cs:(%rax,%rax)