LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Missile.cpp
// Function: Missile::Initialize()
void Missile::Initialize()
{
  ResetAll();

  simTime = GetSimTime();
  
  nextFrameTime = initFrameTime;

  vxb = 0.0;
  vyb = 0.0;

  vxf = vxb;
  vyf = vxb;

  pxf = -( pExec->tFinal - launchTime ) * initVxb;
  pyf = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, 0x170(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x110(%rdi)
movups %xmm0, 0x120(%rdi)
movups %xmm0, 0x130(%rdi)
movups %xmm0, 0x140(%rdi)
movups %xmm0, 0x150(%rdi)
movups %xmm0, 0x159(%rdi)
movq 0x38(%rdi), %rax
movsd (%rax), %xmm1
movsd %xmm1, 0x170(%rdi)
movsd 0xf8(%rdi), %xmm1
movsd %xmm1, 0x30(%rdi)
movups %xmm0, 0x148(%rdi)
movups %xmm0, 0x158(%rdi)
movq 0x180(%rdi), %rax
movsd 0x178(%rax), %xmm0
subsd 0x108(%rdi), %xmm0
xorpd 0xa589(%rip), %xmm0     # 0x15010
mulsd 0x100(%rdi), %xmm0
movsd %xmm0, 0x130(%rdi)
andq $0x0, 0x138(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Missile.cpp
// Function: Missile::Update()
void Missile::Update()
{
  simTime = GetSimTime();
  
  if ( (simTime > launchTime) && !initialized )
  {
    initialized = true;

    vxb = initVxb;
    vyb = 0.0;

    vxf = vxb;
    vyf = vyb;

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
ucomisd 0x108(%rdi), %xmm0
jbe 0xab44
cmpb $0x0, 0x168(%rdi)
jne 0xab44
movb $0x1, 0x168(%rdi)
movsd 0x100(%rdi), %xmm0
movsd %xmm0, 0x148(%rdi)
xorps %xmm1, %xmm1
movups %xmm1, 0x158(%rdi)
movsd %xmm0, 0x150(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MslTse6.cpp
// Function: MslTse6::Initialize()
void MslTse6::Initialize()
{
  int idx;

  ResetAll();

  simTime = GetSimTime();

  assert( pExec );
  assert( pMsl );
  assert( pRdr );
  assert( pSkr );
  assert( pTgt );
  assert( pTse6 );
  assert( pTseO );

  for (idx = 0; idx < 6; ++idx)
  {
    eye[idx][idx] = 1.0;
  }

  HH[0][0] = 1.0;
  HH[1][2] = 1.0;
  HH[2][3] = 1.0;

  HT = Transpose( HH );

  initFrameTime = pMsl->launchTime;

  nextFrameTime = initFrameTime;

  nextUpLinkTime = pMsl->launchTime;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0xb54e
movq 0x38(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x4d0(%rbx)
cmpq $0x0, 0x510(%rbx)
je 0xb454
cmpq $0x0, 0x518(%rbx)
je 0xb471
cmpq $0x0, 0x520(%rbx)
je 0xb490
cmpq $0x0, 0x528(%rbx)
je 0xb4af
cmpq $0x0, 0x530(%rbx)
je 0xb4ce
cmpq $0x0, 0x538(%rbx)
je 0xb4ed
cmpq $0x0, 0x540(%rbx)
je 0xb50c
leaq 0x310(%rbx), %r14
xorl %r15d, %r15d
movabsq $0x3ff0000000000000, %r12 # imm = 0x3FF0000000000000
cmpq $0x6, %r15
je 0xb3a7
movq %r14, %rdi
movl %r15d, %esi
callq 0x1324e
movq %r12, (%rax,%r15,8)
incq %r15
jmp 0xb38d
leaq 0x328(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1324e
movq %r12, (%rax)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1324e
movq %r12, 0x10(%rax)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x1324e
movq %r12, 0x18(%rax)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12d48
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x14d68
leaq 0x340(%rbx), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x13296
leaq -0x68(%rbp), %rdi
callq 0x12dd8
leaq -0x38(%rbp), %rdi
callq 0x12dd8
leaq -0x50(%rbp), %rdi
callq 0x12dd8
movq 0x518(%rbx), %rax
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0xf8(%rbx)
movsd %xmm0, 0x30(%rbx)
movsd %xmm0, 0x108(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa0b1(%rip), %rdi      # 0x1550c
leaq 0xa276(%rip), %rsi      # 0x156d8
leaq 0xa282(%rip), %rcx      # 0x156eb
pushq $0x7f
popq %rdx
callq 0x3120
leaq 0xa09a(%rip), %rdi      # 0x15512
leaq 0xa259(%rip), %rsi      # 0x156d8
leaq 0xa265(%rip), %rcx      # 0x156eb
movl $0x80, %edx
callq 0x3120
leaq 0xa088(%rip), %rdi      # 0x1551f
leaq 0xa23a(%rip), %rsi      # 0x156d8
leaq 0xa246(%rip), %rcx      # 0x156eb
movl $0x81, %edx
callq 0x3120
leaq 0xa258(%rip), %rdi      # 0x1570e
leaq 0xa21b(%rip), %rsi      # 0x156d8
leaq 0xa227(%rip), %rcx      # 0x156eb
movl $0x82, %edx
callq 0x3120
leaq 0xa04f(%rip), %rdi      # 0x15524
leaq 0xa1fc(%rip), %rsi      # 0x156d8
leaq 0xa208(%rip), %rcx      # 0x156eb
movl $0x83, %edx
callq 0x3120
leaq 0xa035(%rip), %rdi      # 0x15529
leaq 0xa1dd(%rip), %rsi      # 0x156d8
leaq 0xa1e9(%rip), %rcx      # 0x156eb
movl $0x84, %edx
callq 0x3120
leaq 0xa200(%rip), %rdi      # 0x15713
leaq 0xa1be(%rip), %rsi      # 0x156d8
leaq 0xa1ca(%rip), %rcx      # 0x156eb
movl $0x85, %edx
callq 0x3120
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x12dd8
jmp 0xb53c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x12dd8
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Seeker.cpp
// Function: Seeker::Seeker()
Seeker::Seeker() :
pExec(0),
pMsl(0),
pTgt(0),
MdlBase()
{
  //
  // Input parameter defaults
  //
  frameTimeStep = 1.0/180.0; // sec    Frame update interval
  initFrameTime = 0.0;       // sec    Time of first FrameUpdate

  detRng = 10.0e3;           // m      Detection / acquisition range  
  fov = 20.0 * DEG2RAD;      // rad    Field of view     
  rinAng = 0.2e-3;           // rad    Range independent angle noise

  //
  // Other variable initialization
  //

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9cd8
leaq 0xe037(%rip), %rax      # 0x1cbc8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1b0(%rbx)
andq $0x0, 0x1c0(%rbx)
movabsq $0x3f76c16c16c16c17, %rax # imm = 0x3F76C16C16C16C17
movq %rax, 0x8(%rbx)
andq $0x0, 0x108(%rbx)
movabsq $0x40c3880000000000, %rax # imm = 0x40C3880000000000
movq %rax, 0xf8(%rbx)
movabsq $0x3fd657184ae74487, %rax # imm = 0x3FD657184AE74487
movq %rax, 0x100(%rbx)
movabsq $0x3f2a36e2eb1c432d, %rax # imm = 0x3F2A36E2EB1C432D
movq %rax, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Seeker.cpp
// Function: Seeker::Initialize()
void Seeker::Initialize()
{
  ResetAll();

  simTime = GetSimTime();

  initFrameTime = pMsl->launchTime;

  nextFrameTime = initFrameTime;

  pxf = pMsl->pxf;
  pyf = pMsl->pyf;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x118(%rdi)
movb $0x0, 0x120(%rdi)
addq $0x128, %rdi            # imm = 0x128
movl $0x88, %edx
xorl %esi, %esi
callq 0x3110
movq 0x38(%rbx), %rax
movq 0x1b8(%rbx), %rcx
movsd (%rax), %xmm0
movsd %xmm0, 0x168(%rbx)
movsd 0x108(%rcx), %xmm0
movsd %xmm0, 0x108(%rbx)
movsd %xmm0, 0x30(%rbx)
movsd 0x130(%rcx), %xmm0
movsd %xmm0, 0x138(%rbx)
movsd 0x138(%rcx), %xmm0
movsd %xmm0, 0x140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Seeker.cpp
// Function: Seeker::FrameUpdate()
void Seeker::FrameUpdate()
{
  simTime = GetSimTime();

  pxf = pMsl->pxf;
  pyf = pMsl->pyf;

  vxf = pMsl->vxf;
  vyf = pMsl->vyf;

  truPosX = pTgt->pxf;
  truPosY = pTgt->pyf;

  truVelX = pTgt->vxf;
  truVelY = pTgt->vyf;

  relPosX = truPosX - pxf;
  relPosY = truPosY - pyf;

  relVelX = truVelX - vxf;
  relVelY = truVelY - vyf;

  truAng = atan2( relPosY, relPosX );

  truRng = sqrt( SQ(relPosX) + SQ(relPosY) );

  truRdot = ( relVelX * relPosX + relVelY * relPosY ) / truRng;

  if ( truRng < detRng )
  {
    measAng = gaussian( truAng, rinAng, &pExec->seed );
    measValid = true;      
  }
  else
  {
    measAng = 0.0;
    measValid = false;      
  }
  
  timeStamp = simTime;
              
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x1b8(%rdi), %rcx
movsd (%rax), %xmm0
movsd %xmm0, 0x168(%rdi)
movsd 0x130(%rcx), %xmm2
movsd %xmm2, 0x138(%rdi)
movsd 0x138(%rcx), %xmm3
movsd %xmm3, 0x140(%rdi)
movsd 0x150(%rcx), %xmm4
movsd %xmm4, 0x1a0(%rdi)
movsd 0x160(%rcx), %xmm5
movsd %xmm5, 0x1a8(%rdi)
movq 0x1c0(%rdi), %rax
movsd 0x160(%rax), %xmm1
movsd %xmm1, 0x170(%rdi)
movsd 0x168(%rax), %xmm0
movsd %xmm0, 0x178(%rdi)
movsd 0x180(%rax), %xmm6
movsd %xmm6, 0x190(%rdi)
movsd 0x190(%rax), %xmm7
movsd %xmm7, 0x198(%rdi)
subsd %xmm2, %xmm1
movsd %xmm1, 0x148(%rdi)
subsd %xmm3, %xmm0
movsd %xmm0, 0x150(%rdi)
subsd %xmm4, %xmm6
movsd %xmm6, 0x158(%rdi)
subsd %xmm5, %xmm7
movsd %xmm7, 0x160(%rdi)
callq 0x3060
movsd %xmm0, 0x130(%rbx)
movsd 0xf8(%rbx), %xmm1
movsd 0x148(%rbx), %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
movsd 0x150(%rbx), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm3, %xmm5
sqrtsd %xmm5, %xmm3
movsd %xmm3, 0x188(%rbx)
mulsd 0x160(%rbx), %xmm4
mulsd 0x158(%rbx), %xmm2
addsd %xmm4, %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, 0x180(%rbx)
ucomisd %xmm3, %xmm1
jbe 0xee27
movsd 0x110(%rbx), %xmm1
movl $0x200, %edi            # imm = 0x200
addq 0x1b0(%rbx), %rdi
callq 0x967d
movb $0x1, %al
jmp 0xee2d
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd %xmm0, 0x118(%rbx)
movb %al, 0x120(%rbx)
movsd 0x168(%rbx), %xmm0
movsd %xmm0, 0x128(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Seeker.cpp
// Function: Seeker::Output(bool, _IO_FILE*)
void Seeker::Output( bool printHeader,
                      FILE *pOutFile )
{
  simTime = GetSimTime();

  if ( printHeader )
  {
    fprintf( pOutFile, "%20s", "skr.measAng");
    fprintf( pOutFile, "%20s", "skr.measValid");
    fprintf( pOutFile, "%20s", "skr.rinAng");
    fprintf( pOutFile, "%20s", "skr.timeStamp");


    fprintf( pOutFile, "%20s", "skr.truAng");
    fprintf( pOutFile, "%20s", "skr.truRdot");
    fprintf( pOutFile, "%20s", "skr.truRng");

    fprintf( pOutFile, "%20s", "skr.vxf");
    fprintf( pOutFile, "%20s", "skr.vyf");
  }
  else
  {
    fprintf( pOutFile, "%20.6e", measAng );
    fprintf( pOutFile, "%20.6d", measValid );
    fprintf( pOutFile, "%20.6e", rinAng );
    fprintf( pOutFile, "%20.6e", timeStamp );

    fprintf( pOutFile, "%20.6e", truAng );
    fprintf( pOutFile, "%20.6e", truRdot );
    fprintf( pOutFile, "%20.6e", truRng );

    fprintf( pOutFile, "%20.6e", vxf );
    fprintf( pOutFile, "%20.6e", vyf );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x168(%rdi)
testl %esi, %esi
je 0xef5e
leaq 0x61a0(%rip), %r14      # 0x15040
leaq 0x6c7d(%rip), %rdx      # 0x15b24
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c75(%rip), %rdx      # 0x15b30
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c6f(%rip), %rdx      # 0x15b3e
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c66(%rip), %rdx      # 0x15b49
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c60(%rip), %rdx      # 0x15b57
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c57(%rip), %rdx      # 0x15b62
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c4f(%rip), %rdx      # 0x15b6e
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c46(%rip), %rdx      # 0x15b79
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x6c3a(%rip), %rdx      # 0x15b81
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3270
movq %rdi, %r14
movsd 0x118(%rdi), %xmm0
leaq 0x60fa(%rip), %r15      # 0x1506a
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movzbl 0x120(%r14), %edx
leaq 0x6bfd(%rip), %rsi      # 0x15b89
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
movsd 0x110(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x128(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x130(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x180(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x188(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x1a0(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x1a8(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3270
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::AddModel(MdlBase*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SimExec::AddModel( MdlBase *pMdl, string mdlName )
{
  mdlVec.push_back( pMdl );

  //
  // Pointer to simExec's time
  //
  pMdl->SetSimTime( &simTime );

  pMdl->mdlName = mdlName;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r15
movq %rsi, (%r15)
addq $0x218, %rdi            # imm = 0x218
movq %r15, %rsi
callq 0x11d2a
movq (%r15), %rdi
addq $0x208, %r14            # imm = 0x208
movq %r14, 0x38(%rdi)
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x3100
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::Initialize()
void  SimExec::Initialize()
{
  int idx;

  ResetAll();

  for ( idx = 0; idx < mdlVec.size(); idx++ )
  {
    mdlVec[idx]->Initialize();
  }

  outputTimeStep = 1.0 / outputRate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xf42a
xorl %r14d, %r14d
movq 0x218(%rbx), %rax
movq 0x220(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0xf40d
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
incq %r14
jmp 0xf3e4
movsd 0x5c23(%rip), %xmm0     # 0x15038
divsd 0x158(%rbx), %xmm0
movsd %xmm0, 0x390(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::Integrate()
void SimExec::Integrate()
{
  int idx;
  MdlBase *pMdl;
  

  for ( idx = 0; idx < mdlVec.size(); ++idx )
  {
    pMdl = mdlVec[idx];
    if ( pMdl->intEn )
    {
      pMdl->Integrate( deltaTime );
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x258(%rdi), %r14
xorl %r15d, %r15d
movq 0x218(%rbx), %rax
movq 0x220(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0xf4f0
movq (%rax,%r15,8), %rdi
cmpb $0x1, 0x40(%rdi)
jne 0xf4eb
movq %r14, %rsi
callq 0x9f32
incq %r15
jmp 0xf4bf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::FrameUpdate()
void SimExec::FrameUpdate()
{
  int    idx;
  double temp;

  //
  // Write selected variables to output file
  //
  if ( (simTime >= outputTime) && (pOutFile != NULL) )
  {
    Output( false, pOutFile );

    outputTime += outputTimeStep;
  }

  //
  // Start next time step calculation with the sim time step.
  //
  deltaTime = timeStep;

  if ( simTime >= nextFrameTime - SMALL )
  {
    nextFrameTime += timeStep;
  }

  temp = nextFrameTime - simTime;
  if ( deltaTime - temp > SMALL )
  {
    deltaTime = temp;
  }

  //
  // Check output time step
  //
  if (pOutFile != NULL )    
  {
    temp = outputTime - simTime;
    if ( deltaTime - temp > SMALL )
    {
      deltaTime = temp;
    }
  }

  //
  // Perform model frame updates.
  //
  for ( idx = 0; idx < mdlVec.size(); ++idx )
  {
    pMdl = mdlVec[idx];

    if ( simTime >= pMdl->nextFrameTime - SMALL )
    {
      pMdl->FrameUpdate();

      pMdl->nextFrameTime += pMdl->frameTimeStep;
    }

    //
    //  Check the models for the next time step.
    //
    temp = pMdl->nextFrameTime - simTime;
    if ( deltaTime - temp > SMALL )
    {
      deltaTime = temp;
    }

  }  // end for ( idx = 0; idx < mdlVec.size(); ++idx )

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movsd 0x208(%rdi), %xmm0
movsd 0x388(%rdi), %xmm2
ucomisd %xmm2, %xmm0
jb 0xf58f
movq 0x210(%rbx), %rdx
testq %rdx, %rdx
je 0xf58f
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movsd 0x208(%rbx), %xmm0
movsd 0x390(%rbx), %xmm2
addsd 0x388(%rbx), %xmm2
movsd %xmm2, 0x388(%rbx)
movsd 0x30(%rbx), %xmm3
movsd 0x180(%rbx), %xmm1
movsd %xmm1, 0x258(%rbx)
movsd 0x6124(%rip), %xmm4     # 0x156d0
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm0
jb 0xf5bf
addsd %xmm1, %xmm3
movsd %xmm3, 0x30(%rbx)
subsd %xmm0, %xmm3
movapd %xmm1, %xmm4
subsd %xmm3, %xmm4
ucomisd 0x65c5(%rip), %xmm4     # 0x15b98
jbe 0xf5e1
movsd %xmm3, 0x258(%rbx)
movapd %xmm3, %xmm1
cmpq $0x0, 0x210(%rbx)
je 0xf60d
subsd %xmm0, %xmm2
movapd %xmm1, %xmm3
subsd %xmm2, %xmm3
ucomisd 0x6599(%rip), %xmm3     # 0x15b98
jbe 0xf60d
movsd %xmm2, 0x258(%rbx)
movapd %xmm2, %xmm1
xorl %r14d, %r14d
movsd 0x60b8(%rip), %xmm4     # 0x156d0
movsd 0x6578(%rip), %xmm5     # 0x15b98
movq 0x218(%rbx), %rax
movq 0x220(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0xf6be
movq (%rax,%r14,8), %rdi
movq %rdi, 0x230(%rbx)
movsd 0x30(%rdi), %xmm2
movapd %xmm2, %xmm3
addsd %xmm4, %xmm3
ucomisd %xmm3, %xmm0
jb 0xf698
movq (%rdi), %rax
callq *0x28(%rax)
movsd 0x652e(%rip), %xmm5     # 0x15b98
movsd 0x605e(%rip), %xmm4     # 0x156d0
movq 0x230(%rbx), %rax
movsd 0x8(%rax), %xmm2
addsd 0x30(%rax), %xmm2
movsd %xmm2, 0x30(%rax)
movsd 0x208(%rbx), %xmm0
movsd 0x258(%rbx), %xmm1
subsd %xmm0, %xmm2
movapd %xmm1, %xmm3
subsd %xmm2, %xmm3
ucomisd %xmm5, %xmm3
jbe 0xf6b6
movsd %xmm2, 0x258(%rbx)
movapd %xmm2, %xmm1
incq %r14
jmp 0xf620
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::process_command_line(int, char**)
void SimExec::process_command_line( int argc,
                                    char *argv[] )
{
  int  i;
  char name[512];
  char val[512];

  if (argc > 1) 
  {
    for (i=1; i<=argc-1; i++)
    {
      get_args(argv[i], name, val);

      parse_symbols(name, val);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdx, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x1067f
movq %rdi, %r14
movl %esi, %r13d
pushq $0x1
popq %rbx
leaq -0x430(%rbp), %r15
leaq -0x230(%rbp), %r12
cmpq %rbx, %r13
je 0x1067f
movq -0x30(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x107da
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1084e
incq %rbx
jmp 0x10654
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::Output(bool, _IO_FILE*)
void SimExec::Output( bool  printHeader,
                      FILE *pOutFile )
{
  int idx;

  if ( printHeader )
  {
    fprintf( pOutFile, "%20s", "simTime");
    fprintf( pOutFile, "%20s", "seed");
  }
  else
  {
    fprintf( pOutFile, "%20.6e", simTime ); 
    fprintf( pOutFile, "%20d", runSeed ); 
  }

  for ( idx = 0; idx < mdlVec.size(); ++idx )
  {
    mdlVec[idx]->Output( printHeader,
                         pOutFile );
  }

  fprintf( pOutFile, "\n" );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
testl %esi, %esi
je 0x1075f
leaq 0x490b(%rip), %r12      # 0x15040
leaq 0x55a9(%rip), %rdx      # 0x15ce5
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x54e4(%rip), %rdx      # 0x15c34
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
jmp 0x10791
movsd 0x208(%r14), %xmm0
leaq 0x48fb(%rip), %rsi      # 0x1506a
movq %rbx, %rdi
movb $0x1, %al
callq 0x3270
movl 0x3ac(%r14), %edx
leaq 0x5566(%rip), %rsi      # 0x15ced
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3270
xorl %r12d, %r12d
movzbl %r15b, %r15d
movq 0x218(%r14), %rax
movq 0x220(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x107c7
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movl %r15d, %esi
movq %rbx, %rdx
callq *0x30(%rax)
incq %r12
jmp 0x10798
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3220
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::read_file(char*)
void SimExec::read_file( char *filename )
{
  FILE *fp;
  char name[512];
  char val[512];
  char line[512];
  int  num_syms = 0;


  if ((fp = fopen(filename, "r")) != NULL) 
  {

    while (!feof(fp)) 
    {

      fgets(line, 512, fp);

      if ((line[0] != '#') && !(isspace(line[0]))) 
      {
        get_args(line, name, val);

        parse_symbols(name, val);

        num_syms++;
      }
    }

    fclose(fp);
  }
  else 
  {
    printf("Nonfatal error opening file %s\n", filename);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x608, %rsp            # imm = 0x608
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4b55(%rip), %rsi      # 0x15f3a
movq %r15, %rdi
callq 0x31f0
testq %rax, %rax
je 0x11477
movq %rax, %r14
leaq -0x230(%rbp), %r15
leaq -0x630(%rbp), %r12
leaq -0x430(%rbp), %r13
movq %r14, %rdi
callq 0x32b0
testl %eax, %eax
jne 0x1145d
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdx
callq 0x32d0
movsbl -0x230(%rbp), %edi
cmpl $0x23, %edi
je 0x1140e
callq 0x3050
testl %eax, %eax
jne 0x1140e
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x107da
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1084e
jmp 0x1140e
movq %r14, %rdi
callq 0x31b0
addq $0x608, %rsp            # imm = 0x608
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4874(%rip), %rdi      # 0x15cf2
movq %r15, %rsi
xorl %eax, %eax
addq $0x608, %rsp            # imm = 0x608
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3040
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::get_boolean(char*)
int SimExec::get_boolean(char *str)
{
  if ( (strcmp(str, "0\n") == 0) ||
    (strcmp(str, "0") == 0) ||
    (strcmp(str, "false\n") == 0) ||
    (strcmp(str, "false") == 0) )
    return 0;

  if ( (strcmp(str, "1\n") == 0) ||
    (strcmp(str, "1") == 0) ||
    (strcmp(str, "true\n") == 0) ||
    (strcmp(str, "true") == 0) )
    return 1;

  printf("Error in input to get_boolean() - %s, exiting\n", str);

  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rsi), %r15b
cmpb $0x30, %r15b
jne 0x11b8c
cmpb $0xa, 0x1(%rbx)
jne 0x11b82
cmpb $0x0, 0x2(%rbx)
je 0x11c0f
cmpb $0x0, 0x1(%rbx)
je 0x11c0f
leaq 0x5591(%rip), %rsi      # 0x17124
movq %rbx, %rdi
callq 0x3260
xorl %r14d, %r14d
testl %eax, %eax
je 0x11c12
leaq 0x416e(%rip), %rsi      # 0x15d17
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x11c12
pushq $0x1
popq %r14
cmpb $0x31, %r15b
jne 0x11bd1
cmpb $0xa, 0x1(%rbx)
jne 0x11bcb
cmpb $0x0, 0x2(%rbx)
je 0x11c12
cmpb $0x0, 0x1(%rbx)
je 0x11c12
leaq 0x5553(%rip), %rsi      # 0x1712b
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x11c12
leaq 0x4127(%rip), %rsi      # 0x15d12
movq %rbx, %rdi
callq 0x3260
testl %eax, %eax
je 0x11c12
leaq 0x5533(%rip), %rdi      # 0x17131
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3040
xorl %edi, %edi
callq 0x3200
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::get_list_index(char*, char**, int)
int SimExec::get_list_index( char *val,
                             char **list,
                             int  max_index )
{
  int index_found = 0;
  int index = 0;
  int i, tmpN;

  if (isdigit(val[0]))
    return atoi(val);

  tmpN=strlen(val);
  if (val[tmpN-1]=='\n')
    val[tmpN-1]='\0';

  if (val[tmpN-1]=='\r')
    val[tmpN-1]='\0';

  // TBD: Not sure why this works, but seems necessary for unix runs
  //  val[tmpN-1]='\0';
  //  val[tmpN-2]='\0';

  while (!index_found && (index<max_index))
  {
    //    if ((strcmp(val, list[index]) == 0) || (((strncmp(val, list[index],strlen(val)-2) == 0)) & (InWindows < 1)) )
    if ((strcmp(val, list[index]) == 0) )
      index_found = 1;
    else
      index++;
  }

  if (!index_found)
  {
    printf("Invalid mode in get_list_index: %s chosen from { ", val);

    for (i=0; i < max_index; i++)
      printf("%s ", list[i]);

    printf("}\n");
    printf("... exiting\n");

    exit(0);

  }
  else
  {

    return index;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movsbl (%rsi), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x11c49
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x32c0
movl %ecx, %ebx
movq %rdx, %r14
movq %r15, %rdi
callq 0x30c0
decl %eax
cltq
movzbl (%r15,%rax), %ecx
cmpl $0xd, %ecx
je 0x11c69
cmpl $0xa, %ecx
jne 0x11c6e
movb $0x0, (%r15,%rax)
xorl %r12d, %r12d
movb $0x1, %cl
testb $0x1, %cl
je 0x11c98
cmpl %ebx, %r12d
jge 0x11c98
movl %r12d, %eax
movq (%r14,%rax,8), %rsi
movq %r15, %rdi
callq 0x3260
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
addl %ecx, %r12d
jmp 0x11c73
testb $0x1, %cl
jne 0x11ca9
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x54b0(%rip), %rdi      # 0x17160
xorl %r12d, %r12d
movq %r15, %rsi
xorl %eax, %eax
callq 0x3040
testl %ebx, %ebx
cmovlel %r12d, %ebx
leaq 0x54c8(%rip), %r15      # 0x17192
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x11ce5
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3040
incq %r12
jmp 0x11ccd
leaq 0x5809(%rip), %rdi      # 0x174f5
callq 0x32a0
leaq 0x57ff(%rip), %rdi      # 0x174f7
callq 0x32a0
xorl %edi, %edi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Target.cpp
// Function: Target::Target()
Target::Target() :
MdlBase()
{
  //
  // Default initialization of input variables
  //
  frameTimeStep = 999.0e9;
  initFrameTime = 999.0e9;

//  initVxb = 1.0e3;
  initVxb = 270.0;
  weaveAmpl = 4.0 * GRAVITY;
  weavePeriod = 10;

  weaveStart = 999.e9;
  weaveEnd = -1.0;

  //
  // Register states for integration
  //
  RegisterState( pxf, vxf);
  RegisterState( pyf, vyf);

  RegisterState( vxf, axf);
  RegisterState( vyf, ayf);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9cd8
leaq 0xa787(%rip), %rax      # 0x1cc98
movq %rax, (%rbx)
movabsq $0x426d132148c00000, %rax # imm = 0x426D132148C00000
movq %rax, 0x8(%rbx)
movq %rax, 0xf8(%rbx)
movabsq $0x4070e00000000000, %rcx # imm = 0x4070E00000000000
movq %rcx, 0x100(%rbx)
movabsq $0x40439eb851eb851f, %rcx # imm = 0x40439EB851EB851F
movq %rcx, 0x118(%rbx)
movabsq $0x4024000000000000, %rcx # imm = 0x4024000000000000
movq %rcx, 0x120(%rbx)
movq %rax, 0x108(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x110(%rbx)
leaq 0x160(%rbx), %rsi
leaq 0x180(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9ef0
leaq 0x168(%rbx), %rsi
leaq 0x190(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9ef0
leaq 0x130(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9ef0
leaq 0x140(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9ef0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9dd6
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Target.cpp
// Function: Target::Initialize()
void Target::Initialize()
{
  double cth;
  double sth;

  ResetAll();

  simTime = GetSimTime();
  
  nextFrameTime = initFrameTime;

  omega = TWOPI / weavePeriod;

  //
  // Crossing angle and flight path angle are supplements of each other.
  //
  theta = PI - pExec->xa;

  cth = cos( theta );
  sth = sin( theta );

  vxb = initVxb;
  vyb = 0.0;

  vxf = vxb * cth - vyb * sth;
  vyf = vxb * sth + vyb * cth;;

  pxf = -pExec->tFinal * vxf;
  pyf = -pExec->tFinal * vyf;

  weavePhase = uniform( -PI, PI, &pExec->seed );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x1a0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x128(%rdi)
movups %xmm0, 0x138(%rdi)
movups %xmm0, 0x158(%rdi)
movups %xmm0, 0x168(%rdi)
movups %xmm0, 0x178(%rdi)
movups %xmm0, 0x188(%rdi)
movb $0x0, 0x198(%rdi)
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0xf8(%rdi), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x4e92(%rip), %xmm0     # 0x17510
divsd 0x120(%rdi), %xmm0
movsd %xmm0, 0x158(%rdi)
movq 0x1b0(%rdi), %rax
movsd 0x351b(%rip), %xmm0     # 0x15bb8
subsd 0x188(%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
callq 0x3360
movsd %xmm0, -0x10(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3080
movsd 0x100(%rbx), %xmm1
movsd %xmm1, 0x178(%rbx)
andq $0x0, 0x188(%rbx)
movsd 0x4e34(%rip), %xmm2     # 0x17518
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
movsd -0x10(%rbp), %xmm4
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x180(%rbx)
xorpd %xmm2, %xmm2
mulsd %xmm4, %xmm2
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x190(%rbx)
movq 0x1b0(%rbx), %rdi
movsd 0x178(%rdi), %xmm0
xorpd 0x28e0(%rip), %xmm0     # 0x15010
mulsd %xmm0, %xmm3
movsd %xmm3, 0x160(%rbx)
mulsd %xmm1, %xmm0
movsd %xmm0, 0x168(%rbx)
addq $0x200, %rdi            # imm = 0x200
movsd 0x4dc9(%rip), %xmm0     # 0x17520
movsd 0x3459(%rip), %xmm1     # 0x15bb8
callq 0x964a
movsd %xmm0, 0x1a8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Target.cpp
// Function: Target::Update()
void Target::Update()
{
  double tempAxf;
  double tempAyf;

  simTime = GetSimTime();
  
  if ( (simTime < weaveStart) || (simTime > weaveEnd) )
  {
    axb = 0.0;
    ayb = 0.0;
  }
  else
  {
    if ( !weaveInit )
    {
      weaveInit = true;

      vyf = -( weaveAmpl / omega ) * cos( weavePhase );

      pyf = -( weaveAmpl / SQ(omega) ) * sin( weavePhase );
    }

    tempAxf = 0.0;
    tempAyf = weaveAmpl * sin( simTime * omega + weavePhase );

    axb =  tempAxf * cos(theta) + tempAyf * sin(theta);
    ayb = -tempAxf * sin(theta) + tempAyf * cos(theta);

    jxf = 0.0;
    jyf = weaveAmpl * omega * cos( simTime * omega );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0x108(%rdi), %xmm1
ucomisd %xmm0, %xmm1
ja 0x12976
ucomisd 0x110(%rbx), %xmm0
ja 0x12976
cmpb $0x0, 0x198(%rbx)
jne 0x1289a
movb $0x1, 0x198(%rbx)
movsd 0x118(%rbx), %xmm0
xorpd 0x27e4(%rip), %xmm0     # 0x15010
divsd 0x158(%rbx), %xmm0
movapd %xmm0, -0x20(%rbp)
movsd 0x1a8(%rbx), %xmm0
callq 0x3360
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x190(%rbx)
movsd 0x158(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd 0x118(%rbx), %xmm1
xorpd 0x27a1(%rip), %xmm1     # 0x15010
divsd %xmm0, %xmm1
movapd %xmm1, -0x20(%rbp)
movsd 0x1a8(%rbx), %xmm0
callq 0x3080
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x168(%rbx)
movsd 0x1a0(%rbx), %xmm0
movsd 0x118(%rbx), %xmm1
movsd %xmm1, -0x20(%rbp)
mulsd 0x158(%rbx), %xmm0
addsd 0x1a8(%rbx), %xmm0
callq 0x3080
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3360
movsd %xmm0, -0x28(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3080
mulsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
mulsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x128(%rbx)
movsd 0x170(%rbx), %xmm0
callq 0x3080
movsd %xmm0, -0x28(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3360
mulsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd 0x4be8(%rip), %xmm1     # 0x17518
addsd %xmm0, %xmm1
movsd %xmm1, 0x138(%rbx)
andq $0x0, 0x148(%rbx)
movsd 0x158(%rbx), %xmm0
movsd 0x118(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
mulsd 0x1a0(%rbx), %xmm0
callq 0x3360
mulsd -0x20(%rbp), %xmm0
movl $0x150, %eax            # imm = 0x150
jmp 0x12987
andq $0x0, 0x128(%rbx)
xorpd %xmm0, %xmm0
movl $0x138, %eax            # imm = 0x138
movsd %xmm0, (%rbx,%rax)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Construct(int, int, double)
void Matrix::Construct(int    _rows,
                       int    _cols,
                       double initVal)
{
  rows = _rows;
  cols = _cols;
  nElem = rows * cols;

  pData = new double[nElem];

  if (pData == NULL)
  {
    throw(MEMERR());
  }

  Set(initVal);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, (%rdi)
imull %esi, %edx
movl %edx, 0x4(%rdi)
leaq (,%rdx,8), %rax
testl %edx, %edx
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12db8
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix &mat)
{
  double *ptr1(mat.pData);
  double *ptr2(NULL);
  int _rows(mat.rows);
  int _cols(mat.cols);

  Construct(_rows, _cols);
  ptr2 = pData;

  for (int idx = 0; idx < nElem; ++idx)
  {
    *ptr2++ = *ptr1++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movl (%rsi), %edx
movl 0x8(%rsi), %esi
callq 0x12d82
movq 0x10(%rbx), %rax
movl 0x4(%rbx), %ecx
xorl %edx, %edx
cmpl %ecx, %edx
jge 0x12d7d
movsd (%r14,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x12d69
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Construct(int, int)
void Matrix::Construct(int _rows,
                       int _cols)
{
  rows = _rows;
  cols = _cols;
  nElem = rows * cols;

  pData = new double[nElem];

  if (pData == NULL)
  {
    throw(MEMERR());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, (%rdi)
imull %esi, %edx
movl %edx, 0x4(%rdi)
leaq (,%rdx,8), %rax
testl %edx, %edx
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Resize(int, int, double)
void Matrix::Resize(int _rows, int _cols, double initVal)
{
  if (pData != NULL)
  {
    delete [] pData;
  }

  rows = _rows;
  cols = _cols;
  nElem = _rows * _cols;
  {
    Construct(rows, cols, initVal);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x12e26
movsd %xmm0, -0x20(%rbp)
callq 0x3230
movsd -0x20(%rbp), %xmm0
movl %r14d, 0x8(%r15)
movl %ebx, (%r15)
movl %ebx, %eax
imull %r14d, %eax
movl %eax, 0x4(%r15)
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12d02
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetPtr(int, int)
bool Matrix::CheckDim(int row, int col)
{
  bool pass(false);

  if ((row >= 0) &&
      (row < rows) &&
      (col >=0 ) &&
      (col < cols))
  {
    pass = true;
  }

  return pass;
}

// Assembly:
testl %esi, %esi
js 0x12eb7
testl %edx, %edx
js 0x12eb7
cmpl %esi, 0x8(%rdi)
jle 0x12eb7
movl (%rdi), %eax
cmpl %edx, %eax
jle 0x12eb7
imull %esi, %eax
cltq
shlq $0x3, %rax
addq 0x10(%rdi), %rax
movl %edx, %ecx
leaq (%rax,%rcx,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x9e7e(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9e1c(%rip), %rsi      # 0x1ccf0
movq 0xa105(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetPtr(int)
double* Matrix::GetPtr(int idx)
{
  bool pass = CheckDim(idx);
  double *ptr(NULL);

  if (pass)
  {
    ptr = pData + idx;
  }
  else
  {
    throw(DIMERR());
  }

  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x12e70
testb %al, %al
je 0x12f0a
movslq %r14d, %rax
shlq $0x3, %rax
addq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x9e2f(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9dcd(%rip), %rsi      # 0x1ccf0
movq 0xa0b6(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::Print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Matrix::Print(string format)
{
  double *pElem(pData);

  if (rows > 1)
  {
    for (int row = 0; row < rows; ++row)
    {
      for (int col = 0; col < cols; ++col)
      {
        printf(format.c_str(), *pElem);
        ++pElem;
      }
      printf("\n");
    }
  }
  else
  {
    for (int col = 0; col < cols; ++col)
    {
      printf(format.c_str(), *pElem);
      ++pElem;
    }
    printf("\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
movl 0x8(%rdi), %eax
cmpl $0x1, %eax
jle 0x12ff4
xorl %r13d, %r13d
cmpl %eax, %r13d
jge 0x13011
xorl %r15d, %r15d
cmpl (%r14), %r15d
jge 0x12fe3
movq (%rbx), %rdi
movsd (%r12), %xmm0
movb $0x1, %al
callq 0x3040
addq $0x8, %r12
incl %r15d
jmp 0x12fc5
pushq $0xa
popq %rdi
callq 0x3250
incl %r13d
movl 0x8(%r14), %eax
jmp 0x12fbd
xorl %r15d, %r15d
cmpl (%r14), %r15d
jge 0x13020
movq (%rbx), %rdi
movsd (%r12,%r15,8), %xmm0
movb $0x1, %al
callq 0x3040
incq %r15
jmp 0x12ff7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3250
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetRow(int)
Matrix Matrix::GetRow(int row)
{
  if ((row < 0) ||
      (row >= rows))
  {
    throw(DIMERR());
  }

  Matrix result(1, cols);
  double *ptr1(pData + row * cols);
  double *ptr2(result.pData);

  for (int col = 0; col < cols; ++col)
  {
    *ptr2++ = *ptr1++;
  }
  
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x13106
movl %edx, %r15d
movq %rsi, %r14
cmpl %edx, 0x8(%rsi)
jle 0x13106
movq %rdi, %rbx
movl (%r14), %edx
pushq $0x1
popq %rsi
xorps %xmm0, %xmm0
callq 0x12d02
movl (%r14), %eax
imull %eax, %r15d
movslq %r15d, %rcx
shlq $0x3, %rcx
addq 0x10(%r14), %rcx
movq 0x10(%rbx), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpl %esi, %eax
je 0x130f8
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x130e5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x9c33(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9bd1(%rip), %rsi      # 0x1ccf0
movq 0x9eba(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetCol(int)
Matrix Matrix::GetCol(int col)
{
  if ((col < 0) ||
      (col >= cols))
  {
    throw(DIMERR());
  }

  Matrix result(rows, 1);
  double *ptr1(pData + col);
  double *ptr2(result.pData);

  for (int row = 0; row < rows; ++row)
  {
    *ptr2++ = *ptr1;
    ptr1 += cols;
  }
  
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x13197
movl %edx, %r15d
movq %rsi, %r14
cmpl %edx, (%rsi)
jle 0x13197
movq %rdi, %rbx
movl 0x8(%r14), %esi
pushq $0x1
popq %rdx
xorps %xmm0, %xmm0
callq 0x12d02
movl %r15d, %eax
shlq $0x3, %rax
addq 0x10(%r14), %rax
movq 0x10(%rbx), %rcx
movl 0x8(%r14), %edx
movslq (%r14), %rsi
shlq $0x3, %rsi
xorl %edi, %edi
cmpl %edx, %edi
jge 0x13189
movsd (%rax), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
addq %rsi, %rax
incq %rdi
jmp 0x13174
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x9ba2(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9b40(%rip), %rsi      # 0x1ccf0
movq 0x9e29(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator()(int)
double& Matrix::operator()(int idx)
{
  bool pass = CheckDim(idx);

  if (!pass)
  {
    throw(DIMERR());
  }

  double &rVal(*GetPtr(idx));

  return rVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x12e70
testb %al, %al
je 0x131e3
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x12ee4
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x9b56(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9af4(%rip), %rsi      # 0x1ccf0
movq 0x9ddd(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator[](int)
double* Matrix::operator[](int row)
{
  if ((row < 0) || (row > rows - 1))
  {
    throw(DIMERR());
  }

  double *pRow(pData + row * cols);

  return pRow;
}

// Assembly:
testl %esi, %esi
js 0x1326a
cmpl %esi, 0x8(%rdi)
jle 0x1326a
movslq (%rdi), %rcx
movslq %esi, %rax
imulq %rcx, %rax
shlq $0x3, %rax
addq 0x10(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x9acb(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9a69(%rip), %rsi      # 0x1ccf0
movq 0x9d52(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator=(Matrix)
Matrix Matrix::operator= (Matrix mat)
{
  double *ptr1 = mat.pData;
  double *ptr2(NULL);
  int    _rows = mat.NumRows();
  int    _cols = mat.NumCols();

  Construct(_rows, _cols);
  ptr2 = pData;

  for (int idx = 0; idx < nElem; ++idx)
  {
    *ptr2++ = *ptr1++;
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %r15
movl (%rdx), %eax
movl 0x8(%rdx), %esi
movq %r14, %rdi
movl %eax, %edx
callq 0x12d82
movq 0x10(%r14), %rax
movl 0x4(%r14), %ecx
xorl %edx, %edx
cmpl %ecx, %edx
jge 0x132d7
movsd (%r15,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x132c3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12d48
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator+(Matrix) const
Matrix Matrix::operator+ (const Matrix rhs) const
{
  if ((rows != rhs.rows) ||
      (cols != rhs.cols))
  {
    throw(DIMERR()); 
  }

  Matrix result(rows, cols);

  for (int idx = 0; idx < nElem; ++idx)
  {
    result.pData[idx] = pData[idx] + rhs.pData[idx];
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl 0x8(%rsi), %esi
cmpl 0x8(%rdx), %esi
jne 0x13382
movq %rdx, %rbx
movl (%r15), %edx
cmpl (%rbx), %edx
jne 0x13382
movq %rdi, %r14
xorpd %xmm0, %xmm0
callq 0x12d02
movslq 0x4(%r15), %rax
movq 0x10(%r15), %rcx
movq 0x10(%r14), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x13374
movsd (%rcx,%rsi,8), %xmm0
movq 0x10(%rbx), %rdi
addsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x13357
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x99b7(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9955(%rip), %rsi      # 0x1ccf0
movq 0x9c3e(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator/(Matrix) const
Matrix Matrix::operator/ (const Matrix rhs) const
{
  if ((rows != rhs.rows) ||
      (cols != rhs.cols))
  {
    throw(DIMERR()); 
  }

  Matrix result(rows, cols);

  for (int idx = 0; idx < nElem; ++idx)
  {
    if (rhs.pData[idx] == 0.0)
    {
      throw(DIVBYZERO());
    }

    result.pData[idx] = pData[idx] / rhs.pData[idx];
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl 0x8(%rsi), %esi
cmpl 0x8(%rdx), %esi
jne 0x134d7
movq %rdx, %r14
movl (%r15), %edx
cmpl (%r14), %edx
jne 0x134d7
movq %rdi, %rbx
xorpd %xmm0, %xmm0
callq 0x12d02
movslq 0x4(%r15), %rax
movq 0x10(%r15), %rcx
movq 0x10(%rbx), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x134a1
movq 0x10(%r14), %rdi
movsd (%rdi,%rsi,8), %xmm0
ucomisd 0x213e(%rip), %xmm0     # 0x155c8
jne 0x1348e
jnp 0x134af
movsd (%rcx,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
jmp 0x13474
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x98b2(%rip), %rcx      # 0x1cd70
movq %rcx, (%rax)
leaq 0x9840(%rip), %rsi      # 0x1cd08
movq 0x9b11(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x9862(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x9800(%rip), %rsi      # 0x1ccf0
movq 0x9ae9(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
movq %rax, %r14
movq %rbx, %rdi
callq 0x12dd8
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::operator*(Matrix) const
Matrix Matrix::operator* (const Matrix rhs) const
{
  if (cols != rhs.rows)
  {
    throw(DIMERR()); 
  }

  Matrix result(rows, rhs.cols);

  double *pResElem(result.pData);
  double *pRhsCol(rhs.pData);
  double *pLhsRow(pData);

  for (int lhsRow = 0; lhsRow < rows; ++lhsRow)
  {
    for (int rhsCol = 0; rhsCol < rhs.cols; ++rhsCol)
    {
      pLhsRow = pData + lhsRow * cols;
      pRhsCol = rhs.pData + rhsCol;
      for (int resIdx = 0; resIdx < cols; ++resIdx)
      {
        *pResElem += *pLhsRow++ * *pRhsCol;
        pRhsCol += rhs.cols; 
      }
      ++pResElem;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0x135df
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %esi
movl (%rdx), %edx
xorpd %xmm0, %xmm0
callq 0x12d02
movq 0x10(%r14), %rax
movl 0x8(%r15), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpl %ecx, %edx
je 0x135cd
movslq (%rbx), %rsi
movl (%r15), %r9d
testl %r9d, %r9d
movl $0x0, %edi
cmovgl %r9d, %edi
testl %esi, %esi
movl $0x0, %r8d
cmovgl %esi, %r8d
shlq $0x3, %rsi
imull %edx, %r9d
movslq %r9d, %r9
shlq $0x3, %r9
addq 0x10(%r15), %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpq %r8, %r11
je 0x135c9
movq 0x10(%rbx), %r12
addq %r10, %r12
xorl %r13d, %r13d
cmpl %r13d, %edi
je 0x135bc
movsd (%r9,%r13,8), %xmm0
mulsd (%r12), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq %rsi, %r12
incq %r13
jmp 0x1359b
addq $0x8, %rax
incq %r11
addq $0x8, %r10
jmp 0x1358c
incl %edx
jmp 0x13551
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x30e0
leaq 0x975a(%rip), %rcx      # 0x1cd48
movq %rcx, (%rax)
leaq 0x96f8(%rip), %rsi      # 0x1ccf0
movq 0x99e1(%rip), %rdx      # 0x1cfe0
movq %rax, %rdi
callq 0x3300
nop