LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Autopilot.cpp
// Function: Autopilot::Output(bool, _IO_FILE*)
void Autopilot::Output( bool printHeader,
                        FILE *pOutFile )
{
  simTime = GetSimTime();

  if ( printHeader )
  {
    fprintf( pOutFile, "%20s", "ap.accLim" );
    fprintf( pOutFile, "%20s", "ap.aCmdYbLim");
    fprintf( pOutFile, "%20s", "ap.ayb" );
    fprintf( pOutFile, "%20s", "ap.tau" );
  }
  else
  {
    fprintf(pOutFile, "%20.6e", accLim );
    fprintf(pOutFile, "%20.6e", aCmdYbLim );
    fprintf(pOutFile, "%20.6e", ayb );
    fprintf(pOutFile, "%20.6e", tau );

  } // end if ( printHeader ) else
}

// 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, 0x130(%rdi)
testl %esi, %esi
je 0x38ee
leaq 0x117ac(%rip), %r14     # 0x15040
leaq 0x117aa(%rip), %rdx     # 0x15045
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x117a0(%rip), %rdx     # 0x1504f
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x11799(%rip), %rdx     # 0x1505c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x1178c(%rip), %rdx     # 0x15063
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 0x100(%rdi), %xmm0
leaq 0x1176a(%rip), %r15     # 0x1506a
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x110(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x118(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x108(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3270
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcRadar.cpp
// Function: FcRadar::FcRadar()
FcRadar::FcRadar()
{
  //
  // Input parameter defaults
  //
  frameTimeStep = 1.0/64.0;
  initFrameTime = 0.0;

  initPxf = -10e3;;
  initPyf = 0.0;

  rinAng = 500.0e-6; // rad   Range independent angle noise
  rinRng = 3.0;      // m     Range independent range noise
  rinRdot = 3.0;     // m/sec Range independent range rate noise

  //
  // Other variable initialization
  //

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9cd8
leaq 0x18f87(%rip), %rax     # 0x1c8f8
movq %rax, (%rbx)
movabsq $0x3f90000000000000, %rax # imm = 0x3F90000000000000
movq %rax, 0x8(%rbx)
andq $0x0, 0xf8(%rbx)
movabsq $-0x3f3c780000000000, %rax # imm = 0xC0C3880000000000
movq %rax, 0x100(%rbx)
andq $0x0, 0x108(%rbx)
movabsq $0x3f40624dd2f1a9fc, %rax # imm = 0x3F40624DD2F1A9FC
movq %rax, 0x110(%rbx)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x120(%rbx)
movq %rax, 0x118(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcRadar.cpp
// Function: FcRadar::Initialize()
void FcRadar::Initialize()
{
  ResetAll();

  simTime = GetSimTime();

  nextFrameTime = initFrameTime;

  pxf = initPxf;
  pyf = initPyf;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x138(%rdi)
movups %xmm0, 0x128(%rdi)
andq $0x0, 0x148(%rdi)
movups %xmm0, 0x158(%rdi)
movups %xmm0, 0x168(%rdi)
andq $0x0, 0x178(%rdi)
movups %xmm0, 0x1a8(%rdi)
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0xf8(%rdi), %xmm0
movsd %xmm0, 0x30(%rdi)
movups 0x100(%rdi), %xmm0
movups %xmm0, 0x140(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcRadar.cpp
// Function: FcRadar::FrameUpdate()
void FcRadar::FrameUpdate()
{
  simTime = GetSimTime();

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

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

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

  relVelX = truVelX;
  relVelY = truVelY;

  truAng = atan2( relPosY, relPosX );

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

  truRdot = ( relVelX * relPosX + relVelY * relPosY ) / truRng;
  
  measAng = gaussian( truAng, rinAng, &pExec->seed );
              
  measRdot = gaussian( truRdot, rinRdot, &pExec->seed );

  measRng = gaussian( truRng, rinRng, &pExec->seed );

  timeStamp = simTime;
              
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x1d0(%rdi), %rcx
movsd (%rax), %xmm0
movsd %xmm0, 0x1a0(%rdi)
movsd 0x160(%rcx), %xmm1
movsd %xmm1, 0x1a8(%rdi)
movsd 0x168(%rcx), %xmm0
movsd %xmm0, 0x1b0(%rdi)
movsd 0x180(%rcx), %xmm2
subsd 0x170(%rdi), %xmm2
movsd %xmm2, 0x1b8(%rdi)
movsd 0x190(%rcx), %xmm3
subsd 0x178(%rdi), %xmm3
movsd %xmm3, 0x1c0(%rdi)
subsd 0x140(%rdi), %xmm1
movsd %xmm1, 0x180(%rdi)
subsd 0x148(%rdi), %xmm0
movsd %xmm0, 0x188(%rdi)
movsd %xmm2, 0x190(%rdi)
movsd %xmm3, 0x198(%rdi)
callq 0x3060
movsd %xmm0, 0x158(%rbx)
movsd 0x110(%rbx), %xmm1
movsd 0x180(%rbx), %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
movsd 0x188(%rbx), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm3, %xmm5
sqrtsd %xmm5, %xmm3
movsd %xmm3, 0x168(%rbx)
mulsd 0x198(%rbx), %xmm4
mulsd 0x190(%rbx), %xmm2
addsd %xmm4, %xmm2
divsd %xmm3, %xmm2
movsd %xmm2, 0x160(%rbx)
movl $0x200, %r14d           # imm = 0x200
movq 0x1c8(%rbx), %rdi
addq %r14, %rdi
callq 0x967d
movsd %xmm0, 0x128(%rbx)
movsd 0x118(%rbx), %xmm1
movsd 0x160(%rbx), %xmm0
movq 0x1c8(%rbx), %rdi
addq %r14, %rdi
callq 0x967d
movsd %xmm0, 0x130(%rbx)
movsd 0x120(%rbx), %xmm1
movsd 0x168(%rbx), %xmm0
addq 0x1c8(%rbx), %r14
movq %r14, %rdi
callq 0x967d
movsd %xmm0, 0x138(%rbx)
movsd 0x1a0(%rbx), %xmm0
movsd %xmm0, 0x150(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::Initialize()
void FcTseO::Initialize()
{
  int idx;

  ResetAll();

  simTime = GetSimTime();

  nextFrameTime = initFrameTime;

  HH = 0.0;
  HH[0][0] = 1.0;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x4304
movq 0x38(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x240(%rbx)
movsd 0xf8(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
leaq 0x170(%rbx), %r15
leaq -0x30(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %r15, %rsi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x1324e
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
movq %r15, (%rax)
addq $0x158, %rbx            # imm = 0x158
cmpq $0x3, %r14
je 0x42f8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1324e
movq %r15, (%rax,%r14,8)
incq %r14
jmp 0x42de
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::ResetAll()
void FcTseO::ResetAll()
{
  estPosY     = 0.0;
  estPosYdot  = 0.0;
  estOmega    = 0.0;
  estOmega2   = 0.0;
  eye         = 0.0;
  HH          = 0.0;
  HT          = 0.0;
  initialized = false;
  innovation  = 0.0;
  KK          = 0.0;
  measPosY    = 0.0;
  phi         = 0.0;
  PP          = 0.0;
  residual    = 0.0;
  rinPosY     = 0.0;
  RR          = 0.0;
  QQ          = 0.0;
  simTime     = 0.0;
  stateVec    = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
leaq 0x158(%rdi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rdi)
movups %xmm0, 0x138(%rdi)
leaq -0xe8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x170(%rbx), %rsi
leaq -0xd0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x188(%rbx), %rsi
leaq -0xb8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
movb $0x0, 0x1a0(%rbx)
leaq 0x1a8(%rbx), %rsi
leaq -0xa0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x1c0(%rbx), %rsi
leaq -0x88(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
andq $0x0, 0x1d8(%rbx)
leaq 0x1e0(%rbx), %rsi
leaq -0x70(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x1f8(%rbx), %rsi
leaq -0x58(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x228(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x210(%rbx)
andq $0x0, 0x220(%rbx)
leaq -0x40(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
andq $0x0, 0x240(%rbx)
addq $0x248, %rbx            # imm = 0x248
leaq -0x28(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::FrameUpdate()
void FcTseO::FrameUpdate()
{
  double angSig;
  double measAng;
  double measRng;
  double rngSig;

  simTime = GetSimTime();

  measAng = pRdr->measAng;
  angSig = pRdr->rinAng; 

  measRng = pRdr->measRng;
  rngSig = pRdr->rinRng;

  measPosY = measRng * measAng;
  rinPosY = measRng * angSig + measAng * rngSig; 

  if ( !initialized )
  {
    initialized = true;

    stateVec(0) = initPosY;
    stateVec(1) = initVelY;
    stateVec(2) = initOmega;

    PP[0][0] = SQ( initPosYsigScale * rinPosY );
    PP[1][1] = SQ( initVelYsig );
    PP[2][2] = SQ( initWsig );
  }

  PropStates( frameTimeStep );

  UpdateStates( measPosY );

  estPosY = stateVec(0);
  estPosYdot = stateVec(1);
  estOmega2 = stateVec(2);
  estOmega = sqrt( estOmega2 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x240(%rdi)
movq 0x268(%rdi), %rax
movsd 0x128(%rax), %xmm0
movsd 0x138(%rax), %xmm1
movapd %xmm0, %xmm2
mulsd 0x120(%rax), %xmm0
mulsd %xmm1, %xmm2
mulsd 0x110(%rax), %xmm1
addsd %xmm0, %xmm1
movsd %xmm2, 0x1d8(%rdi)
movsd %xmm1, 0x218(%rdi)
cmpb $0x0, 0x1a0(%rdi)
jne 0x45e5
movb $0x1, 0x1a0(%rbx)
movsd 0x108(%rbx), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq 0x248(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x131c0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x118(%rbx), %xmm0
movsd %xmm0, -0x28(%rbp)
pushq $0x1
popq %r15
movq %r12, %rdi
movl %r15d, %esi
callq 0x131c0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x100(%rbx), %xmm0
movsd %xmm0, -0x28(%rbp)
pushq $0x2
popq %r14
movq %r12, %rdi
movl %r14d, %esi
callq 0x131c0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x110(%rbx), %xmm0
mulsd 0x218(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq 0x1f8(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x1324e
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x120(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq %r12, %rdi
movl %r15d, %esi
callq 0x1324e
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x128(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq %r12, %rdi
movl %r14d, %esi
callq 0x1324e
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x8(%rbx), %xmm0
movq %rbx, %rdi
callq 0x4678
movsd 0x1d8(%rbx), %xmm0
movq %rbx, %rdi
callq 0x4ada
leaq 0x248(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, 0x138(%rbx)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, 0x140(%rbx)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, 0x150(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x465d
sqrtsd %xmm0, %xmm0
jmp 0x4662
callq 0x3150
movsd %xmm0, 0x148(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTseO.cpp
// Function: FcTseO::CalcStateDeriv(Matrix&)
Matrix FcTseO::CalcStateDeriv( Matrix &XX )
{
  Matrix deriv(3,1);
                             // posY = A*sin(w*t)

  deriv(0) = XX(1);          // d/dt( posY ) = velY = w*A*cos(w*t) 

  deriv(1) = -XX(2) * XX(0); // d/dt( velY ) = -w^2*posY = -w^2*A*sin(w*t)

  deriv(2) = 0.0;

  return( deriv );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x3
popq %rsi
pushq $0x1
popq %r15
xorpd %xmm0, %xmm0
movl %r15d, %edx
callq 0x12cf8
movq %r14, %rdi
movl %r15d, %esi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x131c0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x131c0
movsd (%rax), %xmm0
movapd %xmm0, -0x30(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x131c0
movapd -0x30(%rbp), %xmm0
xorpd 0xf70a(%rip), %xmm0     # 0x15010
movsd -0x38(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x131c0
andq $0x0, (%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x12dd8
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::Initialize()
void FcTse6::Initialize()
{
  int idx;

  ResetAll();

  simTime = GetSimTime();

  nextFrameTime = initFrameTime;

  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 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x5e7e
movq 0x38(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x2f8(%rbx)
movsd 0xf8(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
leaq 0x1c0(%rbx), %r14
xorl %r15d, %r15d
movabsq $0x3ff0000000000000, %r12 # imm = 0x3FF0000000000000
cmpq $0x6, %r15
je 0x5dd0
movq %r14, %rdi
movl %r15d, %esi
callq 0x1324e
movq %r12, (%rax,%r15,8)
incq %r15
jmp 0x5db6
leaq 0x1d8(%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
addq $0x1f0, %rbx            # imm = 0x1F0
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %rbx, %rsi
callq 0x13296
leaq -0x68(%rbp), %rdi
callq 0x12dd8
leaq -0x38(%rbp), %rdi
callq 0x12dd8
leaq -0x50(%rbp), %rdi
callq 0x12dd8
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x12dd8
jmp 0x5e6d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x12dd8
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::ResetAll()
void FcTse6::ResetAll()
{
  angSig      = 0.0;
  cartRel     = 0.0;
  estLosAng   = 0.0;
  estLosr     = 0.0;
  estRng      = 0.0;
  estRdot     = 0.0;
  estAccX     = 0.0;
  estAccY     = 0.0;
  eye         = 0.0;
  HH          = 0.0;
  HT          = 0.0;
  initialized = false;
  innovation  = 0.0;
  KK          = 0.0;
  measAng     = 0.0;
  measRng     = 0.0;
  measRdot    = 0.0;
  measVec     = 0.0;
  mscState    = 0.0;
  phi         = 0.0;
  PP          = 0.0;
  rDotSig     = 0.0;
  residual    = 0.0;
  rngSig      = 0.0;
  RR          = 0.0;
  simTime     = 0.0;
  timeStamp   = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
andq $0x0, 0x1b8(%rdi)
leaq 0x110(%rdi), %rsi
leaq -0x130(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x1c0(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rbx)
movups %xmm0, 0x138(%rbx)
movups %xmm0, 0x128(%rbx)
leaq -0x118(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x1d8(%rbx), %rsi
leaq -0x100(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x1f0(%rbx), %rsi
leaq -0xe8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
movb $0x0, 0x208(%rbx)
leaq 0x210(%rbx), %rsi
leaq -0xd0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x228(%rbx), %rsi
leaq -0xb8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x258(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x240(%rbx)
andq $0x0, 0x250(%rbx)
leaq -0xa0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x270(%rbx), %rsi
leaq -0x88(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x288(%rbx), %rsi
leaq -0x70(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
leaq 0x2a0(%rbx), %rsi
leaq -0x58(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
andq $0x0, 0x2b8(%rbx)
leaq 0x2c0(%rbx), %rsi
leaq -0x40(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
andq $0x0, 0x2d8(%rbx)
leaq 0x2e0(%rbx), %rsi
leaq -0x28(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x132f0
movq %r14, %rdi
callq 0x12dd8
andq $0x0, 0x2f8(%rbx)
andq $0x0, 0x158(%rbx)
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::MscToCart(Matrix&, Matrix&)
void FcTse6::MscToCart( Matrix &mscState,
                        Matrix &cartRel )
{
  double range = 1.0 / mscState(2);
  double rDot = mscState(3) * range;

  double cth = cos( mscState(0) );
  double sth = sin( mscState(0) );

  double thDot = mscState(1);

  cartRel(0) = range * cth;
  cartRel(1) = range * sth;
  
  cartRel(2) = rDot * cth - range * thDot * sth;
  cartRel(3) = rDot * sth + range * thDot * cth;

  cartRel(4) = range * ( mscState(4) * cth - mscState(5) * sth );
  cartRel(5) = range * ( mscState(4) * sth + mscState(5) * cth );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x2
popq %r12
movq %rsi, %rdi
movl %r12d, %esi
callq 0x131c0
movsd 0xd1ce(%rip), %xmm0     # 0x15038
divsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
pushq $0x3
popq %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0x131c0
movsd (%rax), %xmm0
mulsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x131c0
movsd (%rax), %xmm0
callq 0x3360
movsd %xmm0, -0x40(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x131c0
movsd (%rax), %xmm0
callq 0x3080
movsd %xmm0, -0x38(%rbp)
pushq $0x1
popq %r13
movq %r14, %rdi
movl %r13d, %esi
callq 0x131c0
movsd -0x50(%rbp), %xmm0
movapd %xmm0, %xmm1
mulsd -0x40(%rbp), %xmm1
movsd %xmm1, -0x48(%rbp)
movsd (%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x58(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x131c0
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x131c0
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
mulsd -0x58(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x48(%rbp)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x131c0
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x131c0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
pushq $0x4
popq %r12
movq %r14, %rdi
movl %r12d, %esi
callq 0x131c0
movsd (%rax), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
pushq $0x5
popq %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0x131c0
movsd (%rax), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd -0x50(%rbp), %xmm1
movsd %xmm1, -0x30(%rbp)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x131c0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl %r12d, %esi
callq 0x131c0
movsd -0x38(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x131c0
movsd -0x40(%rbp), %xmm0
mulsd (%rax), %xmm0
addsd -0x38(%rbp), %xmm0
mulsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x131c0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/FcTse6.cpp
// Function: FcTse6::CalcStateDeriv(Matrix&)
Matrix  FcTse6::CalcStateDeriv( Matrix &XX )
{
  Matrix  deriv(6,1);
                             
  deriv(0) = XX(2);  // d/dt(posX) = velX
  deriv(1) = XX(3);  // d/dt(posY) = velY
  deriv(2) = XX(4);  // d/dt(velX) = accX
  deriv(3) = XX(5);  // d/dt(velY) = accY
  deriv(4) = 0.0;    // d/dt(accX) = 0.0
  deriv(5) = 0.0;    // d/dy(accY) = 0.0

  return( deriv );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
xorps %xmm0, %xmm0
callq 0x12cf8
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x131c0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x131c0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x131c0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x131c0
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x131c0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x131c0
andq $0x0, (%rax)
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x131c0
andq $0x0, (%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x12dd8
movq %r14, %rdi
callq 0x3320
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Guidance.cpp
// Function: Guidance::Guidance()
Guidance::Guidance() :
pAp(0),
pExec(0),
pMsl(0),
pMslTse(0),
pRdr(0),
pTgt(0),
pTse6(0),
MdlBase()
{
  //
  // Default initialization of input variables
  //
  frameTimeStep = 1.0/64.0;  // sec     Frame time step
  initFrameTime = 0.0;       // sec     Time of first frame update

  gdnLawSelInt  = 1;         // na      Guidance law selection
                             //         1 = Proportion Navigation
                             //         2 = Weave guidance
  kpn           = 3.0;       // na      Pro Nav gain
  tauCtrl       = 0.4;       // sec     Optimal guidance tuning parameter
  useTruth      = false;     // na      Use truth for target state

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9cd8
leaq 0x14253(%rip), %rax     # 0x1ca30
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1d8(%rbx)
movups %xmm0, 0x1e8(%rbx)
movups %xmm0, 0x1f8(%rbx)
andq $0x0, 0x208(%rbx)
movabsq $0x3f90000000000000, %rax # imm = 0x3F90000000000000
movq %rax, 0x8(%rbx)
andq $0x0, 0xf8(%rbx)
movl $0x1, 0x100(%rbx)
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x108(%rbx)
movabsq $0x3fd999999999999a, %rax # imm = 0x3FD999999999999A
movq %rax, 0x118(%rbx)
movb $0x0, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Guidance.cpp
// Function: Guidance::Initialize()
void Guidance::Initialize()
{
  ResetAll();

  simTime = GetSimTime();

  assert( pAp );
  assert( pExec );
  assert( pMsl );
  assert( pMslTse );
  assert( pRdr );
  assert( pTgt );
  assert( pTse6 );

  gdnLawSel = static_cast<GdnLawSel>( gdnLawSelInt );

  launchTime = pMsl->launchTime;
  
  nextFrameTime = launchTime;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%rdi)
movups %xmm0, 0x140(%rdi)
movups %xmm0, 0x130(%rdi)
movups %xmm0, 0x120(%rdi)
andq $0x0, 0x15d(%rdi)
movups %xmm0, 0x168(%rdi)
movups %xmm0, 0x178(%rdi)
movups %xmm0, 0x188(%rdi)
movups %xmm0, 0x198(%rdi)
movups %xmm0, 0x1a8(%rdi)
movups %xmm0, 0x1b8(%rdi)
movups %xmm0, 0x1c8(%rdi)
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x198(%rdi)
cmpq $0x0, 0x1d8(%rdi)
je 0x896b
cmpq $0x0, 0x1e0(%rdi)
je 0x8987
movq 0x1e8(%rdi), %rax
testq %rax, %rax
je 0x89a0
cmpq $0x0, 0x1f0(%rdi)
je 0x89b9
cmpq $0x0, 0x1f8(%rdi)
je 0x89d2
cmpq $0x0, 0x200(%rdi)
je 0x89eb
cmpq $0x0, 0x208(%rdi)
je 0x8a04
movl 0x100(%rdi), %ecx
movl %ecx, 0x160(%rdi)
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
movsd %xmm0, 0x30(%rdi)
popq %rbp
retq
leaq 0xcb5e(%rip), %rdi      # 0x154d0
leaq 0xcb5b(%rip), %rsi      # 0x154d4
leaq 0xcb68(%rip), %rcx      # 0x154e8
pushq $0x6a
jmp 0x8a1b
leaq 0xcb7e(%rip), %rdi      # 0x1550c
leaq 0xcb3f(%rip), %rsi      # 0x154d4
leaq 0xcb4c(%rip), %rcx      # 0x154e8
pushq $0x6b
jmp 0x8a1b
leaq 0xcb6b(%rip), %rdi      # 0x15512
leaq 0xcb26(%rip), %rsi      # 0x154d4
leaq 0xcb33(%rip), %rcx      # 0x154e8
pushq $0x6c
jmp 0x8a1b
leaq 0xcb57(%rip), %rdi      # 0x15517
leaq 0xcb0d(%rip), %rsi      # 0x154d4
leaq 0xcb1a(%rip), %rcx      # 0x154e8
pushq $0x6d
jmp 0x8a1b
leaq 0xcb46(%rip), %rdi      # 0x1551f
leaq 0xcaf4(%rip), %rsi      # 0x154d4
leaq 0xcb01(%rip), %rcx      # 0x154e8
pushq $0x6e
jmp 0x8a1b
leaq 0xcb32(%rip), %rdi      # 0x15524
leaq 0xcadb(%rip), %rsi      # 0x154d4
leaq 0xcae8(%rip), %rcx      # 0x154e8
pushq $0x6f
jmp 0x8a1b
leaq 0xcb1e(%rip), %rdi      # 0x15529
leaq 0xcac2(%rip), %rsi      # 0x154d4
leaq 0xcacf(%rip), %rcx      # 0x154e8
pushq $0x70
popq %rdx
callq 0x3120
nop
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/Guidance.cpp
// Function: Guidance::Output(bool, _IO_FILE*)
void Guidance::Output( bool printHeader,
                       FILE *pOutFile )
{
  simTime = GetSimTime();

  if ( printHeader )
  {
    fprintf( pOutFile, "%20s", "gdn.aCmdYb" );
    fprintf( pOutFile, "%20s", "gdn.losr" );
    fprintf( pOutFile, "%20s", "gdn.rDot" );
    fprintf( pOutFile, "%20s", "gdn.relPxf" );
    fprintf( pOutFile, "%20s", "gdn.relPyf" );
    fprintf( pOutFile, "%20s", "gdn.relVxf" );
    fprintf( pOutFile, "%20s", "gdn.relVyf" );
    fprintf( pOutFile, "%20s", "gdn.rng" );
  }
  else
  {
    fprintf(pOutFile, "%20.6e", aCmdYb );
    fprintf(pOutFile, "%20.6e", estLosr );
    fprintf(pOutFile, "%20.6e", estRdot );
    fprintf(pOutFile, "%20.6e", relPxf );
    fprintf(pOutFile, "%20.6e", relPyf );
    fprintf(pOutFile, "%20.6e", relVxf );
    fprintf(pOutFile, "%20.6e", relVyf );
    fprintf(pOutFile, "%20.6e", estRng );

  } // end if ( printHeader ) else
}

// 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, 0x198(%rdi)
testl %esi, %esi
je 0x90ce
leaq 0xc01c(%rip), %r14      # 0x15040
leaq 0xc504(%rip), %rdx      # 0x1552f
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0xc4fb(%rip), %rdx      # 0x1553a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0xc4f0(%rip), %rdx      # 0x15543
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0xc4e5(%rip), %rdx      # 0x1554c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0xc4dc(%rip), %rdx      # 0x15557
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0xc4d3(%rip), %rdx      # 0x15562
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0xc4ca(%rip), %rdx      # 0x1556d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0xc4c1(%rip), %rdx      # 0x15578
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 0x120(%rdi), %xmm0
leaq 0xbf8a(%rip), %r15      # 0x1506a
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x148(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x158(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x178(%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 0x190(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3270
movsd 0x150(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3270
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: quant(double, double)
double quant(double val, double lsb)
{
  double x;
  int    intx;
  double quantized_val;

  if (lsb > 1e-10) {      /// allow lsb = 0 to turn off, also help prevent overflow
      x = val/lsb;
      intx = (int)x;
      if ( fabs(x - (double)intx) >= 0.5 )   intx = intx + (int)sgn(x);
      quantized_val = lsb*intx;
  } else {
      quantized_val = val;
  }
  return quantized_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
ucomisd 0xc392(%rip), %xmm1     # 0x155b0
jbe 0x9273
divsd %xmm1, %xmm0
cvttpd2dq %xmm0, %xmm2
cvtdq2pd %xmm2, %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
andpd 0xc364(%rip), %xmm3     # 0x155a0
ucomisd 0xbf24(%rip), %xmm3     # 0x15168
jae 0x924c
movapd %xmm2, %xmm0
jmp 0x926f
cvttsd2si %xmm0, %eax
xorpd %xmm2, %xmm2
xorl %ecx, %ecx
ucomisd %xmm0, %xmm2
seta %cl
leaq 0xc32c(%rip), %rdx      # 0x15590
cvttsd2si (%rdx,%rcx,8), %ecx
addl %eax, %ecx
cvtsi2sd %ecx, %xmm0
mulsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: lut1d(double*, double*, int, double)
double lut1d( double *xlist,
              double *lut,
              int    x_dim,
              double x )
{
  int xu;
  int xl;
  int xm;
  if (x < xlist[0])
    x = xlist[0];
  if (x > xlist[x_dim-1])
    x = xlist[x_dim-1];

  xu = x_dim - 1;
  xl = 0;
  xm = (xu + xl) / 2;

  if (x == xlist[xu])
    xl = xu;
  else if (x == xlist[xl])
    xu = xl;
  else {
    while (xu - xl > 1) {
      xm = (xu + xl) / 2;
      if (xlist[xm] == x)
        xl = xu = xm;
      else if (xlist[xm] > x)
        xu = xm;
      else xl = xm;
    }
  }

  if (xl == xu) {
    return lut[xu];
  } else {
    return lut[xl] + (x - xlist[xl]) *
                         ((lut[xu] - lut[xl]) / (xlist[xu] - xlist[xl]));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %ecx
movsd (%rdi), %xmm2
movapd %xmm2, %xmm3
maxsd %xmm0, %xmm3
movslq %edx, %rax
decl %ecx
movsd -0x8(%rdi,%rax,8), %xmm0
movapd %xmm0, %xmm1
minsd %xmm3, %xmm1
ucomisd %xmm0, %xmm1
jne 0x92a6
jp 0x92a6
movl %ecx, %eax
jmp 0x92b0
xorl %eax, %eax
ucomisd %xmm2, %xmm1
jne 0x92b9
jp 0x92b9
cltq
movsd (%rsi,%rax,8), %xmm0
popq %rbp
retq
xorl %r8d, %r8d
movl $0x2, %r9d
movl %ecx, %eax
subl %r8d, %eax
cmpl $0x2, %eax
jl 0x92f7
leal (%r8,%rcx), %eax
cltd
idivl %r9d
cltq
movsd (%rdi,%rax,8), %xmm0
ucomisd %xmm1, %xmm0
cmovbel %eax, %r8d
cmovael %eax, %ecx
ucomisd %xmm0, %xmm1
cmovnel %r8d, %eax
cmovpl %r8d, %eax
movl %eax, %r8d
jmp 0x92c2
cmpl %r8d, %ecx
je 0x92a2
movslq %r8d, %rax
movsd (%rsi,%rax,8), %xmm2
movsd (%rdi,%rax,8), %xmm3
subsd %xmm3, %xmm1
movslq %ecx, %rax
movsd (%rsi,%rax,8), %xmm0
subsd %xmm2, %xmm0
movsd (%rdi,%rax,8), %xmm4
subsd %xmm3, %xmm4
divsd %xmm4, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
jmp 0x92b7
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: ran1(long*)
double ran1(long *idum)
{
  int j;
  long k;
  static long iy = 0;
  static long iv[NTAB];
  double temp;

  if (*idum <= 0 || !iy) {
    if (-(*idum) < 1)
      *idum = 1;
    else *idum
      = -(*idum);
    for (j = NTAB + 7; j >= 0; j--) {
      k = (*idum) / IQ;
      *idum = IA * (*idum-k * IQ) - IR * k;
      if (*idum<0)
        *idum += IM;
      if (j < NTAB)
       iv[j] = *idum;
    }
    iy = iv[0];
  }

  k = (*idum) / IQ;
  *idum = IA * (*idum - k * IQ) - IR * k;
  if (*idum <= 0) *idum += IM;
  j = iy / NDIV;
  iy = iv[j];
  iv[j] = *idum;
  if ( (temp = AM * iy) > RNMX )
    return RNMX;
  else
    return temp;
}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
setg %al
movq 0x13cf4(%rip), %rsi     # 0x1d1f0
testq %rsi, %rsi
setne %dl
testb %dl, %al
jne 0x957b
movq %rcx, %rax
negq %rax
testq %rcx, %rcx
movabsq $0x1, %rcx
cmovsq %rax, %rcx
movl $0x27, %esi
movl $0x1f31d, %r8d          # imm = 0x1F31D
leaq 0x13cd1(%rip), %r9      # 0x1d200
testl %esi, %esi
js 0x9574
movq %rcx, %rax
cqto
idivq %r8
imulq $-0x1f31d, %rax, %rdx   # imm = 0xFFFE0CE3
addq %rcx, %rdx
imulq $0x41a7, %rdx, %rdx     # imm = 0x41A7
imulq $-0xb14, %rax, %rax     # imm = 0xF4EC
leaq (%rdx,%rax), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
addq %rax, %rdx
cmovnsq %rdx, %rcx
cmpl $0x1f, %esi
ja 0x9570
movl %esi, %eax
movq %rcx, (%r9,%rax,8)
decl %esi
jmp 0x952f
movq 0x13c85(%rip), %rsi     # 0x1d200
pushq %rbp
movq %rsp, %rbp
movl $0x1f31d, %r8d          # imm = 0x1F31D
movq %rcx, %rax
cqto
idivq %r8
imulq $-0x1f31d, %rax, %rdx   # imm = 0xFFFE0CE3
addq %rcx, %rdx
imulq $0x41a7, %rdx, %rcx     # imm = 0x41A7
imulq $-0xb14, %rax, %rax     # imm = 0xF4EC
leaq (%rcx,%rax), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rcx,%rax), %rcx
cmovgq %rdx, %rcx
movq %rcx, (%rdi)
movl $0x4000000, %edi        # imm = 0x4000000
movq %rsi, %rax
cqto
idivq %rdi
cltq
leaq 0x13c2f(%rip), %rdx     # 0x1d200
movq (%rdx,%rax,8), %rsi
movq %rsi, 0x13c14(%rip)     # 0x1d1f0
cvtsi2sd %rsi, %xmm1
mulsd 0xbfcf(%rip), %xmm1     # 0x155b8
movq %rcx, (%rdx,%rax,8)
movsd 0xbfcb(%rip), %xmm0     # 0x155c0
minsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: mean(int, double*)
double mean(int    samples,
            double *data)
{
  double sum = 0.0;
  int    i;

  for (i = 0; i < samples; i++)
    sum = sum + data[i];

  return sum / (double)samples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testl %edi, %edi
movl $0x0, %ecx
cmovgl %edi, %ecx
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x9787
addsd (%rsi,%rax,8), %xmm0
incq %rax
jmp 0x9778
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: rms(int, double*)
double rms(int    samples,
           double *data)
{
  double sumsq = 0.0;
  int    i;

  for (i = 0; i < samples; i++)
    sumsq += data[i] * data[i];

  return sqrt(sumsq / ((double)samples));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testl %edi, %edi
movl $0x0, %ecx
cmovgl %edi, %ecx
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x97bc
movsd (%rsi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x97a5
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x97d4
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3150
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: stdd(int, double*)
double stdd(int    samples,
            double *data)
{
  double mean;
  double stdev;
  if (samples == 1)
  {
    return 0.0;
  }
  else
  {
    double sum = 0.0;
    int    i;

    for (i = 0; i < samples; i++)
      sum += data[i];

    mean  = sum / ((double)samples);
    stdev = 0.0;

    for (i=0; i < samples; i++)
      stdev = stdev + ((data[i] - mean) * (data[i] - mean));

    return sqrt(stdev / ((double)samples - 1));
  }
}

// Assembly:
xorpd %xmm0, %xmm0
cmpl $0x1, %edi
je 0x984e
xorl %ecx, %ecx
testl %edi, %edi
movl $0x0, %eax
cmovgl %edi, %eax
xorpd %xmm1, %xmm1
cmpq %rcx, %rax
je 0x9802
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
jmp 0x97f3
cvtsi2sd %edi, %xmm2
divsd %xmm2, %xmm1
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x982b
movsd (%rsi,%rcx,8), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm0
incq %rcx
jmp 0x9810
pushq %rbp
movq %rsp, %rbp
addsd 0xb7f9(%rip), %xmm2     # 0x15030
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
popq %rbp
jb 0x3150
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: theMaximum(int, double*)
double theMaximum(int    samples,
               double *data)
{
  double max = data[0];
  int    i;

  for (i = 0; i < samples; i++) {
    if (data[i] > max)
      max = data[i];
  }

  return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd (%rsi), %xmm0
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
cmpq %rax, %rdi
je 0x9875
movsd (%rsi,%rax,8), %xmm1
maxsd %xmm0, %xmm1
incq %rax
movapd %xmm1, %xmm0
jmp 0x985e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: median(int, double*)
double median(int qtyElem, double *data)
{
  double ans;

  qsort(data, qtyElem, sizeof(double), compDbl);

  if ((qtyElem % 2) == 0) {
    ans = 0.5 * (data[qtyElem/2 - 1] + data[qtyElem/2]);
  } else {
    ans = data[(qtyElem - 1) / 2];
  }
  return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movslq %edi, %r15
leaq 0x48(%rip), %rcx        # 0x9901
pushq $0x8
popq %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3370
testb $0x1, %r15b
jne 0x98e8
sarl %r14d
movslq %r14d, %rax
movsd -0x8(%rbx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
mulsd 0xb882(%rip), %xmm0     # 0x15168
jmp 0x98f6
decl %r14d
sarl %r14d
movslq %r14d, %rax
movsd (%rbx,%rax,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: histogram(double*, int, int)
void histogram(double *data,
               int    samples,
               int    bins)
{
  int    i, j;
  double min_value     = minimum(samples, data);
  double max_value     = theMaximum(samples, data);
  double last_value    = min_value;
  double current_value = 0.0;
  int    count;

  printf("%d \t %7.3f \t %d\n", 0, min_value, 0);

  for (i=1; i<=bins; i++) {
    current_value = min_value + (max_value - min_value) * (double)i/(double)bins;
    count = 0;

    for (j = 0; j < samples; j++)
      if ( (data[j] < current_value) && (data[j] >= last_value))
        count++;

    printf("%d \t %7.3f \t %d\n", i, current_value, count);
    last_value = current_value;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
movq %r14, %rsi
callq 0x9877
movsd %xmm0, -0x38(%rbp)
movl %ebx, %edi
movq %r14, %rsi
callq 0x984f
movsd %xmm0, -0x30(%rbp)
leaq 0xbbf0(%rip), %r15      # 0x155d0
xorl %r13d, %r13d
movq %r15, %rdi
xorl %esi, %esi
movsd -0x38(%rbp), %xmm0
xorl %edx, %edx
movb $0x1, %al
callq 0x3040
cvtsi2sd %r12d, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm3
movsd -0x30(%rbp), %xmm0
subsd %xmm3, %xmm0
movsd %xmm0, -0x30(%rbp)
testl %ebx, %ebx
cmovlel %r13d, %ebx
testl %r12d, %r12d
cmovgl %r12d, %r13d
incl %r13d
pushq $0x1
popq %r12
movsd 0xb609(%rip), %xmm1     # 0x15038
cmpl %r13d, %r12d
je 0x9aa1
movsd -0x30(%rbp), %xmm0
movsd %xmm1, -0x48(%rbp)
mulsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
xorl %eax, %eax
xorl %edx, %edx
cmpq %rax, %rbx
je 0x9a78
movsd (%r14,%rax,8), %xmm1
movapd %xmm3, %xmm2
cmplepd %xmm1, %xmm2
cmpltpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %ecx
subl %ecx, %edx
incq %rax
jmp 0x9a50
movq %r15, %rdi
movl %r12d, %esi
movb $0x1, %al
movapd %xmm0, -0x60(%rbp)
callq 0x3040
movsd -0x48(%rbp), %xmm1
addsd 0xb5a1(%rip), %xmm1     # 0x15038
incl %r12d
movapd -0x60(%rbp), %xmm3
jmp 0x9a2f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: cdf(double*, int, int)
void cdf(double *data,
         int    samples,
         int    bins)
{
  int    i, j;
  double min_value     = minimum(samples, data);
  double max_value     = theMaximum(samples, data);
  double current_value = 0.0;
  int    count;

  printf("%d \t %7.3f \t %d \t %7f\n", 0, min_value, 0, 0.0);

  for (i = 1; i <= bins; i++) {
    current_value = min_value +
                      (max_value - min_value) * (double)i / (double)bins;
    count = 0;
    for (j = 0; j < samples; j++)
      if (data[j] <= current_value)
        count++;

    printf("%d \t %7f \t %d \t %7f\n",
         i, current_value, count, (double)count / (double)samples);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
movq %r14, %rsi
callq 0x9877
movsd %xmm0, -0x38(%rbp)
movl %ebx, %edi
movq %r14, %rsi
callq 0x984f
movsd %xmm0, -0x30(%rbp)
leaq 0xbaf3(%rip), %rdi      # 0x155e1
xorl %r13d, %r13d
xorps %xmm1, %xmm1
xorl %esi, %esi
movsd -0x38(%rbp), %xmm0
xorl %edx, %edx
movb $0x2, %al
callq 0x3040
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x48(%rbp)
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
testl %ebx, %ebx
cmovlel %r13d, %ebx
testl %r15d, %r15d
cmovgl %r15d, %r13d
incl %r13d
pushq $0x1
popq %r15
movsd 0xb4f6(%rip), %xmm1     # 0x15038
leaq 0xbaaf(%rip), %r12      # 0x155f8
cmpl %r13d, %r15d
je 0x9ba5
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
divsd -0x48(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
xorl %eax, %eax
xorl %edx, %edx
cmpq %rax, %rbx
je 0x9b78
ucomisd (%r14,%rax,8), %xmm0
sbbl $-0x1, %edx
incq %rax
jmp 0x9b65
movsd %xmm1, -0x50(%rbp)
cvtsi2sd %edx, %xmm1
divsd -0x40(%rbp), %xmm1
movq %r12, %rdi
movl %r15d, %esi
movb $0x2, %al
callq 0x3040
movsd -0x50(%rbp), %xmm1
addsd 0xb498(%rip), %xmm1     # 0x15038
incl %r15d
jmp 0x9b49
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: abscdf(double*, int, int)
void abscdf(double *data,
            int    samples,
            int    bins)
{
  int    i, j;
  double tmp_min = fabs(minimum(samples, data));
  double tmp_max = fabs(theMaximum(samples, data));
  double current_value = 0.0;
  int    count;

  double max_value = maxi(tmp_min, tmp_max);

  printf("%d \t %7f \t %d \t %7f\n", 0, 0.0, 0, 0.0);

  for (i=1; i<=bins; i++) {
    current_value = max_value*(double)i/(double)bins;
    count = 0;
    for (j = 0; j < samples; j++)
      if (fabs(data[j]) <= current_value)
        count++;
    printf("%d \t %7f \t %d \t %f\n",
        i, current_value, count, (double)count / (double)samples);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
movq %r14, %rsi
callq 0x9877
andpd 0xb9c1(%rip), %xmm0     # 0x155a0
movapd %xmm0, -0x40(%rbp)
movl %ebx, %edi
movq %r14, %rsi
callq 0x984f
andpd 0xb9aa(%rip), %xmm0     # 0x155a0
movapd -0x40(%rbp), %xmm1
maxsd %xmm0, %xmm1
movapd %xmm1, -0x40(%rbp)
leaq 0xb9ed(%rip), %rdi      # 0x155f8
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorl %esi, %esi
xorl %edx, %edx
movb $0x2, %al
callq 0x3040
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x50(%rbp)
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x48(%rbp)
testl %ebx, %ebx
cmovlel %r13d, %ebx
testl %r15d, %r15d
cmovgl %r15d, %r13d
incl %r13d
pushq $0x1
popq %r15
movsd 0xb3e8(%rip), %xmm1     # 0x15038
leaq 0xb9b6(%rip), %r12      # 0x1560d
movapd 0xb941(%rip), %xmm2     # 0x155a0
cmpl %r13d, %r15d
je 0x9cc6
movapd -0x40(%rbp), %xmm0
movsd %xmm1, -0x58(%rbp)
mulsd %xmm1, %xmm0
divsd -0x50(%rbp), %xmm0
xorl %eax, %eax
xorl %edx, %edx
cmpq %rax, %rbx
je 0x9c96
movsd (%r14,%rax,8), %xmm1
andpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
sbbl $-0x1, %edx
incq %rax
jmp 0x9c7b
cvtsi2sd %edx, %xmm1
divsd -0x48(%rbp), %xmm1
movq %r12, %rdi
movl %r15d, %esi
movb $0x2, %al
callq 0x3040
movapd 0xb8ec(%rip), %xmm2     # 0x155a0
movsd -0x58(%rbp), %xmm1
addsd 0xb377(%rip), %xmm1     # 0x15038
incl %r15d
jmp 0x9c5f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/DavidLBruce[P]sim3dof/build/../src/MdlBase.cpp
// Function: MdlBase::MdlBase()
MdlBase::MdlBase()
{
  nextFrameTime = 999.0e9;
  frameTimeStep = 999.0e9;
  mdlName = "";
  pSimTime = 0;
  initComp = false;
  intEn = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x12da5(%rip), %rax     # 0x1ca98
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x10(%rdi), %r14
movb $0x0, 0x20(%rdi)
leaq 0x48(%rdi), %r15
movl $0xa8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x3110
movabsq $0x426d132148c00000, %rax # imm = 0x426D132148C00000
movq %rax, 0x30(%rbx)
movq %rax, 0x8(%rbx)
leaq 0xc5dc(%rip), %rsi      # 0x16313
movq %r14, %rdi
callq 0x3380
andq $0x0, 0x38(%rbx)
xorl %eax, %eax
movb %al, 0xf0(%rbx)
movb %al, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x40(%rbp)
leaq 0xd8(%rbx), %rdi
leaq 0xc0(%rbx), %r13
leaq 0xa8(%rbx), %r12
leaq 0x90(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x78(%rbx), %rax
movq %rax, -0x38(%rbp)
addq $0x60, %rbx
callq 0xa4a8
movq %r13, %rdi
callq 0xa4a8
movq %r12, %rdi
callq 0xa4a8
movq -0x30(%rbp), %rdi
callq 0xa4a8
movq -0x38(%rbp), %rdi
callq 0xa4a8
movq %rbx, %rdi
callq 0xa46a
movq %r15, %rdi
callq 0xa46a
movq %r14, %rdi
callq 0x30d0
movq -0x40(%rbp), %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r15
movq %rsi, (%r15)
addq $0x48, %rdi
movq %r15, %rsi
callq 0xa418
movq %rbx, (%r15)
leaq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0xa418
movb $0x1, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9cd8
leaq 0x121cf(%rip), %rax     # 0x1caf8
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 0x9ef0
leaq 0x138(%rbx), %rsi
leaq 0x160(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9ef0
leaq 0x118(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9ef0
leaq 0x128(%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
nop