LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::rdp_encoding()
void rdp_encoding()
    {

        int off = 0;
        int d = 0;
        int p = 0;
        int diag = 0;
        int packet_size = stripe_unit_size /w;

        for (d = 1; d < disks; d++)
        {

            diag = d;

            for (p = 0; p < w; p++)
            {
                if (diag <= w - 1)
                {
                    for (off = 0; off < packet_size; off++)
                    {

                        odata[0][p * packet_size + off]^= idata[d][p * packet_size + off];
                        odata[1][diag * packet_size + off]^= idata[d][p * packet_size + off];
                    }
                    diag++;

                }
                else
                {

                    for (off = 0; off < packet_size; off++)
                    {

                        odata[0][p * packet_size + off]^= idata[d][p * packet_size + off];
                    }
                    diag = 0;

                }

            }
        }
        for (p = 1; p < w; p++)
        {
            for (off = 0; off < packet_size; off++)
            {
                odata[1][(p - 1) * packet_size + off]^= odata[0][p * packet_size + off];

            }
        }


    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x8(%rdi), %r9d
movl 0xc(%rdi), %eax
movl 0x14(%rdi), %r8d
cltd
idivl %r8d
cmpl $0x2, %r9d
jl 0x1a64
movslq %eax, %rcx
movl %eax, %edx
movl $0x1, %esi
testl %r8d, %r8d
jle 0x1a55
xorl %r9d, %r9d
xorl %r10d, %r10d
movl %esi, %r11d
cmpl %r8d, %r11d
jge 0x1a12
testl %eax, %eax
jle 0x1a0d
movl %r11d, %r8d
imull %eax, %r8d
movslq %r8d, %r8
movq %rdx, %rbx
movq %r9, %r14
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
movq (%r15,%rsi,8), %r15
movb (%r15,%r14), %r15b
movq (%r12), %r12
xorb %r15b, (%r12,%r14)
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
movq (%r15,%rsi,8), %r15
movb (%r15,%r14), %r15b
movq 0x8(%r12), %r12
xorb %r15b, (%r12,%r8)
incq %r8
incq %r14
decq %rbx
jne 0x19d1
incl %r11d
jmp 0x1a3e
xorl %r11d, %r11d
testl %eax, %eax
jle 0x1a3e
movl %r9d, %r8d
movq %rdx, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
movq (%r14,%rsi,8), %r14
movb (%r14,%r8), %r14b
movq (%r15), %r15
xorb %r14b, (%r15,%r8)
incq %r8
decq %rbx
jne 0x1a1f
incq %r10
movslq 0x14(%rdi), %r8
addq %rcx, %r9
cmpq %r8, %r10
jl 0x19b8
movl 0x8(%rdi), %r9d
incq %rsi
movslq %r9d, %r10
cmpq %r10, %rsi
jl 0x19a6
cmpl $0x2, %r8d
jl 0x1ab1
movslq %eax, %rcx
movl %ecx, %edx
movl $0x1, %esi
xorl %r9d, %r9d
testl %eax, %eax
jle 0x1aa3
movq %rdx, %r8
movq %r9, %r10
movq 0x28(%rdi), %r11
movq (%r11), %rbx
addq %rcx, %rbx
movb (%r10,%rbx), %bl
movq 0x8(%r11), %r11
xorb %bl, (%r11,%r10)
incq %r10
decq %r8
jne 0x1a81
movl 0x14(%rdi), %r8d
incq %rsi
movslq %r8d, %r10
addq %rcx, %r9
cmpq %r10, %rsi
jl 0x1a77
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/syzcch[P]FEC_C_version/./fec_rdp.h
// Function: rdp::rdp_decoding_r(char**, int, int, int, int)
void rdp_decoding_r(char * g_data[], int disks, int stripe_unit_size, int w, int k)
    {
        int off = 0;
        int p = 0;
        int packet_size = stripe_unit_size / w;
        int i = 0;

        memcpy(g_data[k],g_data[0],stripe_unit_size*sizeof(char));
        for(i=2; i<(disks+2); i++)
        {
            if(i==k) continue;
            for (p = 0; p < w; p++)
            {
                for (off = 0; off < packet_size; off++)
                {
                    g_data[k][p * packet_size + off]^=g_data[i][p * packet_size + off];
                }
            }
        }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r13d
movl %edx, %r14d
movq %rsi, %r15
movl %r9d, -0x2c(%rbp)
movslq %r9d, %r12
movq (%rsi,%r12,8), %rdi
movq (%rsi), %rsi
movslq %ecx, %rdx
callq 0x1070
testl %r14d, %r14d
jle 0x1e94
movl %r13d, %eax
cltd
idivl %ebx
movl -0x2c(%rbp), %ecx
addl $0x2, %r14d
movl %ebx, %edx
movl $0x2, %esi
testl %ebx, %ebx
setle %dil
cmpq %rcx, %rsi
sete %r8b
orb %dil, %r8b
jne 0x1e8c
xorl %edi, %edi
xorl %r8d, %r8d
testl %eax, %eax
jle 0x1e81
movq %rax, %r9
movq %rdi, %r10
movq (%r15,%rsi,8), %r11
movb (%r11,%r10), %r11b
movq (%r15,%r12,8), %r13
xorb %r11b, (%r13,%r10)
incq %r10
decq %r9
jne 0x1e68
incq %r8
addq %rax, %rdi
cmpq %rdx, %r8
jne 0x1e5e
incq %rsi
cmpq %r14, %rsi
jne 0x1e47
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DavidLBruce[P]sim3dof/build/../src/Autopilot.cpp
// Function: Autopilot::Autopilot()
Autopilot::Autopilot() :
MdlBase()
{
  //
  // Default initialization of input variables
  //
  frameTimeStep = 1.0/64.0;  // sec     Frame time step
  initFrameTime = 0.0;       // sec     Time of first frame update

  accLim = 300.0;            // m/sec^2 Acceleration limit
  tau = 0.2;                 // sec     Control system time constant
                             //         Autopilot, Aero, & CAS
  //
  // Register states for integration
  //
  RegisterState( x0, x0d );
  RegisterState( x1, x1d );
  RegisterState( x2, x2d );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x9fd0
leaq 0x1a2c6(%rip), %rax     # 0x1d890
movq %rax, (%rbx)
movabsq $0x3f90000000000000, %rax # imm = 0x3F90000000000000
movq %rax, 0x8(%rbx)
movq $0x0, 0xf8(%rbx)
movabsq $0x4072c00000000000, %rax # imm = 0x4072C00000000000
movq %rax, 0x100(%rbx)
movabsq $0x3fc999999999999a, %rax # imm = 0x3FC999999999999A
movq %rax, 0x108(%rbx)
leaq 0x138(%rbx), %rsi
leaq 0x140(%rbx), %rdx
movq %rbx, %rdi
callq 0xa2c2
leaq 0x148(%rbx), %rsi
leaq 0x150(%rbx), %rdx
movq %rbx, %rdi
callq 0xa2c2
leaq 0x158(%rbx), %rsi
leaq 0x160(%rbx), %rdx
movq %rbx, %rdi
callq 0xa2c2
popq %rbx
popq %r14
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/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 0x9fd0
leaq 0x19f8f(%rip), %rax     # 0x1d8f8
movq %rax, (%rbx)
movabsq $0x3f90000000000000, %rax # imm = 0x3F90000000000000
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0xf8(%rbx)
movabsq $-0x3f3c780000000000, %rcx # imm = 0xC0C3880000000000
movq %rcx, 0x100(%rbx)
movq %rax, 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_O3/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 0x4350
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 0x13a6c
movq %r14, %rdi
callq 0x134aa
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x139a6
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
movq %r15, (%rax)
addq $0x158, %rbx            # imm = 0x158
movq %rbx, %rdi
movl %r14d, %esi
callq 0x139a6
movq %r15, (%rax,%r14,8)
incq %r14
cmpq $0x3, %r14
jne 0x432c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x158(%rdi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rdi)
movups %xmm0, 0x138(%rdi)
leaq -0xf0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x170(%rbx), %rsi
leaq -0xd8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x188(%rbx), %rsi
leaq -0xc0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
movb $0x0, 0x1a0(%rbx)
leaq 0x1a8(%rbx), %rsi
leaq -0xa8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x1c0(%rbx), %rsi
leaq -0x90(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
xorl %r15d, %r15d
movq %r15, 0x1d8(%rbx)
leaq 0x1e0(%rbx), %rsi
leaq -0x78(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x1f8(%rbx), %rsi
leaq -0x60(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x228(%rbx), %rsi
movq %r15, 0x220(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x210(%rbx)
leaq -0x48(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
movq %r15, 0x240(%rbx)
addq $0x248, %rbx            # imm = 0x248
leaq -0x30(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
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 0x4631
movb $0x1, 0x1a0(%rbx)
movsd 0x108(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0x248(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x118(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x100(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x110(%rbx), %xmm0
mulsd 0x218(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0x1f8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x139a6
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd 0x120(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x139a6
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x128(%rbx), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x2, %esi
callq 0x139a6
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x8(%rbx), %xmm0
movq %rbx, %rdi
callq 0x46c4
movsd 0x1d8(%rbx), %xmm0
movq %rbx, %rdi
callq 0x4b22
leaq 0x248(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, 0x138(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, 0x140(%rbx)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, 0x150(%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x46ad
sqrtsd %xmm0, %xmm0
jmp 0x46b2
callq 0x3120
movsd %xmm0, 0x148(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movl $0x3, %esi
movl $0x1, %edx
callq 0x13378
movq %r14, %rdi
movl $0x1, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13918
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13918
movsd (%rax), %xmm0
movapd %xmm0, -0x20(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13918
movapd -0x20(%rbp), %xmm0
xorpd 0x1069c(%rip), %xmm0    # 0x16010
movsd -0x28(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rax)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13918
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x134aa
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5f6c
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
movq %r14, %rdi
movl %r15d, %esi
callq 0x139a6
movq %r12, (%rax,%r15,8)
incq %r15
cmpq $0x6, %r15
jne 0x5ea2
leaq 0x1d8(%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
addq $0x1f0, %rbx            # imm = 0x1F0
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %rbx, %rsi
callq 0x139f0
leaq -0x68(%rbp), %rdi
callq 0x134aa
leaq -0x38(%rbp), %rdi
callq 0x134aa
leaq -0x50(%rbp), %rdi
callq 0x134aa
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x134aa
jmp 0x5f5b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x134aa
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x1b8(%rdi)
leaq 0x110(%rdi), %rsi
leaq -0x138(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x1c0(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rbx)
movups %xmm0, 0x138(%rbx)
movups %xmm0, 0x128(%rbx)
leaq -0x120(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x1d8(%rbx), %rsi
leaq -0x108(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x1f0(%rbx), %rsi
leaq -0xf0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
movb $0x0, 0x208(%rbx)
leaq 0x210(%rbx), %rsi
leaq -0xd8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x228(%rbx), %rsi
leaq -0xc0(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x258(%rbx), %rsi
movq %r15, 0x250(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x240(%rbx)
leaq -0xa8(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x270(%rbx), %rsi
leaq -0x90(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x288(%rbx), %rsi
leaq -0x78(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
leaq 0x2a0(%rbx), %rsi
leaq -0x60(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
movq %r15, 0x2b8(%rbx)
leaq 0x2c0(%rbx), %rsi
leaq -0x48(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
movq %r15, 0x2d8(%rbx)
leaq 0x2e0(%rbx), %rsi
leaq -0x30(%rbp), %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x13a6c
movq %r14, %rdi
callq 0x134aa
movq %r15, 0x2f8(%rbx)
movq %r15, 0x158(%rbx)
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
movl $0x2, %esi
callq 0x13918
movsd 0xe07c(%rip), %xmm0     # 0x16038
divsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x13918
movsd (%rax), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x13918
movsd (%rax), %xmm0
callq 0x3310
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x13918
movsd (%rax), %xmm0
callq 0x3080
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13918
movsd -0x38(%rbp), %xmm0
movapd %xmm0, %xmm1
mulsd -0x28(%rbp), %xmm1
movsd %xmm1, -0x30(%rbp)
movsd (%rax), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13918
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13918
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13918
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x4, %esi
callq 0x13918
movsd (%rax), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x13918
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
subsd %xmm0, %xmm1
mulsd -0x38(%rbp), %xmm1
movsd %xmm1, -0x18(%rbp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x4, %esi
callq 0x13918
movsd -0x20(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x13918
movsd -0x28(%rbp), %xmm0
mulsd (%rax), %xmm0
addsd -0x20(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13918
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
xorps %xmm0, %xmm0
movl $0x6, %esi
movl $0x1, %edx
callq 0x13378
movq %r14, %rdi
movl $0x2, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x3, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x4, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movl $0x5, %esi
callq 0x13918
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13918
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13918
movq $0x0, (%rax)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13918
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x134aa
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $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 0x8ada
cmpq $0x0, 0x1e0(%rdi)
je 0x8af9
movq 0x1e8(%rdi), %rax
testq %rax, %rax
je 0x8b18
cmpq $0x0, 0x1f0(%rdi)
je 0x8b37
cmpq $0x0, 0x1f8(%rdi)
je 0x8b56
cmpq $0x0, 0x200(%rdi)
je 0x8b75
cmpq $0x0, 0x208(%rdi)
je 0x8b94
movl 0x100(%rdi), %ecx
movl %ecx, 0x160(%rdi)
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
movsd %xmm0, 0x30(%rdi)
popq %rbp
retq
leaq 0xd9ef(%rip), %rdi      # 0x164d0
leaq 0xd9ec(%rip), %rsi      # 0x164d4
leaq 0xd9f9(%rip), %rcx      # 0x164e8
movl $0x6a, %edx
callq 0x30f0
leaq 0xda0c(%rip), %rdi      # 0x1650c
leaq 0xd9cd(%rip), %rsi      # 0x164d4
leaq 0xd9da(%rip), %rcx      # 0x164e8
movl $0x6b, %edx
callq 0x30f0
leaq 0xd9f3(%rip), %rdi      # 0x16512
leaq 0xd9ae(%rip), %rsi      # 0x164d4
leaq 0xd9bb(%rip), %rcx      # 0x164e8
movl $0x6c, %edx
callq 0x30f0
leaq 0xd9d9(%rip), %rdi      # 0x16517
leaq 0xd98f(%rip), %rsi      # 0x164d4
leaq 0xd99c(%rip), %rcx      # 0x164e8
movl $0x6d, %edx
callq 0x30f0
leaq 0xd9c2(%rip), %rdi      # 0x1651f
leaq 0xd970(%rip), %rsi      # 0x164d4
leaq 0xd97d(%rip), %rcx      # 0x164e8
movl $0x6e, %edx
callq 0x30f0
leaq 0xd9a8(%rip), %rdi      # 0x16524
leaq 0xd951(%rip), %rsi      # 0x164d4
leaq 0xd95e(%rip), %rcx      # 0x164e8
movl $0x6f, %edx
callq 0x30f0
leaq 0xd98e(%rip), %rdi      # 0x16529
leaq 0xd932(%rip), %rsi      # 0x164d4
leaq 0xd93f(%rip), %rcx      # 0x164e8
movl $0x70, %edx
callq 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9264
leaq 0xce86(%rip), %r14      # 0x16040
leaq 0xd36e(%rip), %rdx      # 0x1652f
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd365(%rip), %rdx      # 0x1653a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd35a(%rip), %rdx      # 0x16543
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd34f(%rip), %rdx      # 0x1654c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd346(%rip), %rdx      # 0x16557
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd33d(%rip), %rdx      # 0x16562
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd334(%rip), %rdx      # 0x1656d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd32b(%rip), %rdx      # 0x16578
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 0x120(%rdi), %xmm0
leaq 0xcdf4(%rip), %r15      # 0x1606a
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x148(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x158(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x178(%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 0x190(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
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 0x3230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd1fe(%rip), %xmm1     # 0x165b0
jbe 0x940a
divsd %xmm1, %xmm0
cvttpd2dq %xmm0, %xmm2
cvtdq2pd %xmm2, %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
andpd 0xd1d0(%rip), %xmm3     # 0x165a0
ucomisd 0xcd90(%rip), %xmm3     # 0x16168
jae 0x93e0
movapd %xmm2, %xmm0
jmp 0x9406
cvttsd2si %xmm0, %eax
xorpd %xmm2, %xmm2
xorl %ecx, %ecx
ucomisd %xmm0, %xmm2
seta %cl
leaq 0xd198(%rip), %rdx      # 0x16590
cvttsd2si (%rdx,%rcx,8), %ecx
addl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movsd (%rdi), %xmm2
movapd %xmm2, %xmm3
maxsd %xmm0, %xmm3
leal -0x1(%rdx), %eax
movslq %edx, %rcx
movsd -0x8(%rdi,%rcx,8), %xmm0
movapd %xmm0, %xmm1
minsd %xmm3, %xmm1
ucomisd %xmm0, %xmm1
jne 0x943c
jp 0x943c
movl %eax, %ecx
jmp 0x9446
xorl %ecx, %ecx
ucomisd %xmm2, %xmm1
jne 0x9450
jp 0x9450
movslq %ecx, %rax
movsd (%rsi,%rax,8), %xmm0
popq %rbp
retq
xorl %ecx, %ecx
cmpl $0x3, %edx
jl 0x9493
xorl %edx, %edx
leal (%rdx,%rax), %ecx
movl %ecx, %r8d
shrl $0x1f, %r8d
addl %ecx, %r8d
sarl %r8d
movslq %r8d, %rcx
movsd (%rdi,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
cmovbel %ecx, %edx
cmovael %ecx, %eax
ucomisd %xmm0, %xmm1
cmovnel %edx, %ecx
cmovpl %edx, %ecx
movl %eax, %r8d
subl %ecx, %r8d
movl %ecx, %edx
cmpl $0x1, %r8d
jg 0x9459
cmpl %eax, %ecx
je 0x9438
movslq %ecx, %rcx
movsd (%rsi,%rcx,8), %xmm2
movsd (%rdi,%rcx,8), %xmm3
subsd %xmm3, %xmm1
cltq
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 0x944e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14b1b(%rip), %r8      # 0x1e1c0
testq %r8, %r8
setne %dl
movabsq $0x41a705af1fe3fb79, %rsi # imm = 0x41A705AF1FE3FB79
testb %dl, %al
jne 0x972d
movq %rcx, %rax
negq %rax
testq %rcx, %rcx
movl $0x1, %ecx
cmovsq %rax, %rcx
movl $0x27, %r8d
leaq 0x14af8(%rip), %r9      # 0x1e1d0
movq %rcx, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rdx     # imm = 0xF4EC
leaq (%rax,%rdx), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
addq %rdx, %rax
cmovnsq %rax, %rcx
cmpq $0x1f, %r8
ja 0x9720
movq %rcx, (%r9,%r8,8)
addq $-0x1, %r8
jb 0x96d8
movq 0x14aa3(%rip), %r8      # 0x1e1d0
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rax,%rcx), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rax,%rcx), %rax
cmovgq %rdx, %rax
movq %rax, (%rdi)
leaq 0x3ffffff(%r8), %rcx
testq %r8, %r8
cmovnsq %r8, %rcx
shrq $0x1a, %rcx
movslq %ecx, %rcx
leaq 0x14a41(%rip), %rdx     # 0x1e1d0
movq (%rdx,%rcx,8), %rsi
movq %rsi, 0x14a26(%rip)     # 0x1e1c0
cvtsi2sd %rsi, %xmm1
mulsd 0xce11(%rip), %xmm1     # 0x165b8
movq %rax, (%rdx,%rcx,8)
movsd 0xce0d(%rip), %xmm0     # 0x165c0
minsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %edi, %edi
jle 0x9978
movl %edi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rsi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x9969
jmp 0x997c
xorpd %xmm0, %xmm0
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %edi, %edi
jle 0x99af
movl %edi, %eax
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x999a
xorps %xmm2, %xmm2
cvtsi2sd %edi, %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x99c6
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9a46
jl 0x9a19
movl %edi, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x99df
cvtsi2sd %edi, %xmm2
testl %edi, %edi
jle 0x9a1f
divsd %xmm2, %xmm1
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x99fe
jmp 0x9a23
cvtsi2sd %edi, %xmm2
jmp 0x9a23
xorpd %xmm0, %xmm0
pushq %rbp
movq %rsp, %rbp
addsd 0xc601(%rip), %xmm2     # 0x16030
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
popq %rbp
jb 0x3120
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %xmm1
testl %edi, %edi
jle 0x9a6e
movl %edi, %eax
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm0
maxsd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jne 0x9a57
jmp 0x9a72
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: minimum(int, double*)
double minimum(int    samples,
               double *data)
{
  double min = data[0];
  double mm;
  int i;

  for (i = 0; i < samples; i++) {

    mm = data[i];

    if (mm < min)
      min = mm;
  }

  return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd (%rsi), %xmm1
testl %edi, %edi
jle 0x9a9b
movl %edi, %eax
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm0
minsd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jne 0x9a84
jmp 0x9a9f
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a(%rip), %rcx        # 0x9b05
movl $0x8, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3320
testb $0x1, %r15b
jne 0x9aec
sarl %r14d
movslq %r14d, %rax
movsd -0x8(%rbx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
mulsd 0xc67e(%rip), %xmm0     # 0x16168
jmp 0x9afa
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_O3/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, %ebx
movl %esi, %r14d
movq %rdi, %r15
movsd (%rdi), %xmm1
movl %esi, %r12d
testl %esi, %esi
jle 0x9c29
xorl %eax, %eax
movapd %xmm1, %xmm0
movapd %xmm0, %xmm2
movsd (%r15,%rax,8), %xmm0
minsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r12
jne 0x9bf4
xorl %eax, %eax
movapd %xmm1, %xmm2
movsd (%r15,%rax,8), %xmm1
maxsd %xmm2, %xmm1
incq %rax
cmpq %rax, %r12
jne 0x9c0c
movsd %xmm1, -0x30(%rbp)
jmp 0x9c32
movsd %xmm1, -0x30(%rbp)
movapd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq 0xc992(%rip), %rdi      # 0x165d0
xorl %esi, %esi
xorl %edx, %edx
movb $0x1, %al
callq 0x3040
movsd -0x38(%rbp), %xmm2
testl %ebx, %ebx
movsd -0x30(%rbp), %xmm1
jle 0x9d0d
subsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %r13d
movsd 0xc3bf(%rip), %xmm3     # 0x16038
movapd %xmm2, %xmm4
movsd %xmm1, -0x30(%rbp)
movapd %xmm1, %xmm0
mulsd %xmm3, %xmm0
divsd -0x40(%rbp), %xmm0
addsd %xmm2, %xmm0
testl %r14d, %r14d
movsd %xmm3, -0x48(%rbp)
jle 0x9cc9
xorl %eax, %eax
xorl %edx, %edx
movsd (%r15,%rax,8), %xmm1
movapd %xmm4, %xmm2
cmplepd %xmm1, %xmm2
cmpltpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %ecx
subl %ecx, %edx
incq %rax
cmpq %rax, %r12
jne 0x9ca1
jmp 0x9ccb
xorl %edx, %edx
leaq 0xc8fe(%rip), %rdi      # 0x165d0
movl %r13d, %esi
movb $0x1, %al
movapd %xmm0, -0x60(%rbp)
callq 0x3040
movsd -0x48(%rbp), %xmm3
addsd 0xc34a(%rip), %xmm3     # 0x16038
leal 0x1(%r13), %eax
movapd -0x60(%rbp), %xmm4
cmpl %ebx, %r13d
movl %eax, %r13d
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
jne 0x9c82
addq $0x38, %rsp
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/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, %ebx
movl %esi, %r14d
movq %rdi, %r15
movsd (%rdi), %xmm1
movl %esi, %r12d
testl %esi, %esi
jle 0x9d7b
xorl %eax, %eax
movapd %xmm1, %xmm0
movapd %xmm0, %xmm2
movsd (%r15,%rax,8), %xmm0
minsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r12
jne 0x9d46
xorl %eax, %eax
movapd %xmm1, %xmm2
movsd (%r15,%rax,8), %xmm1
maxsd %xmm2, %xmm1
incq %rax
cmpq %rax, %r12
jne 0x9d5e
movsd %xmm1, -0x30(%rbp)
jmp 0x9d84
movsd %xmm1, -0x30(%rbp)
movapd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq 0xc851(%rip), %rdi      # 0x165e1
xorpd %xmm1, %xmm1
xorl %esi, %esi
xorl %edx, %edx
movb $0x2, %al
callq 0x3040
movsd -0x38(%rbp), %xmm1
testl %ebx, %ebx
movsd -0x30(%rbp), %xmm0
jle 0x9e51
subsd %xmm1, %xmm0
xorps %xmm2, %xmm2
cvtsi2sd %ebx, %xmm2
movsd %xmm2, -0x48(%rbp)
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
movsd %xmm2, -0x40(%rbp)
movl $0x1, %r13d
movsd 0xc25c(%rip), %xmm2     # 0x16038
movsd %xmm0, -0x30(%rbp)
mulsd %xmm2, %xmm0
divsd -0x48(%rbp), %xmm0
addsd %xmm1, %xmm0
testl %r14d, %r14d
movsd %xmm2, -0x50(%rbp)
jle 0x9e0f
xorl %eax, %eax
xorl %edx, %edx
ucomisd (%r15,%rax,8), %xmm0
sbbl $-0x1, %edx
incq %rax
cmpq %rax, %r12
jne 0x9dfc
jmp 0x9e11
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd -0x40(%rbp), %xmm1
leaq 0xc7d4(%rip), %rdi      # 0x165f8
movl %r13d, %esi
movb $0x2, %al
callq 0x3040
movsd -0x50(%rbp), %xmm2
addsd 0xc1fd(%rip), %xmm2     # 0x16038
leal 0x1(%r13), %eax
cmpl %ebx, %r13d
movl %eax, %r13d
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
jne 0x9de1
addq $0x28, %rsp
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/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, %ebx
movl %esi, %r14d
movq %rdi, %r15
movsd (%rdi), %xmm2
movl %esi, %r13d
testl %esi, %esi
jle 0x9ed4
xorl %eax, %eax
movapd %xmm2, %xmm1
movapd %xmm1, %xmm0
movsd (%r15,%rax,8), %xmm1
minsd %xmm0, %xmm1
incq %rax
cmpq %rax, %r13
jne 0x9e8a
xorl %eax, %eax
movapd %xmm2, %xmm0
movsd (%r15,%rax,8), %xmm2
maxsd %xmm0, %xmm2
incq %rax
cmpq %rax, %r13
jne 0x9ea2
movapd 0xc6e0(%rip), %xmm0     # 0x165a0
andpd %xmm0, %xmm1
movapd %xmm1, -0x40(%rbp)
andpd %xmm0, %xmm2
movapd %xmm2, -0x50(%rbp)
jmp 0x9ee6
andpd 0xc6c4(%rip), %xmm2     # 0x165a0
movapd %xmm2, -0x50(%rbp)
movapd %xmm2, -0x40(%rbp)
leaq 0xc70b(%rip), %rdi      # 0x165f8
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorl %esi, %esi
xorl %edx, %edx
movb $0x2, %al
callq 0x3040
testl %ebx, %ebx
movapd -0x40(%rbp), %xmm0
jle 0x9fbe
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd %xmm1, -0x60(%rbp)
maxsd -0x50(%rbp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14d, %xmm1
movsd %xmm1, -0x58(%rbp)
movl $0x1, %r12d
movsd 0xc0ff(%rip), %xmm1     # 0x16038
movapd 0xc65f(%rip), %xmm2     # 0x165a0
movapd %xmm0, -0x40(%rbp)
mulsd %xmm1, %xmm0
divsd -0x60(%rbp), %xmm0
testl %r14d, %r14d
movsd %xmm1, -0x50(%rbp)
jle 0x9f78
xorl %eax, %eax
xorl %edx, %edx
movsd (%r15,%rax,8), %xmm1
andpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
sbbl $-0x1, %edx
incq %rax
cmpq %rax, %r13
jne 0x9f5d
jmp 0x9f7a
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd -0x58(%rbp), %xmm1
leaq 0xc680(%rip), %rdi      # 0x1660d
movl %r12d, %esi
movb $0x2, %al
callq 0x3040
movapd 0xc601(%rip), %xmm2     # 0x165a0
movsd -0x50(%rbp), %xmm1
addsd 0xc08c(%rip), %xmm1     # 0x16038
leal 0x1(%r12), %eax
cmpl %ebx, %r12d
movl %eax, %r12d
movapd -0x40(%rbp), %xmm0
jne 0x9f46
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq %rdi, %r14
leaq 0x13ab0(%rip), %rax     # 0x1da98
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x48(%rdi), %r12
movl $0xa8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x30e0
movabsq $0x426d132148c00000, %rax # imm = 0x426D132148C00000
movq %rax, 0x30(%r14)
movq %rax, 0x8(%r14)
leaq 0xd2e4(%rip), %rcx      # 0x17313
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x3260
movq $0x0, 0x38(%r14)
xorl %eax, %eax
movb %al, 0xf0(%r14)
movb %al, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0xd8(%r14), %rdi
testq %rdi, %rdi
je 0xa080
movq 0xe8(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0xc0(%r14), %rdi
testq %rdi, %rdi
je 0xa09b
movq 0xd0(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0xa8(%r14), %rdi
testq %rdi, %rdi
je 0xa0b6
movq 0xb8(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0xa0d1
movq 0xa0(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0xa0e9
movq 0x88(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0xa0fe
movq 0x70(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa113
movq 0x58(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0xa127
movq (%r13), %rsi
incq %rsi
callq 0x31a0
movq %r15, %rdi
callq 0x32d0
nop