LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kube[P]gradius/Game.cpp
// Function: Game::draw()
void  Game::draw() {
  _world.draw();

  _drawScore();

  if (_gameOver)
    _drawGameOver();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x33da
movq %rbx, %rdi
callq 0x2f00
cmpl $0x0, 0x8(%rbx)
je 0x3219
popq %rbx
jmp 0x2f26
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
movl 0xc(%rdi), %ecx
movl %ecx, %esi
subl 0x3f1a(%rip), %esi      # 0x7148
pushq $-0x64
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
movl $0xfffff95c, %edx       # imm = 0xFFFFF95C
cmpl %edx, %eax
cmovll %eax, %edx
addl $0x7d0, %edx            # imm = 0x7D0
cmpl %edx, %esi
jle 0x3286
movl %ecx, 0x3ef8(%rip)      # 0x7148
pushq $0x58
popq %rdi
callq 0x2110
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x33d6
movl %eax, %ebp
callq 0x2060
pushq $0x64
popq %rcx
cltd
idivl %ecx
imull %edx, %ebp
movl %ebp, %eax
cltd
idivl %ecx
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %eax, %esi
callq 0x2ba4
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %rbp
leaq (,%rbp,8), %rdi
testq %rbp, %rbp
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
movslq 0x4(%rbx), %rax
leaq (,%rax,8), %r14
testq %rax, %rax
cmovsq %r15, %r14
xorl %r15d, %r15d
testl %eax, %eax
movl $0x0, %r12d
cmovgl %eax, %r12d
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
cmpq %r13, %r15
je 0x33b0
movq %r14, %rdi
callq 0x2030
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
xorl %eax, %eax
cmpq %rax, %r12
je 0x33ab
movq 0x8(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x3394
incq %r15
jmp 0x337d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3bc4(%rip), %rax      # 0x6fb8
movl (%rax), %eax
movl (%rbx), %r13d
movl 0x4(%rbx), %r15d
subl %r13d, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %r14d
movq 0x3b98(%rip), %rax      # 0x6fa8
movl (%rax), %eax
subl %r15d, %eax
cltd
idivl %ecx
movl %eax, %ebp
movl %eax, (%rsp)
movq 0x3bb4(%rip), %r12      # 0x6fd8
movq (%r12), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x20b0
movq (%r12), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3460
movq (%r12), %rdi
movq 0x3b5e(%rip), %rax      # 0x6fb0
movl 0x1e0(%rax), %esi
movl %r15d, %edx
callq 0x2180
movl %r15d, 0x4(%rsp)
movq (%r12), %rdi
movl %r14d, %r15d
addl %r13d, %r15d
movl (%rsp), %esi
movl %r15d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3499
movq (%r12), %rdi
movq 0x3b26(%rip), %rax      # 0x6fb0
movl 0x1e0(%rax), %esi
movl 0x4(%rsp), %edx
callq 0x2180
movq (%r12), %rdi
movl (%rsp), %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x34c6
movq (%r12), %rdi
movq 0x3af8(%rip), %rax      # 0x6fb0
movl 0x1c4(%rax), %esi
movl %r13d, %edx
callq 0x20f0
movq (%r12), %rdi
addl 0x4(%rsp), %ebp
movl %ebp, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x34f9
movq (%r12), %rdi
movq 0x3ac8(%rip), %rax      # 0x6fb0
movl 0x1c4(%rax), %esi
incl %r13d
movl %r13d, %edx
callq 0x20f0
movq (%r12), %rdi
movl (%rsp), %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3523
movq (%r12), %rdi
movq 0x3a98(%rip), %rax      # 0x6fb0
movl 0x1b0(%rax), %esi
callq 0x2070
movq (%r12), %rdi
movl (%rsp), %esi
movl %r15d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x354d
movq (%r12), %rdi
movq 0x3a6e(%rip), %rax      # 0x6fb0
movl 0x1ac(%rax), %esi
callq 0x2070
movq (%r12), %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x3576
movq (%r12), %rdi
movq 0x3a45(%rip), %rax      # 0x6fb0
movl 0x1b4(%rax), %esi
callq 0x2070
movq (%r12), %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2140
cmpl $-0x1, %eax
je 0x359f
movq (%r12), %rdi
movq 0x3a1c(%rip), %rax      # 0x6fb0
movl 0x1a8(%rax), %esi
callq 0x2070
movq (%r12), %rdi
xorl %r14d, %r14d
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x21a0
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x35e7
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x35e2
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x35dd
movq (%rdi), %rax
callq *0x10(%rax)
incq %r15
jmp 0x35bd
incq %r14
jmp 0x35b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x365b
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x3656
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x3651
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
callq 0x256c
incq %r15
jmp 0x3620
incq %r14
jmp 0x3615
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3695
cmpl %esi, (%rdi)
jle 0x3695
cmpl %edx, 0x4(%rdi)
jle 0x3695
movq 0x8(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
movl %edx, %ecx
testq %rbx, %rbx
je 0x369f
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x36a6
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x20(%rax)
andq $0x0, (%rax,%rcx,8)
jmp 0x36aa
movq %rbx, (%rax,%rcx,8)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x64
popq %rdx
movss 0x9a2(%rip), %xmm0      # 0x4060
movss 0xa56(%rip), %xmm2      # 0x411c
pushq $0x35
popq %rcx
xorps %xmm1, %xmm1
movl %edx, %esi
callq 0x26fc
leaq 0x3656(%rip), %rax      # 0x6d30
movq %rax, (%rbx)
movaps 0xa4c(%rip), %xmm0      # 0x4130
movups %xmm0, 0x18(%rbx)
movq 0x38c1(%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 0x3662
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2782
movq %r14, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x64
popq %rdx
movss 0x91f(%rip), %xmm0      # 0x4060
movss 0x9d3(%rip), %xmm2      # 0x411c
pushq $0x35
popq %rcx
xorps %xmm1, %xmm1
movl %edx, %esi
callq 0x26fc
leaq 0x35d3(%rip), %rax      # 0x6d30
cvtsi2ss %r14d, %xmm0
movq %rax, (%rbx)
cvtsi2ss %ebp, %xmm1
movss %xmm0, 0x8(%rbx)
movss %xmm1, 0xc(%rbx)
movaps 0x9b6(%rip), %xmm2      # 0x4130
movups %xmm2, 0x18(%rbx)
movq 0x382b(%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 0x3662
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2782
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/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 0x37b5(%rip), %rax      # 0x6fb8
movl (%rax), %ebp
movq 0x30(%rdi), %rdi
callq 0x33d6
subl %eax, %ebp
pushq $0x2
popq %r15
movl %ebp, %eax
cltd
idivl %r15d
movl %eax, %ebp
movq 0x3785(%rip), %rax      # 0x6fa8
movl (%rax), %r14d
movq 0x30(%rbx), %rdi
callq 0x33d2
subl %eax, %r14d
movl %r14d, %eax
cltd
idivl %r15d
movl %eax, %r14d
movq 0x3795(%rip), %r15      # 0x6fd8
movq (%r15), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x20b0
cvtsi2ss %r14d, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
cvtsi2ss %ebp, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq (%r15), %rdi
movl 0x2c(%rbx), %esi
callq 0x2070
movq (%r15), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/kube[P]gradius/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:
movups 0x24(%rdi), %xmm2
movsd 0x10(%rdi), %xmm3
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
addps %xmm3, %xmm0
movaps 0x65a(%rip), %xmm1      # 0x4010
xorps %xmm0, %xmm1
maxps %xmm0, %xmm1
shufps $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
movaps %xmm0, %xmm3
divps %xmm1, %xmm3
mulps %xmm2, %xmm3
cmpltps %xmm1, %xmm2
andps %xmm2, %xmm3
andnps %xmm0, %xmm2
orps %xmm3, %xmm2
movlps %xmm2, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0x10(%rdi), %rax
movl %esi, %r14d
movq %rdi, %rbx
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x3
popq %rsi
callq 0x32e0
movl $0x204, %eax            # imm = 0x204
leaq 0x5361(%rip), %r15      # 0xb776
bextrl %eax, %r14d, %eax
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x3190
movl $0x202, %eax            # imm = 0x202
bextrl %eax, %r14d, %eax
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x3190
andl $0x3, %r14d
movsbl (%r14,%r15), %esi
movq %rbx, %rdi
callq 0x3190
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %rax, %r14
callq 0x30f0
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O2/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::Reference::findAlignment(std::vector<unsigned char, std::allocator<unsigned char>> const&) const
ReadReport getReport() const
    {
        return ReadReport{mFirstCodonCovered,
                          Offset(mWTItr-mWTBeg),
                          mNMismatches,
                          mVariations};
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdx), %r15
movq (%rdx), %rbp
movl (%rsi), %eax
movq %r15, %rcx
subq %rbp, %rcx
cmpq %rax, %rcx
jae 0x6e23
vxorps %xmm0, %xmm0, %xmm0
movq %rdi, %rax
vmovups %xmm0, 0x9(%rdi)
vmovups %xmm0, (%rdi)
jmp 0x6f3a
subq %rax, %r15
movq %rbp, %r14
leaq 0x20(%rsp), %r13
leaq 0x38(%rsi), %r12
negq %r14
movq %rdx, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rbp, %rbx
incq %r15
movq %rbp, (%r13)
cmpq %r15, %rbp
je 0x6e8f
movq %r12, %rdi
movq %r13, %rsi
callq 0x665c
movq 0x10(%rsp), %rsi
movq %rax, %rcx
xorl %edx, %edx
movq %r12, %rdi
divq 0x48(%rsi)
movq %rdx, %rsi
movq %r13, %rdx
callq 0x668e
testq %rax, %rax
jne 0x6ea6
incq %rbp
incq %rbx
decq %r14
movq %rbp, 0x20(%rsp)
jmp 0x6e4e
movq 0x8(%rsp), %rax
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x9(%rax)
vmovups %xmm0, (%rax)
jmp 0x6f3a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x10(%rax), %r9
movq %rbx, %rcx
movb 0x18(%rax), %bpl
movq 0x8(%rsp), %rax
subq (%rdi), %rcx
movq 0x8(%rsi), %r11
movq 0x10(%rsi), %r15
movq 0x8(%rdi), %rdi
movq %r9, %r10
movq %r9, %rdx
cmpq %r9, %rcx
movq %r15, %rsi
cmovbq %rcx, %r10
subq %r11, %rsi
addq %r10, %rdi
subq %r10, %rdx
movq %rsi, %r12
subq %r10, %rcx
movq %rdi, %r8
subq %rdx, %r12
subq %rbx, %r8
cmpq %r12, %r8
cmovaeq %r12, %r8
subq %r9, %r15
addq %rdi, %r14
subq %r11, %r15
addq %r10, %r15
subq %rdx, %rsi
subq %r8, %rsi
cmpq %r14, %r15
cmovbq %r15, %r14
subq %r14, %rdi
subq %rbx, %rdi
testb %bpl, %bpl
cmoveq %rdx, %rsi
cmoveq %rcx, %rdi
addq %rsi, %r8
movq %rsi, (%rax)
movq %r8, 0x8(%rax)
movq %rdi, 0x10(%rax)
movb %bpl, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x50(%rdi), %rbx
testq %rbx, %rbx
je 0x7011
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x3200
movq %rax, %rdi
movq %r13, %rsi
callq 0x31d0
pushq $0x3a
popq %rsi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
movq %r12, %rsi
callq 0x3150
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x3200
movq (%r15), %r12
movq 0x8(%r15), %r15
leaq 0x499c(%rip), %r13      # 0xb94d
cmpq %r15, %r12
je 0x6fcd
movzbl (%r12), %eax
movq %rbx, %rdi
movsbl (%rax,%r13), %esi
callq 0x3200
incq %r12
jmp 0x6fb1
leaq 0x4975(%rip), %rsi      # 0xb949
movq %rbx, %rdi
callq 0x31d0
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x6ffd
movb (%r15), %al
movq %rbx, %rdi
addb $0x21, %al
movsbl %al, %esi
callq 0x3200
incq %r15
jmp 0x6fe3
pushq $0xa
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x60, %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 0x70e8
movq 0x10(%r13), %rcx
movl 0xc(%rbx), %esi
cmpq %rsi, %rcx
ja 0x7074
movq 0x20(%rsp), %rax
subq 0x18(%rsp), %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
cmpq $0x2, %rax
jb 0x70ab
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x7212
leaq 0x30(%rsp), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x7b70
leaq 0x48(%rsp), %rdi
callq 0x7e6a
movq 0x10(%r14), %rcx
movl 0xc(%rbx), %esi
cmpq %rsi, %rcx
ja 0x70bb
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7bca
leaq 0x18(%rsp), %rdi
callq 0x7e6a
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %rdi
movq %rax, %rbx
callq 0x7e6a
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
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 0x7c88
movq (%r13), %rax
movq (%r12), %rbp
movq 0x8(%r12), %rbx
movq 0x8(%rax), %r13
addq %rbp, %r13
cmpb $0x0, 0x18(%r12)
je 0x718e
movq 0x10(%r12), %r12
movq 0x8(%r15), %r15
subq %rbx, %rbp
xorl %ebx, %ebx
notq %r12
addq %r12, %r15
addq 0x8(%r14), %r12
leaq 0x10(%rsp), %r14
cmpq %rbx, %rbp
je 0x71c8
movb (%r15,%rbx), %al
movzbl (%r13), %esi
movl %eax, %ecx
xorb $0x3, %cl
cmpb $0x4, %al
movzbl %cl, %eax
pushq $0x4
popq %rcx
cmovel %ecx, %eax
movzbl (%r12,%rbx), %ecx
movzbl %al, %edx
movq %r14, %rdi
callq 0x7d40
incq %r13
decq %rbx
jmp 0x7158
movq 0x10(%r12), %r12
movq (%r15), %r15
subq %rbp, %rbx
xorl %ebp, %ebp
addq %r12, %r15
addq (%r14), %r12
leaq 0x10(%rsp), %r14
cmpq %rbp, %rbx
je 0x71c8
movzbl (%r15,%rbp), %edx
movzbl (%r13,%rbp), %esi
movzbl (%r12,%rbp), %ecx
movq %r14, %rdi
callq 0x7d40
incq %rbp
jmp 0x71a6
movq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7e34
leaq 0x70(%rsp), %rdi
callq 0x7e6a
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x71fd
jmp 0x71fd
leaq 0x70(%rsp), %rdi
movq %rax, %rbx
callq 0x7e6a
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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), %r9
movq 0x78(%rsi), %r8
movq %r8, 0x8(%rdi)
vmovups %xmm0, 0x10(%rdi)
addq $0x10, %r8
movq 0x90(%rsi), %rax
movq %rax, 0x20(%rdi)
vmovups %xmm0, 0x28(%rdi)
movb %cl, 0x38(%rdi)
vmovups %xmm0, 0x3c(%rdi)
andq $0x0, 0x70(%rdi)
vxorps %xmm0, %xmm0, %xmm0
xorl %eax, %eax
vmovups %ymm0, 0x50(%rdi)
movq -0x8(%r8), %rcx
cmpq %rdx, %rcx
ja 0x7cea
subq -0x10(%r8), %rcx
addq %rcx, %rax
movq %rax, 0x50(%rdi)
movq %r8, 0x8(%rdi)
addq $0x10, %r8
jmp 0x7ccc
vmovups -0x10(%r8), %xmm0
xorl %ecx, %ecx
vmovups %xmm0, (%r9)
subq -0x10(%r8), %rdx
cmovbq %rcx, %rdx
addq %rdx, %rax
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
movl %edx, 0x40(%rdi)
addl %edx, %edx
xorb $0x6, %dl
movq %rax, 0x50(%rdi)
movq 0x90(%rsi), %rcx
leaq (%rcx,%rax,4), %rcx
shlq $0x3, %rax
movq %rcx, 0x28(%rdi)
addq 0xa8(%rsi), %rax
movq %rax, 0x30(%rdi)
shrxl %edx, (%rcx), %eax
movl %eax, 0x3c(%rdi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7d6d
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 0x7d95
cmpb %dl, %sil
je 0x7e2c
cmpb %cl, 0x38(%rbx)
ja 0x7e2c
incq 0x58(%rbx)
jmp 0x7e2c
cmpb %cl, 0x38(%rbx)
ja 0x7da9
incl 0x48(%rbx)
cmpb %dl, %sil
je 0x7da9
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 0x7e2c
movq 0x28(%rbx), %rax
leaq 0x3c(%rbx), %r14
cmpl (%rax), %ecx
je 0x7e16
movq 0x30(%rbx), %rdx
movq (%rdx), %rdx
btq %rcx, %rdx
jae 0x7e16
cmpl $0x3, 0x48(%rbx)
jne 0x7e16
leaq 0x60(%rbx), %rdi
movq 0x60(%rbx), %rdx
cmpq 0x68(%rbx), %rdx
jne 0x7df8
movl 0x44(%rbx), %edx
subq %rdx, 0x58(%rbx)
movq %rsp, %rsi
andl $0x0, (%rsi)
subq 0x20(%rbx), %rax
sarq $0x2, %rax
movq %rax, 0x8(%rsi)
movl %ecx, 0x10(%rsi)
callq 0x7e78
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
// File: /workspace/github_cpp_makefile_star2_O2/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::operator<((anonymous namespace)::Variation const&, (anonymous namespace)::Variation const&)
bool operator<( Variation const& var1, Variation const& var2 )
    { if ( var1.mType != var2.mType ) return var1.mType < var2.mType;
      if ( var1.mCodonIdx != var2.mCodonIdx )
          return var1.mCodonIdx < var2.mCodonIdx;
      return var1.mValue < var2.mValue; }

// Assembly:
movl (%rsi), %eax
cmpl %eax, (%rdi)
jne 0x8659
movq 0x8(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jne 0x8655
movl 0x10(%rdi), %eax
cmpl 0x10(%rsi), %eax
setb %al
retq
setl %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8799
movq %rax, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xa044
movq (%r15), %rax
xorl %ecx, %ecx
cmpq $0x200, %rcx            # imm = 0x200
je 0x87c6
movq 0x20(%r14,%rcx), %rdx
movq (%rbx,%rcx), %rsi
addq $0x8, %rcx
addq %rsi, (%rax,%rdx,8)
jmp 0x87aa
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x2160
andl $0x0, (%rax)
movl %r14d, 0x4(%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x29d8
cmpq %rcx, 0x10(%rcx)
je 0x29c2
movq 0x18(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq %rdx, 0x18(%rax)
jmp 0x29ca
movq %rax, 0x10(%rcx)
movq %rcx, 0x18(%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x18(%rcx)
cmpl %r14d, 0x4(%rcx)
jge 0x29db
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a65
cmpl %edx, 0x4(%r8)
jge 0x2a70
movq (%rdi), %rax
movq %r8, %rcx
movq 0x18(%rsi), %rdx
cmpq %rsi, %rdx
je 0x2a1e
movq %rdx, 0x8(%rcx)
movq 0x10(%rsi), %r8
movq %rdx, 0x18(%r8)
movq 0x18(%rsi), %rdx
movq %r8, 0x10(%rdx)
jmp 0x2a23
andq $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 0x2a4b
movq %rsi, (%rdi)
movq %rsi, %rax
andq $0x0, 0x20(%rsi)
movq 0x20(%rcx), %r8
testq %r8, %r8
je 0x2a70
cmpb $0x0, 0x28(%r8)
movq %rcx, %rsi
jne 0x29fc
jmp 0x2a70
movq (%rdi), %rax
cmpl %edx, 0x4(%rax)
jge 0x2a70
movq %rsi, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH07_Classes/examples/add_item.cc
// Function: main
int main()
{
	Sales_data data1, data2;
	if (read(cin, data1) && read(cin, data2)) {  // read the transactions
		if (data1.isbn() == data2.isbn()) {      // check isbns
			data1.combine(data2);                // add the transactions
			print(cout, data1);                  // print the results
			cout << endl;                        // followed by a newline 
		}
	} else
		cerr << "Input failed!" << endl;        

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x2d13(%rip), %rdi      # 0x3fd8
leaq -0x48(%rbp), %rsi
callq 0x145e
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12fa
movq 0x2cf5(%rip), %rdi      # 0x3fd8
leaq -0x78(%rbp), %rsi
callq 0x145e
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x133a
movq 0x2cef(%rip), %rdi      # 0x3ff0
leaq 0xcfc(%rip), %rsi       # 0x2004
callq 0x10a0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1050
leaq -0x78(%rbp), %rdi
callq 0x1040
leaq -0x48(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x10c0
leaq -0xb8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x10c0
leaq -0x98(%rbp), %rbx
leaq -0xb8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e0
movl %eax, %r15d
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1040
testb %r15b, %r15b
je 0x1318
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x14d2
movq 0x2c29(%rip), %rbx      # 0x3fc8
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x1522
jmp 0x1310
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1040
jmp 0x13c6
jmp 0x13c3
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x1040
leaq -0x48(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e06ac(%rip), %rbx    # 0x3e4ff0
leaq 0x286c5(%rip), %rsi     # 0x2d010
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286ce(%rip), %rsi     # 0x2d030
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286d9(%rip), %rsi     # 0x2d052
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286e2(%rip), %rsi     # 0x2d072
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286e7(%rip), %rsi     # 0x2d08e
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286ee(%rip), %rsi     # 0x2d0ac
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286ea(%rip), %rsi     # 0x2d0bf
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286e7(%rip), %rsi     # 0x2d0d3
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286e7(%rip), %rsi     # 0x2d0ea
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x286e9(%rip), %rsi     # 0x2d103
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
leaq 0x28707(%rip), %rsi     # 0x2d138
movq %rbx, %rdi
callq 0x4300
movq %rax, %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4180
xorl %edi, %edi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3dec11(%rip), %rax    # 0x3e49a0
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)
andq $0x0, 0x78(%rbx)
xorl %eax, %eax
movb %al, 0x80(%rbx)
leaq 0xa0(%rbx), %rcx
movq %rcx, 0x90(%rbx)
andq $0x0, 0x98(%rbx)
movb %al, 0xa0(%rbx)
callq 0x58a4
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x5df8
movq %rax, 0x28(%rbx)
movq 0x38(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x5e06
movq %rax, 0x40(%rbx)
leaq 0x50(%rbx), %rdi
callq 0xc782
andl $0x0, 0x68(%rbx)
xorl %eax, %eax
movb %al, 0x6c(%rbx)
andq $0x0, 0x78(%rbx)
movq 0x70(%rbx), %rcx
movb %al, (%rcx)
andq $0x0, 0x98(%rbx)
movq 0x90(%rbx), %rcx
movb %al, (%rcx)
movb %al, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzePcasso::AnalyzePcasso(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
AnalyzePcasso::AnalyzePcasso (std::string delim){
  std::vector<std::string> tokens;
  pout=PREDICT;
  t.clear();
  t.resize(PCASSO::getNTree());
  for (unsigned int i=0; i< PCASSO::getNTree(); i++){
    t.at(i)=new DTree;
    Misc::splitStr(Misc::trim(PCASSO::getTree(i)), " \t", tokens, false);
    t.at(i)->genDTree(tokens, delim);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, %rbx
callq 0x5d84
leaq 0x3debad(%rip), %rax    # 0x3e4a40
movq %rax, (%rbx)
leaq 0xb8(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
andq $0x0, 0xc8(%rbx)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movl $0x2, 0xb4(%rbx)
callq 0x2c9ae
movl %eax, %esi
movq %r14, %rdi
callq 0xc7ac
movq %r14, (%rsp)
xorl %r12d, %r12d
leaq 0x98(%rsp), %r13
leaq 0xb8(%rsp), %rbx
leaq 0x78(%rsp), %r15
leaq 0x58(%rsp), %r14
callq 0x2c9ae
movl %eax, %eax
cmpq %rax, %r12
jae 0x5fe0
pushq $0x38
popq %rdi
callq 0x4320
movq %rax, %rbp
movq %rax, %rdi
callq 0x17acc
movq (%rsp), %rdi
movq %r12, %rsi
callq 0xc7de
movq %rbp, (%rax)
leaq 0x38(%rsp), %rdi
movl %r12d, %esi
callq 0x2c740
movq %r13, %rdi
leaq 0x28682(%rip), %rsi     # 0x2e5c4
leaq 0xf(%rsp), %rdx
callq 0x58d8
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
movq %r13, %rdx
callq 0x18be4
movq %r15, %rdi
leaq 0x2752e(%rip), %rsi     # 0x2d494
leaq 0xe(%rsp), %rdx
callq 0x58d8
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x188fc
movq %r15, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4170
movq %r13, %rdi
callq 0x4170
leaq 0x38(%rsp), %rdi
callq 0x4170
movq (%rsp), %rdi
movq %r12, %rsi
callq 0xc7de
movq (%rax), %rbp
movq %r14, %rdi
movq 0x30(%rsp), %rsi
callq 0x4430
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x181be
movq %r14, %rdi
callq 0x4170
incq %r12
jmp 0x5ef9
leaq 0x10(%rsp), %rdi
callq 0x59a0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6066
jmp 0x605f
movq %rax, %rbx
jmp 0x6036
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x6048
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4170
jmp 0x6029
movq %rax, %rbx
jmp 0x6043
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x4170
leaq 0x38(%rsp), %rdi
callq 0x4170
jmp 0x6062
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %rbp, %rdi
callq 0x4330
jmp 0x6062
movq %rax, %rbx
movq (%rsp), %r14
leaq 0x10(%rsp), %rdi
callq 0x59a0
movq %r14, %rdi
callq 0xce50
movq 0x28(%rsp), %rdi
callq 0xc736
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeCasa::AnalyzeCasa(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
AnalyzeCasa::AnalyzeCasa (std::string delim){
  unsigned int ntree;
  /* t1 */
  std::vector<std::string> tokens;
  t1.clear();
  ntree=CASAP::getNTree();
  t1.resize(ntree);
  
  for (unsigned int i=0; i< ntree; i++){
    t1.at(i)=new DTree;
    Misc::splitStr(CASAP::getTree(i), " \t", tokens, false);
    t1.at(i)->genDTree(tokens, delim);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
callq 0x5d84
leaq 0x3de9e1(%rip), %rax    # 0x3e4a90
movq %rax, (%rbx)
leaq 0xb8(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rbx)
movq %rbx, 0x8(%rsp)
andq $0x0, 0xc8(%rbx)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
callq 0x2c73a
movl %eax, %esi
movq %r14, %rdi
movq %rsi, 0x30(%rsp)
callq 0xc7ac
xorl %r13d, %r13d
leaq 0x78(%rsp), %rbx
leaq 0x58(%rsp), %rbp
leaq 0x38(%rsp), %r12
cmpq %r13, 0x30(%rsp)
je 0x61a9
pushq $0x38
popq %rdi
callq 0x4320
movq %rax, %r15
movq %rax, %rdi
callq 0x17acc
movq %r14, %rdi
movq %r13, %rsi
callq 0xc7de
movq %r15, (%rax)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2c274
movq %rbp, %rdi
leaq 0x27352(%rip), %rsi     # 0x2d494
leaq 0x7(%rsp), %rdx
callq 0x58d8
movq %rbx, %rdi
movq %rbp, %rsi
leaq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x188fc
movq %rbp, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
movq %r13, %rsi
callq 0xc7de
movq (%rax), %r15
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0x4430
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x181be
movq %r12, %rdi
callq 0x4170
incq %r13
jmp 0x6101
leaq 0x10(%rsp), %rdi
callq 0x59a0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6201
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x61fa
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x4330
jmp 0x6204
jmp 0x6201
movq %rax, %rbx
jmp 0x61f5
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x4170
leaq 0x78(%rsp), %rdi
callq 0x4170
jmp 0x6204
movq %rax, %rbx
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rdi
callq 0x59a0
movq %r14, %rdi
callq 0xce50
movq %r15, %rdi
callq 0xc736
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x62e3
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x1
popq %rbp
movq %rsi, %rdi
movq %rdx, %rsi
movl %ebp, %edx
callq 0x1b05c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b232
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1b3ae
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, (%rdx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6236
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %ecx, %edx
callq 0x1b6fe
leaq 0x10(%rsp), %rdi
callq 0x4170
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1a686
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6264
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeDistance::setupMolSel(Molecule*)
void AnalyzeDistance::setupMolSel(Molecule* molin){
  unsigned int i;
  Molecule* tmpmol;

  for (i=0; i< this->getNSel(); i++){
    molin->select(this->getSel(i));
    tmpmol=molin->copy();
    this->addMol(tmpmol);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
pushq $0x1
popq %rbp
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
shrq $0x5, %rax
cmpl %eax, %r13d
jae 0x63d3
movl %r13d, 0x4(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6236
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x1b6fe
movq %r15, %rdi
callq 0x4170
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a686
movq %r14, %rdi
movq %rax, %rsi
callq 0x6264
incl %r13d
jmp 0x637e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x4430
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0x4170
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%rax)
pushq $0x1
popq %rdx
movq %r12, %rdi
movl %edx, %esi
callq 0x1a26c
movq %rax, %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4430
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
callq 0x4170
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
callq 0x8be4
movq %rax, %rdi
callq 0x1b9da
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8d43
movq %rax, %rbx
movq %r14, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O2/atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeCOG::runAnalysis()
void AnalyzeCOG::runAnalysis(){
  Coor xyz=Analyze::centerOfGeometry(this->getMol(0));
  std::cout << std::fixed;
  std::cout << std::setw(9) << std::right << std::setprecision(3) << xyz.x();
  std::cout << std::setw(9) << std::right << std::setprecision(3) << xyz.y();
  std::cout << std::setw(9) << std::right << std::setprecision(3) << xyz.z();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x8be4
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8e74
movq 0x3dc229(%rip), %r14    # 0x3e4fc8
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%r14,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rcx
pushq $0x9
popq %r15
movq %r15, 0x10(%r14,%rcx)
movq -0x18(%rax), %rcx
movl $0xffffff4f, %ebp       # imm = 0xFFFFFF4F
movl 0x18(%r14,%rcx), %edx
andl %ebp, %edx
movl $0x80, %r12d
orl %r12d, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
pushq $0x3
popq %r13
movq %r13, 0x8(%r14,%rax)
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x44d0
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq %r15, 0x10(%r14,%rcx)
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl %ebp, %edx
orl %r12d, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
movq %r13, 0x8(%r14,%rax)
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x44d0
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq %r15, 0x10(%r14,%rcx)
movq -0x18(%rax), %rcx
andl 0x18(%r14,%rcx), %ebp
orl %r12d, %ebp
movl %ebp, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
movq %r13, 0x8(%r14,%rax)
movsd 0x10(%rbx), %xmm0
movq %r14, %rdi
callq 0x44d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2bf40
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
movl %r12d, 0xc(%rsp)
movq %r14, %rdi
callq 0x1ac18
cmpl %eax, %r12d
jae 0x8ef5
testb %bpl, %bpl
je 0x8ecd
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ab66
movq %rax, %rdi
callq 0xea64
cmpb $0x0, (%rax)
je 0x8eeb
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ab66
movq %rax, %rdi
callq 0xea3c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2bfac
movl 0xc(%rsp), %r12d
incl %r12d
jmp 0x8e9e
movq %r14, %rdi
testb %bpl, %bpl
je 0x8f04
callq 0x1b756
jmp 0x8f09
callq 0x1b6a8
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x2c19a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq