LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/DavidLBruce[P]sim3dof/build/../src/MdlBase.cpp
// Function: MdlBase::RegisterState(double&, double&)
void MdlBase::RegisterState(double &state, double &deriv)
{
  double *ptr;
  ptr = &state; 
  m_state.push_back(ptr);

  ptr = &deriv; 
  m_deriv.push_back(ptr);

  intEn = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
movq 0x50(%rdi), %rsi
cmpq 0x58(%rdi), %rsi
je 0xa2ee
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0xa2fb
leaq 0x48(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0xa924
movq %r14, -0x18(%rbp)
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0xa313
movq %r14, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0xa320
leaq 0x60(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0xa924
movb $0x1, 0x40(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DavidLBruce[P]sim3dof/build/../src/Missile.cpp
// Function: Missile::Missile()
Missile::Missile() :
MdlBase()
{
  //
  // Default initialization of input variables
  //
  frameTimeStep = 999.0e9;
  initFrameTime = 999.0e9;

//  initVxb = 270.0;
//  launchTime = 3.0;

  initVxb = 1.0e3;
  launchTime = 30.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 0x9fd0
leaq 0x12e53(%rip), %rax     # 0x1daf8
movq %rax, (%rbx)
movabsq $0x426d132148c00000, %rax # imm = 0x426D132148C00000
movq %rax, 0x8(%rbx)
movq %rax, 0xf8(%rbx)
movabsq $0x408f400000000000, %rax # imm = 0x408F400000000000
movq %rax, 0x100(%rbx)
movabsq $0x403e000000000000, %rax # imm = 0x403E000000000000
movq %rax, 0x108(%rbx)
leaq 0x130(%rbx), %rsi
leaq 0x150(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xa2c2
leaq 0x138(%rbx), %rsi
leaq 0x160(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa2c2
leaq 0x118(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa2c2
leaq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa2c2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa130
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %eax, %eax
movq %rax, 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), %rcx
movsd (%rcx), %xmm1
movsd %xmm1, 0x170(%rdi)
movsd 0xf8(%rdi), %xmm1
movsd %xmm1, 0x30(%rdi)
movups %xmm0, 0x148(%rdi)
movups %xmm0, 0x158(%rdi)
movq 0x180(%rdi), %rcx
movsd 0x178(%rcx), %xmm0
subsd 0x108(%rdi), %xmm0
xorpd 0xb20c(%rip), %xmm0     # 0x16010
mulsd 0x100(%rdi), %xmm0
movsd %xmm0, 0x130(%rdi)
movq %rax, 0x138(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaec2
cmpb $0x0, 0x168(%rdi)
jne 0xaec2
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_O3/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 0xb94c
movq 0x38(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x4d0(%rbx)
cmpq $0x0, 0x510(%rbx)
je 0xb850
cmpq $0x0, 0x518(%rbx)
je 0xb86f
cmpq $0x0, 0x520(%rbx)
je 0xb88e
cmpq $0x0, 0x528(%rbx)
je 0xb8ad
cmpq $0x0, 0x530(%rbx)
je 0xb8cc
cmpq $0x0, 0x538(%rbx)
je 0xb8eb
cmpq $0x0, 0x540(%rbx)
je 0xb90a
leaq 0x310(%rbx), %r14
xorl %r15d, %r15d
movabsq $0x3ff0000000000000, %r12 # imm = 0x3FF0000000000000
movq %r14, %rdi
movl %r15d, %esi
callq 0x139a6
movq %r12, (%rax,%r15,8)
incq %r15
cmpq $0x6, %r15
jne 0xb787
leaq 0x328(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x139a6
movq %r12, (%rax)
movq %r14, %rdi
movl $0x1, %esi
callq 0x139a6
movq %r12, 0x10(%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x139a6
movq %r12, 0x18(%rax)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x133e2
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x157c0
leaq 0x340(%rbx), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x139f0
leaq -0x68(%rbp), %rdi
callq 0x134aa
leaq -0x38(%rbp), %rdi
callq 0x134aa
leaq -0x50(%rbp), %rdi
callq 0x134aa
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 0xacb5(%rip), %rdi      # 0x1650c
leaq 0xae7a(%rip), %rsi      # 0x166d8
leaq 0xae86(%rip), %rcx      # 0x166eb
movl $0x7f, %edx
callq 0x30f0
leaq 0xac9c(%rip), %rdi      # 0x16512
leaq 0xae5b(%rip), %rsi      # 0x166d8
leaq 0xae67(%rip), %rcx      # 0x166eb
movl $0x80, %edx
callq 0x30f0
leaq 0xac8a(%rip), %rdi      # 0x1651f
leaq 0xae3c(%rip), %rsi      # 0x166d8
leaq 0xae48(%rip), %rcx      # 0x166eb
movl $0x81, %edx
callq 0x30f0
leaq 0xae5a(%rip), %rdi      # 0x1670e
leaq 0xae1d(%rip), %rsi      # 0x166d8
leaq 0xae29(%rip), %rcx      # 0x166eb
movl $0x82, %edx
callq 0x30f0
leaq 0xac51(%rip), %rdi      # 0x16524
leaq 0xadfe(%rip), %rsi      # 0x166d8
leaq 0xae0a(%rip), %rcx      # 0x166eb
movl $0x83, %edx
callq 0x30f0
leaq 0xac37(%rip), %rdi      # 0x16529
leaq 0xaddf(%rip), %rsi      # 0x166d8
leaq 0xadeb(%rip), %rcx      # 0x166eb
movl $0x84, %edx
callq 0x30f0
leaq 0xae02(%rip), %rdi      # 0x16713
leaq 0xadc0(%rip), %rsi      # 0x166d8
leaq 0xadcc(%rip), %rcx      # 0x166eb
movl $0x85, %edx
callq 0x30f0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x134aa
jmp 0xb93a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x134aa
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9fd0
leaq 0xeba3(%rip), %rax      # 0x1dbc8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1b0(%rbx)
xorl %eax, %eax
movq %rax, 0x1c0(%rbx)
movabsq $0x3f76c16c16c16c17, %rcx # imm = 0x3F76C16C16C16C17
movq %rcx, 0x8(%rbx)
movq %rax, 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_O3/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
xorps %xmm3, %xmm3
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 0xf2c4
movsd 0x110(%rbx), %xmm1
movl $0x200, %edi            # imm = 0x200
addq 0x1b0(%rbx), %rdi
callq 0x983a
movb $0x1, %al
jmp 0xf2ca
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf3fc
leaq 0x6d02(%rip), %r14      # 0x16040
leaq 0x77df(%rip), %rdx      # 0x16b24
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x77d7(%rip), %rdx      # 0x16b30
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x77d1(%rip), %rdx      # 0x16b3e
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x77c8(%rip), %rdx      # 0x16b49
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x77c2(%rip), %rdx      # 0x16b57
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x77b9(%rip), %rdx      # 0x16b62
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x77b1(%rip), %rdx      # 0x16b6e
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x77a8(%rip), %rdx      # 0x16b79
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x779c(%rip), %rdx      # 0x16b81
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
movq %rdi, %r14
movsd 0x118(%rdi), %xmm0
leaq 0x6c5c(%rip), %r15      # 0x1606a
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movzbl 0x120(%r14), %edx
leaq 0x775f(%rip), %rsi      # 0x16b89
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3230
movsd 0x110(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x128(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x130(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x180(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x188(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x1a0(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
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 0x3230
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %rax
movq %rdi, %r14
movq %rsi, -0x20(%rbp)
movq 0x220(%rdi), %rsi
cmpq 0x228(%rdi), %rsi
je 0xf8fa
movq %rax, (%rsi)
addq $0x8, 0x220(%r14)
jmp 0xf910
leaq 0x218(%r14), %rdi
leaq -0x20(%rbp), %r15
movq %r15, %rdx
callq 0x125be
movq (%r15), %rax
addq $0x208, %r14            # imm = 0x208
movq %r14, 0x38(%rax)
addq $0x10, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x30d0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfb8f
movq 0x210(%rbx), %rdx
testq %rdx, %rdx
je 0xfb8f
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 0x6b24(%rip), %xmm4     # 0x166d0
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm0
jb 0xfbbf
addsd %xmm1, %xmm3
movsd %xmm3, 0x30(%rbx)
subsd %xmm0, %xmm3
movapd %xmm1, %xmm4
subsd %xmm3, %xmm4
ucomisd 0x6fc5(%rip), %xmm4     # 0x16b98
jbe 0xfbe1
movsd %xmm3, 0x258(%rbx)
movapd %xmm3, %xmm1
cmpq $0x0, 0x210(%rbx)
je 0xfc0d
subsd %xmm0, %xmm2
movapd %xmm1, %xmm3
subsd %xmm2, %xmm3
ucomisd 0x6f99(%rip), %xmm3     # 0x16b98
jbe 0xfc0d
movsd %xmm2, 0x258(%rbx)
movapd %xmm2, %xmm1
movq 0x218(%rbx), %rax
cmpq %rax, 0x220(%rbx)
je 0xfccd
xorl %r14d, %r14d
movsd 0x6aa4(%rip), %xmm4     # 0x166d0
movsd 0x6f64(%rip), %xmm5     # 0x16b98
movq (%rax,%r14,8), %rdi
movq %rdi, 0x230(%rbx)
movsd 0x30(%rdi), %xmm2
movapd %xmm2, %xmm3
addsd %xmm4, %xmm3
ucomisd %xmm3, %xmm0
jb 0xfc8e
movq (%rdi), %rax
callq *0x28(%rax)
movsd 0x6f38(%rip), %xmm5     # 0x16b98
movsd 0x6a68(%rip), %xmm4     # 0x166d0
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 0xfcac
movsd %xmm2, 0x258(%rbx)
movapd %xmm2, %xmm1
incq %r14
movq 0x218(%rbx), %rax
movq 0x220(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0xfc34
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, -0x30(%rbp)
cmpl $0x2, %esi
jl 0x10e26
movq %rdx, %r14
movl %esi, %r13d
movl $0x1, %ebx
leaq -0x430(%rbp), %r15
leaq -0x230(%rbp), %r12
movq (%r14,%rbx,8), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x10fa0
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1103a
incq %rbx
cmpq %rbx, %r13
jne 0x10e00
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f15
leaq 0x5155(%rip), %r12      # 0x16040
leaq 0x5df3(%rip), %rdx      # 0x16ce5
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x5d2e(%rip), %rdx      # 0x16c34
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3230
jmp 0x10f47
movsd 0x208(%r14), %xmm0
leaq 0x5145(%rip), %rsi      # 0x1606a
movq %rbx, %rdi
movb $0x1, %al
callq 0x3230
movl 0x3ac(%r14), %edx
leaq 0x5db0(%rip), %rsi      # 0x16ced
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3230
movq 0x218(%r14), %rax
cmpq %rax, 0x220(%r14)
je 0x10f8b
xorl %r12d, %r12d
movzbl %r15b, %r15d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movl %r15d, %esi
movq %rbx, %rdx
callq *0x30(%rax)
incq %r12
movq 0x218(%r14), %rax
movq 0x220(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x10f5e
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O3/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::get_args(char*, char*, char*)
void SimExec::get_args( char *in, char *name, char *val )
{
  int  i;
  int  length;

  char *ptr;

  length = strlen(in);
  if (length == 0)
  {
    strcpy(name, "");
    strcpy(val, "");
  }
  else
  {
    ptr = &in[0];

    i = 0;
    while ( (*ptr != '=') &&
            ( i < length) )
    {
      name[i] = *ptr;
      ptr++;
      i++;
    }

    name[i] = '\0';

    if (i == length)
    {
      val[0] = '\0';
    }
    else
    {
      ptr++;
      i = 0;

      while (*ptr!='\0')
      {
        val[i] = *ptr;
        ptr++;
        i++;
      }
      val[i] = '\0';
    }
  }

  ptr = NULL;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
callq 0x30a0
testl %eax, %eax
je 0x11021
movb (%r14), %dl
cmpb $0x3d, %dl
sete %sil
testl %eax, %eax
setle %dil
xorl %ecx, %ecx
orb %sil, %dil
jne 0x10ff9
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb %dl, (%r15,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
cmpb $0x3d, %dl
je 0x10ff6
cmpq %rsi, %rcx
jb 0x10fe0
addq %rcx, %r14
movl %ecx, %edx
movb $0x0, (%r15,%rdx)
cmpl %eax, %ecx
je 0x1102c
movb 0x1(%r14), %al
testb %al, %al
je 0x11027
xorl %ecx, %ecx
movb %al, (%rbx,%rcx)
movb 0x2(%r14,%rcx), %al
incq %rcx
testb %al, %al
jne 0x1100e
movl %ecx, %eax
jmp 0x11029
movb $0x0, (%r15)
jmp 0x1102c
xorl %eax, %eax
addq %rax, %rbx
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5369(%rip), %rsi      # 0x16f3a
movq %r15, %rdi
callq 0x31c0
testq %rax, %rax
je 0x11c6d
movq %rax, %r14
movq %rax, %rdi
callq 0x3270
testl %eax, %eax
jne 0x11c53
leaq -0x230(%rbp), %r15
leaq -0x630(%rbp), %r12
leaq -0x430(%rbp), %r13
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdx
callq 0x3290
movsbl -0x230(%rbp), %edi
cmpl $0x23, %edi
je 0x11c47
callq 0x3050
testl %eax, %eax
jne 0x11c47
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x10fa0
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1103a
movq %r14, %rdi
callq 0x3270
testl %eax, %eax
je 0x11c06
movq %r14, %rdi
callq 0x3180
addq $0x608, %rsp            # imm = 0x608
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x507e(%rip), %rdi      # 0x16cf2
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_O3/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 0x12386
cmpb $0xa, 0x1(%rbx)
jne 0x1237c
cmpb $0x0, 0x2(%rbx)
je 0x1240b
cmpb $0x0, 0x1(%rbx)
je 0x1240b
leaq 0x5d97(%rip), %rsi      # 0x18124
movq %rbx, %rdi
callq 0x3220
xorl %r14d, %r14d
testl %eax, %eax
je 0x12416
leaq 0x4974(%rip), %rsi      # 0x16d17
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
je 0x12416
cmpb $0x31, %r15b
jne 0x123c7
cmpb $0xa, 0x1(%rbx)
jne 0x123c1
cmpb $0x0, 0x2(%rbx)
je 0x12410
cmpb $0x0, 0x1(%rbx)
je 0x12410
leaq 0x5d5d(%rip), %rsi      # 0x1812b
movq %rbx, %rdi
callq 0x3220
movl $0x1, %r14d
testl %eax, %eax
je 0x12416
leaq 0x492b(%rip), %rsi      # 0x16d12
movq %rbx, %rdi
callq 0x3220
testl %eax, %eax
je 0x12416
leaq 0x5d37(%rip), %rdi      # 0x18131
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3040
xorl %edi, %edi
callq 0x31d0
xorl %r14d, %r14d
jmp 0x12416
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1244d
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3280
movl %ecx, %r14d
movq %rdx, %rbx
movq %r15, %rdi
callq 0x30a0
decl %eax
cltq
movzbl (%r15,%rax), %ecx
cmpl $0xd, %ecx
je 0x1246e
cmpl $0xa, %ecx
jne 0x12473
movb $0x0, (%r15,%rax)
testl %r14d, %r14d
jle 0x124ad
xorl %eax, %eax
movl %eax, %r12d
movl %eax, %eax
movq (%rbx,%rax,8), %rsi
movq %r15, %rdi
callq 0x3220
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addl %r12d, %eax
testl %ecx, %ecx
je 0x124a0
cmpl %r14d, %eax
jl 0x1247a
testl %ecx, %ecx
jne 0x124c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5cac(%rip), %rdi      # 0x18160
movq %r15, %rsi
xorl %eax, %eax
callq 0x3040
jmp 0x124f9
leaq 0x5c99(%rip), %rdi      # 0x18160
movq %r15, %rsi
xorl %eax, %eax
callq 0x3040
testl %r14d, %r14d
jle 0x124f9
movl %r14d, %r15d
leaq 0x5cb2(%rip), %r14      # 0x18192
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3040
incq %r12
cmpq %r12, %r15
jne 0x124e3
leaq 0x5ff5(%rip), %rdi      # 0x184f5
callq 0x3250
leaq 0x5feb(%rip), %rdi      # 0x184f7
callq 0x3250
xorl %edi, %edi
callq 0x31d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9fd0
leaq 0xb117(%rip), %rax      # 0x1dc98
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 0xa2c2
leaq 0x168(%rbx), %rsi
leaq 0x190(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa2c2
leaq 0x130(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa2c2
leaq 0x140(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa2c2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa130
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 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 0x581b(%rip), %xmm0     # 0x18510
divsd 0x120(%rdi), %xmm0
movsd %xmm0, 0x158(%rdi)
movq 0x1b0(%rdi), %rax
movsd 0x3e8c(%rip), %xmm0     # 0x16ba0
subsd 0x188(%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
callq 0x3310
movsd %xmm0, -0x18(%rbp)
movsd 0x170(%rbx), %xmm0
callq 0x3080
movsd 0x100(%rbx), %xmm1
movsd %xmm1, 0x178(%rbx)
movq %r14, 0x188(%rbx)
movsd 0x57be(%rip), %xmm2     # 0x18518
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
movsd -0x18(%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 0x326a(%rip), %xmm0     # 0x16010
mulsd %xmm0, %xmm3
movsd %xmm3, 0x160(%rbx)
mulsd %xmm1, %xmm0
movsd %xmm0, 0x168(%rbx)
addq $0x200, %rdi            # imm = 0x200
movsd 0x5753(%rip), %xmm0     # 0x18520
movsd 0x3dcb(%rip), %xmm1     # 0x16ba0
callq 0x9807
movsd %xmm0, 0x1a8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12ff5
ucomisd 0x110(%rbx), %xmm0
ja 0x12ff5
cmpb $0x0, 0x198(%rbx)
jne 0x12f16
movb $0x1, 0x198(%rbx)
movsd 0x118(%rbx), %xmm0
xorpd 0x3168(%rip), %xmm0     # 0x16010
divsd 0x158(%rbx), %xmm0
movapd %xmm0, -0x20(%rbp)
movsd 0x1a8(%rbx), %xmm0
callq 0x3310
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x190(%rbx)
movsd 0x158(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd 0x118(%rbx), %xmm1
xorpd 0x3125(%rip), %xmm1     # 0x16010
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 0x3310
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 0x3310
mulsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd 0x556c(%rip), %xmm1     # 0x18518
addsd %xmm0, %xmm1
movsd %xmm1, 0x138(%rbx)
movq $0x0, 0x148(%rbx)
movsd 0x158(%rbx), %xmm0
movsd 0x118(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
mulsd 0x1a0(%rbx), %xmm0
callq 0x3310
mulsd -0x20(%rbp), %xmm0
movl $0x150, %eax            # imm = 0x150
jmp 0x13009
movq $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_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movl %edx, %ebx
movq %rdi, %r14
movl %esi, 0x8(%rdi)
movl %edx, (%rdi)
imull %esi, %ebx
movl %ebx, 0x4(%rdi)
leaq (,%rbx,8), %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movsd -0x18(%rbp), %xmm0
movq %rax, 0x10(%r14)
testl %ebx, %ebx
jle 0x133d8
xorl %ecx, %ecx
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x133cb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
movl (%rsi), %r15d
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl %r15d, (%rdi)
imull %eax, %r15d
movl %r15d, 0x4(%rdi)
leaq (,%r15,8), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
testl %r15d, %r15d
jle 0x13442
movl %r15d, %ecx
xorl %edx, %edx
movsd (%r14,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpl %edx, %ecx
jne 0x13430
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $-0x1, %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_O3/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 0x1358b
testl %edx, %edx
js 0x1358b
cmpl %esi, 0x8(%rdi)
jle 0x1358b
movl (%rdi), %eax
cmpl %edx, %eax
jle 0x1358b
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
movl $0x8, %edi
callq 0x30b0
leaq 0xa7a8(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa746(%rip), %rsi      # 0x1dcf0
movq 0xaa2f(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DavidLBruce[P]sim3dof/Matrix/build/../../Matrix/src/Matrix.cpp
// Function: Matrix::GetPtr(int)
bool Matrix::CheckDim(int idx)
{
  bool pass(false);

  if ((idx >= 0) &&
      (idx < nElem) &&
      ((rows == 1 ) ||
      (cols == 1)))
  {
    pass = true;
  }

  return pass;
}

// Assembly:
testl %esi, %esi
js 0x135d9
cmpl %esi, 0x4(%rdi)
jle 0x135d9
cmpl $0x1, 0x8(%rdi)
je 0x135ce
cmpl $0x1, (%rdi)
jne 0x135d9
movl %esi, %eax
shlq $0x3, %rax
addq 0x10(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x30b0
leaq 0xa75a(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa6f8(%rip), %rsi      # 0x1dcf0
movq 0xa9e1(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
cmpl $0x2, 0x8(%rdi)
jl 0x13715
xorl %r12d, %r12d
cmpl $0x0, (%r14)
jle 0x136f3
xorl %r13d, %r13d
movq (%rbx), %rdi
movsd (%r15), %xmm0
movb $0x1, %al
callq 0x3040
addq $0x8, %r15
incl %r13d
cmpl (%r14), %r13d
jl 0x136d8
movl $0xa, %edi
callq 0x3210
incl %r12d
cmpl 0x8(%r14), %r12d
jl 0x136cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%r14)
jle 0x13736
xorl %r12d, %r12d
movq (%rbx), %rdi
movsd (%r15,%r12,8), %xmm0
movb $0x1, %al
callq 0x3040
incq %r12
cmpl (%r14), %r12d
jl 0x1371e
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13856
movl %edx, %ebx
movq %rsi, %r15
cmpl %edx, 0x8(%rsi)
jle 0x13856
movq %rdi, %r14
movl (%r15), %edx
xorps %xmm0, %xmm0
movl $0x1, %esi
callq 0x13382
movl (%r15), %eax
testl %eax, %eax
jle 0x13848
movq 0x10(%r14), %rcx
imull %eax, %ebx
shlq $0x3, %rbx
addq 0x10(%r15), %rbx
xorl %edx, %edx
movsd (%rbx,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpl %edx, %eax
jne 0x13837
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0xa4e1(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa47f(%rip), %rsi      # 0x1dcf0
movq 0xa768(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x138ed
movl %edx, %r15d
movq %rsi, %r14
cmpl %edx, (%rsi)
jle 0x138ed
movq %rdi, %rbx
movl 0x8(%r14), %esi
xorps %xmm0, %xmm0
movl $0x1, %edx
callq 0x13382
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x138df
movl %r15d, %ecx
shlq $0x3, %rcx
addq 0x10(%r14), %rcx
movq 0x10(%rbx), %rdx
movslq (%r14), %rsi
shlq $0x3, %rsi
xorl %edi, %edi
movsd (%rcx), %xmm0
movsd %xmm0, (%rdx,%rdi,8)
incq %rdi
addq %rsi, %rcx
cmpl %edi, %eax
jne 0x138cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0xa44a(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa3e8(%rip), %rsi      # 0x1dcf0
movq 0xa6d1(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x139c2
cmpl %esi, 0x8(%rdi)
jle 0x139c2
movslq (%rdi), %rcx
movslq %esi, %rax
imulq %rcx, %rax
shlq $0x3, %rax
addq 0x10(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x30b0
leaq 0xa371(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa30f(%rip), %rsi      # 0x1dcf0
movq 0xa5f8(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %r15
movl (%rdx), %r12d
movl 0x8(%rdx), %eax
movl %eax, 0x8(%rsi)
movl %r12d, (%rsi)
imull %eax, %r12d
movl %r12d, 0x4(%rsi)
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%r14)
testl %r12d, %r12d
jle 0x13a54
movl %r12d, %ecx
xorl %edx, %edx
movsd (%r15,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpl %edx, %ecx
jne 0x13a42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x133e2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13b02
movq %rdx, %r14
movl (%r15), %edx
cmpl (%r14), %edx
jne 0x13b02
movq %rdi, %rbx
xorpd %xmm0, %xmm0
callq 0x13382
movslq 0x4(%r15), %rax
testq %rax, %rax
jle 0x13af4
movq 0x10(%r15), %rcx
movq 0x10(%r14), %rdx
movq 0x10(%rbx), %rsi
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm0
addsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x13add
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0xa235(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa1d3(%rip), %rsi      # 0x1dcf0
movq 0xa4bc(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movl 0x8(%rsi), %esi
cmpl 0x8(%rdx), %esi
jne 0x13c69
movq %rdx, %r15
movl (%r14), %edx
cmpl (%r15), %edx
jne 0x13c69
movq %rdi, %rbx
xorpd %xmm0, %xmm0
callq 0x13382
xorpd %xmm2, %xmm2
movslq 0x4(%r14), %rax
testq %rax, %rax
jle 0x13c31
movq 0x10(%r15), %rcx
movq 0x10(%r14), %rdx
movq 0x10(%rbx), %r14
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
ucomisd %xmm2, %xmm0
jne 0x13c1a
jnp 0x13c3f
movsd (%rdx,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x13c0d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x30b0
leaq 0xa120(%rip), %rcx      # 0x1dd70
movq %rcx, (%rax)
leaq 0xa0ae(%rip), %rsi      # 0x1dd08
movq 0xa37f(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
movl $0x8, %edi
callq 0x30b0
leaq 0xa0ce(%rip), %rcx      # 0x1dd48
movq %rcx, (%rax)
leaq 0xa06c(%rip), %rsi      # 0x1dcf0
movq 0xa355(%rip), %rdx      # 0x1dfe0
movq %rax, %rdi
callq 0x32b0
movq %rax, %r15
testq %r14, %r14
je 0x13ca3
movq %r14, %rdi
callq 0x3200
movq $0x0, 0x10(%rbx)
movq %r15, %rdi
callq 0x32d0
nop