LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x417d(%rip), %rax      # 0x6fb8
movl (%rax), %r14d
movq 0x30(%rdi), %rdi
callq 0x34c6
subl %eax, %r14d
movl %r14d, %ebp
shrl $0x1f, %ebp
addl %r14d, %ebp
sarl %ebp
movq 0x414c(%rip), %rax      # 0x6fa8
movl (%rax), %r14d
movq 0x30(%rbx), %rdi
callq 0x34c2
subl %eax, %r14d
movl %r14d, %r15d
shrl $0x1f, %r15d
addl %r14d, %r15d
sarl %r15d
movq 0x4159(%rip), %r14      # 0x6fd8
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x20b0
cvtsi2ss %r15d, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq (%r14), %rdi
movl 0x2c(%rbx), %esi
callq 0x2070
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f89(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x2090
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
ja 0x3086
leaq 0x1073(%rip), %rax      # 0x40dc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpl $0x0, 0x8(%rbx)
jne 0x30d6
movq 0x18(%rbx), %rdi
movss 0x1024(%rip), %xmm1     # 0x40a8
jmp 0x30e4
cmpl $0x20, %eax
je 0x3095
cmpl $0x1b, %eax
jne 0x30d6
movb $0x0, (%rbx)
jmp 0x30d6
cmpl $0x0, 0x8(%rbx)
jne 0x30d6
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x39e6
cmpl $0x0, 0x8(%rbx)
jne 0x30d6
movq 0x18(%rbx), %rdi
movss 0x101d(%rip), %xmm0     # 0x40d4
jmp 0x30cb
cmpl $0x0, 0x8(%rbx)
jne 0x30d6
movq 0x18(%rbx), %rdi
movss 0x100d(%rip), %xmm0     # 0x40d8
xorps %xmm1, %xmm1
jmp 0x30e7
cmpl $0x0, 0x8(%rbx)
je 0x30d8
popq %rbx
retq
movq 0x18(%rbx), %rdi
movss 0xfec(%rip), %xmm1      # 0x40d0
xorps %xmm0, %xmm0
popq %rbx
jmp 0x3ac6
nop
// File: /workspace/github_cpp_makefile_star2_O3/kube[P]gradius/Game.cpp
// Function: Game::run()
void  Game::run() {
  static int elapsedMicroSeconds = 0;
  _elapsedTime = 0;

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


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

  // playMusic();

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

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

  // stopMusic();

  echo();
  endwin();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
callq 0x21e0
movq 0x3ec0(%rip), %rax      # 0x6fc8
movl $0xa, (%rax)
movq 0x3ec3(%rip), %r14      # 0x6fd8
movq (%r14), %rdi
movl $0x1, %esi
callq 0x20a0
movq (%r14), %rdi
movl $0x1, %esi
callq 0x20c0
xorl %edi, %edi
callq 0x20e0
callq 0x2160
callq 0x2050
movl $0x1, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x2, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x3, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2040
movl $0x4, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x5, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movl $0x6, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2040
movq 0x10(%rbx), %rdi
callq 0x34c6
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movq 0x10(%rbx), %rdi
callq 0x34c2
leal (%rax,%rax,2), %ecx
leal (%rax,%rax,2), %edx
addl $0x3, %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x2, %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2ff4
cmpb $0x1, (%rbx)
jne 0x324e
movq %rbx, %rdi
callq 0x3044
movq 0x10(%rbx), %rdi
callq 0x36f8
movq %rbx, %rdi
callq 0x3266
callq 0x2200
movq %rbx, %rdi
callq 0x32e6
movl $0x12c, %edi            # imm = 0x12C
callq 0x21d0
movl 0x3f2d(%rip), %ecx      # 0x7144
leal 0x136(%rcx), %eax
movl %eax, 0x3f21(%rip)      # 0x7144
cmpl $0x2b3, %ecx            # imm = 0x2B3
jl 0x3249
movl %eax, %ecx
imulq $0x10624dd3, %rcx, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %eax
movl %eax, 0x3efe(%rip)      # 0x7144
incl 0xc(%rbx)
cmpb $0x0, (%rbx)
jne 0x31e1
callq 0x2080
popq %rbx
popq %r14
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/kube[P]gradius/Game.cpp
// Function: Game::draw()
void  Game::draw() {
  _world.draw();

  _drawScore();

  if (_gameOver)
    _drawGameOver();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x34ca
movq 0x3d3b(%rip), %r14      # 0x6fb8
movl (%r14), %eax
movl %eax, %esi
shrl $0x1f, %esi
addl %eax, %esi
sarl %esi
addl $-0x5, %esi
movl 0x4(%rbx), %ecx
leaq 0xe56(%rip), %rdx       # 0x40ec
movl $0x3, %edi
xorl %eax, %eax
callq 0x21b0
cmpl $0x0, 0x8(%rbx)
je 0x32de
movq 0x3cf9(%rip), %rax      # 0x6fa8
movl (%rax), %eax
movl %eax, %edi
shrl $0x1f, %edi
addl %eax, %edi
sarl %edi
movl (%r14), %eax
movl %eax, %esi
shrl $0x1f, %esi
addl %eax, %esi
sarl %esi
addl $-0x4, %esi
leaq 0xe26(%rip), %rdx       # 0x40f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/kube[P]gradius/Game.cpp
// Function: Game::popRandomEnemy()
void  Game::popRandomEnemy() {
  static int lastEnemyTimestamp = 0;

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

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

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

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

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

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

  drawRectangle(offsetX, offsetY, _width, _height);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2150
movq 0x3ad4(%rip), %rax      # 0x6fb8
movl (%rax), %eax
movl (%rbx), %r13d
movl 0x4(%rbx), %ebp
subl %r13d, %eax
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
movq 0x3aa5(%rip), %rax      # 0x6fa8
movl (%rax), %eax
subl %ebp, %eax
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
movq 0x3abd(%rip), %r15      # 0x6fd8
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x20b0
movq (%r15), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3554
movq (%r15), %rdi
movq 0x3a69(%rip), %rax      # 0x6fb0
movl 0x1e0(%rax), %esi
movl %ebp, %edx
callq 0x2180
movq (%r15), %rdi
leal (%r14,%r13), %edx
movl %r12d, %esi
movl %edx, 0x4(%rsp)
callq 0x2140
cmpl $-0x1, %eax
je 0x3583
movq (%r15), %rdi
movq 0x3a3a(%rip), %rax      # 0x6fb0
movl 0x1e0(%rax), %esi
movl %ebp, %edx
callq 0x2180
movq (%r15), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x35ae
movq (%r15), %rdi
movq 0x3a10(%rip), %rax      # 0x6fb0
movl 0x1c4(%rax), %esi
movl %r13d, %edx
callq 0x20f0
movq (%r15), %rdi
addl %r12d, %ebp
movl %ebp, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x35de
movq (%r15), %rdi
movq 0x39e3(%rip), %rax      # 0x6fb0
movl 0x1c4(%rax), %esi
incl %r13d
movl %r13d, %edx
callq 0x20f0
movq (%r15), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3606
movq (%r15), %rdi
movq 0x39b5(%rip), %rax      # 0x6fb0
movl 0x1b0(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl %r12d, %esi
movl 0x4(%rsp), %r12d
movl %r12d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3633
movq (%r15), %rdi
movq 0x3988(%rip), %rax      # 0x6fb0
movl 0x1ac(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x365a
movq (%r15), %rdi
movq 0x3961(%rip), %rax      # 0x6fb0
movl 0x1b4(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3681
movq (%r15), %rdi
movq 0x393a(%rip), %rax      # 0x6fb0
movl 0x1a8(%rax), %esi
callq 0x2070
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x21a0
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0x36d5
movl 0x4(%rbx), %eax
xorl %r14d, %r14d
testl %eax, %eax
jle 0x36ca
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0x36bd
movq (%rdi), %rax
callq *0x10(%rax)
movl 0x4(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x36a3
movl (%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x369c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x375b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
xorl %r14d, %r14d
testl %eax, %eax
jle 0x374b
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0x373e
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
callq 0x256c
movl 0x4(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x3713
movl (%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x370c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kube[P]gradius/World.cpp
// Function: World::setEntityAt(int, int, AGameEntity*)
void    World::setEntityAt(int x, int y, AGameEntity* entity) {
  if (x < 0 || y < 0 || x >= _width || y >= _height) {
    entity->collide();
    return;
  }  

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x8a5(%rip), %xmm0      # 0x4060
movss 0x959(%rip), %xmm2      # 0x411c
xorps %xmm1, %xmm1
movl $0x64, %esi
movl $0x64, %edx
movl $0x35, %ecx
callq 0x2708
leaq 0x354f(%rip), %rax      # 0x6d30
movq %rax, (%rbx)
movaps 0x945(%rip), %xmm0      # 0x4130
movups %xmm0, 0x18(%rbx)
movq 0x37ba(%rip), %rax      # 0x6fb0
movl 0xb4(%rax), %eax
movl %eax, 0x2c(%rbx)
cvttss2si 0x8(%rbx), %esi
movq 0x30(%rbx), %rdi
cvttss2si 0xc(%rbx), %edx
movq %rbx, %rcx
callq 0x375c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x278e
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/kube[P]gradius/Player.cpp
// Function: Player::Player(int, int)
Player::Player(int x, int y) :
  AShip(100, 100, 100, 0, -1, 53)
{
  _posX = x;
  _posY = y;

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movss 0x81c(%rip), %xmm0      # 0x4060
movss 0x8d0(%rip), %xmm2      # 0x411c
xorps %xmm1, %xmm1
movl $0x64, %esi
movl $0x64, %edx
movl $0x35, %ecx
callq 0x2708
leaq 0x34c6(%rip), %rax      # 0x6d30
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
movq %rax, (%rbx)
xorps %xmm1, %xmm1
cvtsi2ss %ebp, %xmm1
movss %xmm0, 0x8(%rbx)
movss %xmm1, 0xc(%rbx)
movaps 0x8a3(%rip), %xmm2      # 0x4130
movups %xmm2, 0x18(%rbx)
movq 0x3718(%rip), %rax      # 0x6fb0
movl 0xb4(%rax), %eax
movl %eax, 0x2c(%rbx)
movq 0x30(%rbx), %rdi
cvttss2si %xmm0, %esi
cvttss2si %xmm1, %edx
movq %rbx, %rcx
callq 0x375c
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x278e
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x369f(%rip), %rax      # 0x6fb8
movl (%rax), %r14d
movq 0x30(%rdi), %rdi
callq 0x34c6
subl %eax, %r14d
movl %r14d, %ebp
shrl $0x1f, %ebp
addl %r14d, %ebp
sarl %ebp
movq 0x366e(%rip), %rax      # 0x6fa8
movl (%rax), %r14d
movq 0x30(%rbx), %rdi
callq 0x34c2
subl %eax, %r14d
movl %r14d, %r15d
shrl $0x1f, %r15d
addl %r14d, %r15d
sarl %r15d
movq 0x367b(%rip), %r14      # 0x6fd8
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x20b0
cvtsi2ss %r15d, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq (%r14), %rdi
movl 0x2c(%rbx), %esi
callq 0x2070
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::seqFor[abi:cxx11](unsigned int)
std::string seqFor( Codon codon )
{
    std::string result;
    result.reserve(3);
    result.push_back("ACGT"[(codon >> 4) & 3]);
    result.push_back("ACGT"[(codon >> 2) & 3]);
    result.push_back("ACGT"[codon & 3]);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %r15
movl %esi, %r14d
movq %rdi, %rbx
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x3, %esi
callq 0x3300
movl $0x204, %eax            # imm = 0x204
leaq 0x577b(%rip), %r12      # 0xcb76
bextrl %eax, %r14d, %eax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x31a0
movl $0x202, %eax            # imm = 0x202
bextrl %eax, %r14d, %eax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x31a0
andl $0x3, %r14d
movsbl (%r14,%r12), %esi
movq %rbx, %rdi
callq 0x31a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rbx), %rdi
movq %rax, %r14
cmpq %r15, %rdi
je 0x7451
callq 0x31c0
movq %r14, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::Reference::findAlignment(std::vector<unsigned char, std::allocator<unsigned char>> const&) const
Alignment findAlignment( Sequence const& seq ) const
    {
        if ( seq.size() < mK )
            return Alignment();

        auto notFound = mUniqueKmers.end();
        for ( Kmer kmer(seq.begin()), end(seq.end()-mK+1); kmer != end; ++kmer )
        {
            auto itr = mUniqueKmers.find(kmer);
            if ( itr != notFound )
            {
                Offset refStart = itr->second.getOffset();
                Offset readStart = kmer - seq.begin();
                Offset backOff = std::min(refStart,readStart);
                refStart -= backOff;
                readStart -= backOff;
                Offset len = std::min(mRefSeq.size()-refStart,
                                        seq.size()-readStart);
                bool isRC = itr->second.isRC();
                if ( isRC )
                {
                    refStart = mRefSeq.size()-refStart-len;
                    readStart = seq.size()-readStart-len;
                }
                return Alignment(refStart,refStart+len,readStart,isRC);
            }
        }
        return Alignment();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rsi), %eax
movq %rcx, %r13
subq %rdx, %rcx
cmpq %rax, %rcx
jae 0x803f
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x9(%rdi)
vmovups %xmm0, (%rdi)
jmp 0x815b
subq %rax, %r13
movq %rsi, 0x10(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
leaq 0x1(%r13), %rax
cmpq %rdx, %rax
je 0x80d9
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r12
movabsq $0x100000001b3, %r15    # imm = 0x100000001B3
movl 0x38(%rax), %r14d
movq 0x48(%rax), %rbx
leaq 0x38(%rax), %rbp
movabsq $-0x340d631b7bdddcdb, %rcx # imm = 0xCBF29CE484222325
testq %r14, %r14
je 0x80b1
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
xorl %eax, %eax
movzbl (%r12,%rax), %ecx
incq %rax
xorq %rdx, %rcx
imulq %r15, %rcx
movq %rcx, %rdx
cmpq %rax, %r14
jne 0x809a
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
movq %rbp, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x76b4
testq %rax, %rax
jne 0x80ed
leaq 0x1(%r12), %rax
cmpq %r13, %r12
movq %rax, %r12
jne 0x807f
movq 0x18(%rsp), %rax
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x9(%rax)
vmovups %xmm0, (%rax)
jmp 0x815b
movq 0x10(%rax), %rcx
subq 0x8(%rsp), %r12
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %r8
movb 0x18(%rax), %al
cmpq %rcx, %r12
movq 0x10(%rsi), %r10
movq %rcx, %rdx
movq %r8, %rdi
cmovbq %r12, %rdx
subq 0x8(%rsi), %r10
subq %rdx, %r12
subq %rdx, %rcx
subq %r12, %rdi
movq %r10, %rsi
subq %rcx, %rsi
cmpq %rsi, %rdi
cmovaeq %rsi, %rdi
leaq (%r12,%rdi), %r9
subq %rcx, %r10
subq %rdi, %r10
movq 0x18(%rsp), %rsi
subq %r9, %r8
testb %al, %al
cmoveq %rcx, %r10
cmoveq %r12, %r8
addq %r10, %rdi
movq %r10, (%rsi)
movq %rdi, 0x8(%rsi)
movq %r8, 0x10(%rsi)
movb %al, 0x18(%rsi)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::dumpNonAligner(char const*, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
void dumpNonAligner( char const* fileName, size_t readId,
                            Sequence const& seq, Quals const& quals )
    { if ( !mpJunkOS ) return;
      std::ostream& os = *mpJunkOS;
      os << '@' << fileName << ':' << readId << '\n';
      for ( Call call : seq ) os << charFor(call);
      os << "\n+\n";
      for ( Qual qual : quals ) os << (char)(qual+FASTQ_QUAL_OFFSET);
      os << '\n'; }

// Assembly:
testq %rdi, %rdi
je 0x82b4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbp
leaq 0x4(%rsp), %rsi
movl $0x1, %edx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movb $0x40, (%rsi)
callq 0x3210
movq %rax, %r13
testq %rbp, %rbp
je 0x81bf
movq %rbp, %rdi
callq 0x30e0
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x3210
jmp 0x81da
movq (%r13), %rax
movq %r13, %rdi
movq -0x18(%rax), %rax
movl 0x20(%r13,%rax), %esi
addq %rax, %rdi
orl $0x1, %esi
callq 0x3360
leaq 0x5(%rsp), %rsi
movl $0x1, %edx
movq %r13, %rdi
movb $0x3a, (%rsi)
callq 0x3210
movq %rax, %rdi
movq %r12, %rsi
callq 0x3130
leaq 0x6(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
movb $0xa, (%rsi)
callq 0x3210
movq (%r15), %r12
movq 0x8(%r15), %r13
cmpq %r13, %r12
je 0x824b
leaq 0x4b55(%rip), %rbp      # 0xcd77
leaq 0x2(%rsp), %r15
movzbl (%r12), %eax
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
movb (%rax,%rbp), %al
movb %al, 0x2(%rsp)
callq 0x3210
incq %r12
cmpq %r13, %r12
jne 0x8227
leaq 0x4b21(%rip), %rsi      # 0xcd73
movl $0x3, %edx
movq %rbx, %rdi
callq 0x3210
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x8291
leaq 0x3(%rsp), %r14
movb (%r15), %al
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
addb $0x21, %al
movb %al, 0x3(%rsp)
callq 0x3210
incq %r15
cmpq %r12, %r15
jne 0x8270
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
movb $0xa, (%rsi)
callq 0x3210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::processAlignment(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, (anonymous namespace)::Alignment const&)
void processAlignment( Sequence const& seq, Quals const& quals,
                                Alignment const& aln )
    {
        mNAlignedReads += 1;
        ReadReport readReport = findAlternateCodons(seq,quals,aln);
        if ( readReport.mNMismatches > mMaxSeqErrs ||
                readReport.mVariations.size() > 1 )
            readReport = findIndels(aln,seq,quals);
        if ( readReport.mNMismatches <= mMaxSeqErrs )
            processReport(readReport);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
incq 0x38(%rdi)
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x83d6
movq 0x10(%r13), %rax
movl 0xc(%rbx), %ecx
cmpq %rcx, %rax
ja 0x831b
movq 0x18(%rsp), %r13
movq 0x20(%rsp), %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
subq %r13, %rdx
sarq $0x3, %rdx
imulq %rdx, %rsi
cmpq $0x2, %rsi
jb 0x8384
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x853e
vmovups 0x40(%rsp), %xmm0
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
vmovaps %xmm0, (%rsp)
vmovdqu 0x58(%rsp), %xmm0
movq 0x18(%rsp), %rdi
vmovdqu %xmm0, 0x18(%rsp)
movq %rax, 0x28(%rsp)
testq %rdi, %rdi
je 0x8377
vmovdqa %xmm0, 0x30(%rsp)
callq 0x31c0
vmovdqa 0x30(%rsp), %xmm0
movq 0x10(%rsp), %rax
movl 0xc(%rbx), %ecx
vmovq %xmm0, %r13
cmpq %rcx, %rax
ja 0x8394
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9106
testq %r13, %r13
je 0x83ae
movq %r13, %rdi
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31c0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x83ce
callq 0x31c0
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::findAlternateCodons(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, (anonymous namespace)::Alignment const&)
ReadReport findAlternateCodons( Sequence const& seq,
                                    Quals const& quals,
                                    Alignment const& aln )
    {
        AlignmentScorer alignmentScorer(mRef,aln.getRefStart(),mMinQ);
        auto refItr(mRef.getRef().begin()+aln.getRefStart());
        auto refEnd(mRef.getRef().begin()+aln.getRefEnd());
        if ( !aln.isReadRC() )
        {
            auto readItr(seq.begin()+aln.getReadStart());
            auto qualItr(quals.begin()+aln.getReadStart());
            while ( refItr != refEnd )
            {
                alignmentScorer(*refItr,*readItr,*qualItr);
                ++refItr; ++readItr; ++qualItr;
            }
        }
        else
        {
            auto readItr(seq.rbegin()+aln.getReadStart());
            auto qualItr(quals.rbegin()+aln.getReadStart());
            while ( refItr != refEnd )
            {
                alignmentScorer(*refItr,complement(*readItr),*qualItr);
                ++refItr; ++readItr; ++qualItr;
            }
        }
        return alignmentScorer.getReport();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rcx, %r14
movq (%rsi), %rsi
movq (%r8), %rdx
movzbl 0x8(%r13), %ecx
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r8, %r12
callq 0x9270
movq (%r13), %rax
movq (%r12), %rbp
movq 0x8(%r12), %r15
movq 0x8(%rax), %r13
addq %rbp, %r13
cmpb $0x0, 0x18(%r12)
je 0x8484
subq %r15, %rbp
je 0x84c3
movq 0x10(%r12), %r15
movq 0x8(%r14), %r12
leaq 0x10(%rsp), %r14
notq %r15
addq %r15, %r12
addq 0x8(%rbx), %r15
xorl %ebx, %ebx
movb (%r15,%rbx), %al
movzbl (%r13), %esi
movl %eax, %ecx
xorb $0x3, %cl
cmpb $0x4, %al
movzbl %cl, %eax
movl $0x4, %ecx
cmovel %ecx, %eax
movzbl (%r12,%rbx), %ecx
movzbl %al, %edx
movq %r14, %rdi
callq 0x933c
incq %r13
decq %rbx
cmpq %rbx, %rbp
jne 0x844c
jmp 0x84c3
cmpq %r15, %rbp
je 0x84c3
movq %rbx, %rax
movq 0x10(%r12), %rbx
movq (%r14), %r12
subq %rbp, %r15
leaq 0x10(%rsp), %r14
xorl %ebp, %ebp
addq %rbx, %r12
addq (%rax), %rbx
movzbl (%rbx,%rbp), %edx
movzbl (%r13,%rbp), %esi
movzbl (%r12,%rbp), %ecx
movq %r14, %rdi
callq 0x933c
incq %rbp
cmpq %rbp, %r15
jne 0x84a4
leaq 0x70(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq -0x38(%rsi), %rdx
movq -0x10(%rsi), %rax
movq -0x8(%rsi), %rcx
subq -0x40(%rsi), %rdx
movq %rax, (%rdi)
sarq $0x2, %rdx
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
addq $0x18, %rdi
callq 0x956e
movq 0x70(%rsp), %rdi
addq $0x88, %rsp
testq %rdi, %rdi
je 0x8515
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8524
jmp 0x8524
movq 0x70(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x8536
callq 0x31c0
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AlignmentScorer::AlignmentScorer((anonymous namespace)::Reference const&, unsigned long, unsigned char)
AlignmentScorer( Reference const& ref, Offset refStart, Qual minQ )
    : mRefPos(refStart), mExonItr(ref.getORF().begin()), mNextExon{0,0},
      mWTBeg(ref.getORFWTCodons().begin()), mMinQ(minQ),
      mCodon(0), mPhase(0), mNCodonMismatches(0), mNHiQCalls(0),
      mFirstCodonCovered(0), mNMismatches(0)
    {
        while ( mExonItr->mEnd <= mRefPos )
        {
            mFirstCodonCovered += mExonItr->size();
            ++mExonItr;
        }
        mNextExon = *mExonItr;
        if ( mRefPos > mExonItr->mBegin )
            mFirstCodonCovered += mRefPos - mExonItr->mBegin;
        mPhase = mFirstCodonCovered % 3;
        mFirstCodonCovered = mFirstCodonCovered / 3;
        mWTItr = ref.getORFWTCodons().begin()+mFirstCodonCovered;
        mPlannedItr = ref.getPlannedMasks().begin()+mFirstCodonCovered;
        mCodon = *mWTItr >> ((3 - mPhase)*2);
    }

// Assembly:
movq %rdx, (%rdi)
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rdi), %rax
movq 0x78(%rsi), %r8
movq %r8, 0x8(%rdi)
vmovups %xmm0, 0x10(%rdi)
movq 0x90(%rsi), %r9
movq %r9, 0x20(%rdi)
vmovups %xmm0, 0x28(%rdi)
movb %cl, 0x38(%rdi)
vmovups %xmm0, 0x3c(%rdi)
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x70(%rdi)
xorl %ecx, %ecx
vmovups %ymm0, 0x50(%rdi)
movq 0x8(%r8), %r9
cmpq %rdx, %r9
ja 0x92d7
subq (%r8), %r9
addq %r9, %rcx
movq 0x18(%r8), %r9
addq $0x10, %r8
cmpq %rdx, %r9
jbe 0x92bc
movq %rcx, 0x50(%rdi)
movq %r8, 0x8(%rdi)
vmovups (%r8), %xmm0
vmovups %xmm0, (%rax)
xorl %eax, %eax
subq (%r8), %rdx
cmovaeq %rdx, %rax
addq %rcx, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rax, %rdx
mulxq %rcx, %rcx, %rcx
shrq %rcx
leal (%rcx,%rcx,2), %edx
subl %edx, %eax
movl %eax, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
addl %eax, %eax
movq 0x90(%rsi), %rdx
xorb $0x6, %al
leaq (%rdx,%rcx,4), %rdx
shlq $0x3, %rcx
movq %rdx, 0x28(%rdi)
addq 0xa8(%rsi), %rcx
movq %rcx, 0x30(%rdi)
shrxl %eax, (%rdx), %eax
movl %eax, 0x3c(%rdi)
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AlignmentScorer::operator()(unsigned char, unsigned char, unsigned char)
void operator()( Call wtCall, Call call, Qual qual )
    {
        if ( mRefPos == mNextExon.mEnd )
            mNextExon = *++mExonItr;
        if ( mRefPos++ < mNextExon.mBegin )
        {
            if ( wtCall != call && qual >= mMinQ )
                mNMismatches += 1;
        }
        else
        {
            if ( qual >= mMinQ )
            {
                mNHiQCalls += 1;
                if ( wtCall != call )
                {
                    mNMismatches += 1;
                    mNCodonMismatches += 1;
                }
            }
            mCodon = (mCodon << 2) | call;
            if ( ++mPhase == 3 )
            {
                if ( mCodon != *mWTItr &&
                     ((1ul << mCodon) & *mPlannedItr) &&
                     mNHiQCalls == 3 )
                {
                    if ( mVariations.empty() )
                        mNMismatches -= mNCodonMismatches;
                    mVariations.push_back(
                        Variation{VariationType::ALTERNATE_CODON,
                                   Offset(mWTItr-mWTBeg),
                                   mCodon} );
                }
                mCodon = 0;
                mPhase = 0;
                mNCodonMismatches = 0;
                mNHiQCalls = 0;
                ++mWTItr;
                ++mPlannedItr;
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq %rdi, %rbx
cmpq 0x18(%rdi), %rax
jne 0x9369
movq 0x8(%rbx), %r8
leaq 0x10(%rbx), %rdi
leaq 0x10(%r8), %r9
movq %r9, 0x8(%rbx)
vmovups 0x10(%r8), %xmm0
vmovups %xmm0, (%rdi)
leaq 0x1(%rax), %rdi
movq %rdi, (%rbx)
cmpq 0x10(%rbx), %rax
jae 0x9391
cmpb %dl, %sil
je 0x942b
cmpb %cl, 0x38(%rbx)
ja 0x942b
incq 0x58(%rbx)
jmp 0x942b
cmpb %cl, 0x38(%rbx)
ja 0x93a5
incl 0x48(%rbx)
cmpb %dl, %sil
je 0x93a5
incq 0x58(%rbx)
incl 0x44(%rbx)
movl 0x3c(%rbx), %eax
movl 0x40(%rbx), %esi
movzbl %dl, %ecx
shll $0x2, %eax
incl %esi
orl %eax, %ecx
movl %ecx, 0x3c(%rbx)
movl %esi, 0x40(%rbx)
cmpl $0x3, %esi
jne 0x942b
movq 0x28(%rbx), %rax
leaq 0x3c(%rbx), %r14
cmpl (%rax), %ecx
je 0x9415
movq 0x30(%rbx), %rdx
movq (%rdx), %rdx
btq %rcx, %rdx
jae 0x9415
cmpl $0x3, 0x48(%rbx)
jne 0x9415
leaq 0x60(%rbx), %rdi
movq 0x60(%rbx), %rdx
cmpq 0x68(%rbx), %rdx
jne 0x93f4
movl 0x44(%rbx), %edx
subq %rdx, 0x58(%rbx)
movq %rsp, %rsi
movl $0x0, (%rsi)
subq 0x20(%rbx), %rax
sarq $0x2, %rax
movq %rax, 0x8(%rsi)
movl %ecx, 0x10(%rsi)
callq 0x9434
movq 0x28(%rbx), %rax
vxorps %xmm0, %xmm0, %xmm0
addq $0x4, %rax
vmovups %xmm0, (%r14)
movq %rax, 0x28(%rbx)
addq $0x8, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AminoAcidNamer::getAACounts(unsigned long const*, std::vector<unsigned long, std::allocator<unsigned long>>*) const
void getAACounts( size_t const* codonCounts,
                            std::vector<size_t>* pAACounts ) const
    { std::vector<size_t>& aaCounts = *pAACounts;
      aaCounts.clear(); aaCounts.resize(mLabels.size());
      for ( size_t idx : mCodonToAA )
          aaCounts[idx] += *codonCounts++; }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdx), %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rax, 0x8(%rdx)
je 0x9d69
movq %rax, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xb600
movq (%r15), %rax
xorl %ecx, %ecx
movq 0x20(%r14,%rcx), %rdx
movq (%rbx,%rcx), %rsi
addq $0x8, %rcx
addq %rsi, (%rax,%rdx,8)
cmpq $0x200, %rcx            # imm = 0x200
jne 0x9d7a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/comptotherescue[P]Fibonacci-Heap/keywordcounter.cpp
// Function: Fibops::Insert(int)
Fib* Insert(int a_ival)
	{
		Fib *node = new Fib(a_ival);
		
		if (m_pMax != NULL)
		{
			if (m_pMax->m_pLeftsib == m_pMax) {
				m_pMax->m_pLeftsib = node;
				node->m_pRightsib = m_pMax;
				node->m_pLeftsib = m_pMax;
				m_pMax->m_pRightsib = node;
			}
			else {
				m_pMax->m_pRightsib->m_pLeftsib = node;
				node->m_pRightsib = m_pMax->m_pRightsib;
				node->m_pLeftsib = m_pMax;
				m_pMax->m_pRightsib = node;
			}
			if (m_pMax->m_iData < a_ival) {
				m_pMax = node;
			}
		}
		else
		{
			m_pMax = node;
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x30, %edi
callq 0x2160
movl $0x0, (%rax)
movl %r14d, 0x4(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x2c53
cmpq %rcx, 0x10(%rcx)
je 0x2c3d
movq 0x18(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq %rdx, 0x18(%rax)
jmp 0x2c45
movq %rax, 0x10(%rcx)
movq %rcx, 0x18(%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x18(%rcx)
cmpl %r14d, 0x4(%rcx)
jge 0x2c56
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/comptotherescue[P]Fibonacci-Heap/keywordcounter.cpp
// Function: Fibops::IncreaseKey(Fib*, int)
void IncreaseKey(Fib *key, int a_iVal)
	{
		Fib* k;
		key->m_iData += a_iVal;
		//Check if the value is greater than it's parent
		if (NULL == key->m_pParent)
		{
			if (m_pMax->m_iData < key->m_iData)
			{
				m_pMax = key;
			}
			return;
		}
		if (key->m_pParent->m_iData < key->m_iData)
		{
			do
			{
				if (key->m_pRightsib == key)
				{ 
					key->m_pParent->m_pChild = NULL;
				}
				else
				{
					key->m_pParent->m_pChild = key->m_pRightsib;
					key->m_pLeftsib->m_pRightsib = key->m_pRightsib;
					key->m_pRightsib->m_pLeftsib = key->m_pLeftsib;
				}
				//Make childcut boolean true
				key->m_pParent->m_bChildcut = true;
				key->m_pParent->m_iDegree -= 1;
				m_pMax->m_pRightsib->m_pLeftsib = key;
				key->m_pRightsib = m_pMax->m_pRightsib;
				m_pMax->m_pRightsib = key;
				key->m_pLeftsib = m_pMax;
				if (m_pMax->m_iData < key->m_iData)
				{
					m_pMax = key;
				}
				k = key->m_pParent;
				key->m_pParent = NULL;
				key = k;
			} while (NULL != key->m_pParent && key->m_pParent->m_bChildcut == true); // check if parent's childcut is true
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addl 0x4(%rsi), %edx
movl %edx, 0x4(%rsi)
movq 0x20(%rsi), %r8
testq %r8, %r8
je 0x2ce7
cmpl %edx, 0x4(%r8)
jge 0x2cf2
movq (%rdi), %rax
movq %r8, %rcx
movq 0x18(%rsi), %rdx
cmpq %rsi, %rdx
je 0x2c9a
movq %rdx, 0x8(%rcx)
movq 0x10(%rsi), %r8
movq %rdx, 0x18(%r8)
movq 0x18(%rsi), %rdx
movq %r8, 0x10(%rdx)
jmp 0x2ca2
movq $0x0, 0x8(%rcx)
movb $0x1, 0x28(%rcx)
decl (%rcx)
movq 0x18(%rax), %rdx
movq %rsi, 0x10(%rdx)
movq %rdx, 0x18(%rsi)
movq %rsi, 0x18(%rax)
movq %rax, 0x10(%rsi)
movl 0x4(%rax), %edx
cmpl 0x4(%rsi), %edx
jge 0x2cca
movq %rsi, (%rdi)
movq %rsi, %rax
movq $0x0, 0x20(%rsi)
movq 0x20(%rcx), %r8
testq %r8, %r8
je 0x2cf2
cmpb $0x0, 0x28(%r8)
movq %rcx, %rsi
jne 0x2c78
jmp 0x2cf2
movq (%rdi), %rax
cmpl %edx, 0x4(%rax)
jge 0x2cf2
movq %rsi, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/src/casa.cpp
// Function: usage()
void usage(){
  std::cerr << "Usages: Skipping unknown option"  << std::endl;
  std::cerr << "Usage:  casa [-options] <PDBfile>" << std::endl;
  std::cerr << "Options: [-paramfile PARAMfile]" << std::endl;
  std::cerr << "         [-reffile REFfile]" << std::endl;
  std::cerr << "         [-sasafile SASAfile]" << std::endl;
  std::cerr << "         [-header]" << std::endl;
  std::cerr << "         [-predict]" << std::endl;
  std::cerr << "         [-cut Cutoff]" << std::endl;
  std::cerr << "         [-trj TRAJfile]" << std::endl;
  std::cerr << "         [-skip frames] [-start frame] [-stop frame]" << std::endl;  
  std::cerr << "         [-identification ID]" << std::endl;
  std::cerr << std::endl;
  exit(0);
}

// Assembly:
pushq %rbx
movq 0x3eb48c(%rip), %rbx    # 0x3efff0
leaq 0x364a5(%rip), %rsi     # 0x3b010
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364ae(%rip), %rsi     # 0x3b030
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364b9(%rip), %rsi     # 0x3b052
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364c2(%rip), %rsi     # 0x3b072
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364c7(%rip), %rsi     # 0x3b08e
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364ce(%rip), %rsi     # 0x3b0ac
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364ca(%rip), %rsi     # 0x3b0bf
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364c7(%rip), %rsi     # 0x3b0d3
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364c7(%rip), %rsi     # 0x3b0ea
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364c9(%rip), %rsi     # 0x3b103
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x364e7(%rip), %rsi     # 0x3b138
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4150
xorl %edi, %edi
callq 0x4360
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::Analyze()
Analyze::Analyze (){
  sel.clear();
  mol.clear();
  tdata.clear();
  fdata.clear();
  ndata=0;
  resel=false;
  ifile.clear();
  ofile.clear();
  verbose=false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3e91d1(%rip), %rax    # 0x3ef990
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x80(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x70(%rbx)
xorl %eax, %eax
movq %rax, 0x78(%rbx)
movb %al, 0x80(%rbx)
leaq 0xa0(%rbx), %rcx
movq %rcx, 0x90(%rbx)
movq %rax, 0x98(%rbx)
movb %al, 0xa0(%rbx)
xorl %esi, %esi
callq 0x127e2
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x6828
movq %rax, 0x28(%rbx)
movq 0x38(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x6836
movq %rax, 0x40(%rbx)
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x12834
movl $0x0, 0x68(%rbx)
xorl %eax, %eax
movb %al, 0x6c(%rbx)
movq %rax, 0x78(%rbx)
movq 0x70(%rbx), %rcx
movb %al, (%rcx)
movq %rax, 0x98(%rbx)
movq 0x90(%rbx), %rcx
movb %al, (%rcx)
movb %al, 0xb0(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::readTopology(Molecule*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Analyze::readTopology(Molecule* molin, std::string topin){
  if (topin.length() > 0){
    molin->readTopology(topin);
    molin->setMass();
    molin->setCharge();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdx)
je 0x6f94
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x24b7c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x24e54
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x25092
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::setupMolSel(Molecule*)
void Analyze::setupMolSel(Molecule* molin){
  Molecule* tmpmol;

  molin->select(this->getSel(0));
  tmpmol=molin->copy();
  this->addMol(tmpmol);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6e8c
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x255d4
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ff0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
movl $0x1, %esi
callq 0x23f02
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6eea
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7030
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeAverage::preAnalysis(Molecule*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void AnalyzeAverage::preAnalysis(Molecule* molin, std::string topin){
  this->readTopology(molin, topin);
  this->setupMolSel(molin);
  Molecule* refmol=molin->clone();
  this->readTopology(refmol, topin);
  this->setupMolSel(refmol);
  //Zero coordinates for future appending
  this->getMol(1)->zeroCoor();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x647c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xd2ce
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r15, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x239be
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x647c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xd332
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rdx
jbe 0xd36a
movq 0x8(%rax), %rdi
callq 0x2593a
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2dfb8(%rip), %rdi     # 0x3b329
movl $0x1, %esi
xorl %eax, %eax
callq 0x4440
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xd38e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xd39f
movq (%r13), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::centerOfGeometry(Molecule*, bool)
Coor Analyze::centerOfGeometry(Molecule *mol, bool selFlag){
  Coor cog=Coor(0.0, 0.0, 0.0);

  for (unsigned int i=0; i< mol->getAtmVecSize(); i++){
    if (selFlag == true && mol->getAtom(i)->getSel() == false){
      continue;
    }
    cog+=mol->getAtom(i)->getCoor();
  }

  if (selFlag == true){
    cog/=mol->getNAtomSelected();
  }
  else{
    cog/=mol->getNAtom();
  }

  return cog;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x39fe4
movl $0x0, 0xc(%rsp)
movq %r14, %rdi
callq 0x24632
testl %eax, %eax
je 0xd56c
leaq 0xc(%rsp), %r15
testb %bpl, %bpl
je 0xd534
movq %r14, %rdi
movq %r15, %rsi
callq 0x24578
movq %rax, %rdi
callq 0x1496e
cmpb $0x0, (%rax)
je 0xd552
movq %r14, %rdi
movq %r15, %rsi
callq 0x24578
movq %rax, %rdi
callq 0x14946
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a050
movl 0xc(%rsp), %r12d
incl %r12d
movl %r12d, 0xc(%rsp)
movq %r14, %rdi
callq 0x24632
cmpl %eax, %r12d
jb 0xd517
movq %r14, %rdi
testb %bpl, %bpl
je 0xd57b
callq 0x2565c
jmp 0xd580
callq 0x2557c
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x3a23e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::angle(Coor const&, Coor const&, Coor const&)
double Analyze::angle (const Coor& u, const Coor& v, const Coor& w){
  double angle;
  Coor dx, dy;
  double dp, nx, ny;

  dx=u-v;
  dy=w-v;

  nx=dx.norm();
  ny=dy.norm();

  dp=dx.dot(dy);

  angle=acos(dp/(nx*ny));

  return angle/PI*180.0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x39fd4
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x39fd4
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3a0b8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a006
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3a0b8
movq %r14, %rdi
movq %r13, %rsi
callq 0x3a006
movq %rbx, %rdi
callq 0x3a2f0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x3a2f0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a284
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x4290
divsd 0x3e2793(%rip), %xmm0   # 0x3f0308
mulsd 0x2d8cb(%rip), %xmm0    # 0x3b448
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq