LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x930e
leaq 0xcddc(%rip), %r14      # 0x16040
leaq 0xd2c4(%rip), %rdx      # 0x1652f
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd2bb(%rip), %rdx      # 0x1653a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd2b0(%rip), %rdx      # 0x16543
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd2a5(%rip), %rdx      # 0x1654c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd29c(%rip), %rdx      # 0x16557
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd293(%rip), %rdx      # 0x16562
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd28a(%rip), %rdx      # 0x1656d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0xd281(%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 0xcd4a(%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
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd152(%rip), %xmm1     # 0x165b0
jbe 0x94b0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm2
cvtdq2pd %xmm2, %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
andpd 0xd120(%rip), %xmm3     # 0x165a0
ucomisd 0xcce0(%rip), %xmm3     # 0x16168
jb 0x94a5
xorpd %xmm2, %xmm2
xorl %ecx, %ecx
ucomisd %xmm0, %xmm2
seta %cl
leaq 0xd0f2(%rip), %rdx      # 0x16590
cvttsd2si (%rdx,%rcx,8), %ecx
addl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x94e2
jp 0x94e2
movl %eax, %ecx
jmp 0x9531
xorl %ecx, %ecx
ucomisd %xmm2, %xmm1
jne 0x94f0
jp 0x94f0
xorl %eax, %eax
jmp 0x9531
cmpl $0x3, %edx
jl 0x9531
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 0x94f7
cmpl %eax, %ecx
jne 0x953e
cltq
movsd (%rsi,%rax,8), %xmm0
jmp 0x956f
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
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movabsq $0x41a705af1fe3fb79, %rsi # imm = 0x41A705AF1FE3FB79
testq %rax, %rax
jle 0x975c
cmpq $0x0, 0x14a6a(%rip)     # 0x1e1c0
jne 0x97dd
movq %rax, %rdx
negq %rdx
testq %rax, %rax
movl $0x1, %ecx
cmovsq %rdx, %rcx
movq %rcx, (%rdi)
movl $0x27, %r8d
leaq 0x14a52(%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 0x97c6
movq %rcx, (%r9,%r8,8)
addq $-0x1, %r8
jb 0x977e
movq %rcx, (%rdi)
movq 0x149fa(%rip), %rax     # 0x1e1d0
movq %rax, 0x149e3(%rip)     # 0x1e1c0
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
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)
movq 0x14993(%rip), %rcx     # 0x1e1c0
leaq 0x3ffffff(%rcx), %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
shrq $0x1a, %rdx
movslq %edx, %rcx
leaq 0x14987(%rip), %rdx     # 0x1e1d0
movq (%rdx,%rcx,8), %rsi
movq %rsi, 0x1496c(%rip)     # 0x1e1c0
cvtsi2sd %rsi, %xmm1
mulsd 0xcd57(%rip), %xmm1     # 0x165b8
movq %rax, (%rdx,%rcx,8)
movsd 0xcd53(%rip), %xmm0     # 0x165c0
minsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9a32
movl %edi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rsi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x9a23
jmp 0x9a36
xorpd %xmm0, %xmm0
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9a69
movl %edi, %eax
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x9a54
xorps %xmm2, %xmm2
cvtsi2sd %edi, %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x9a80
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x3120
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9af4
movl %edi, %eax
xorpd %xmm1, %xmm1
jl 0x9aa6
xorl %ecx, %ecx
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x9a99
cvtsi2sd %edi, %xmm2
testl %edi, %edi
jle 0x9ad1
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 0x9ab8
pushq %rbp
movq %rsp, %rbp
addsd 0xc553(%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_O1/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 0x9b1c
movl %edi, %eax
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm0
maxsd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jne 0x9b05
jmp 0x9b20
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9b49
movl %edi, %eax
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm0
minsd %xmm1, %xmm0
incq %rcx
movapd %xmm0, %xmm1
cmpq %rcx, %rax
jne 0x9b32
jmp 0x9b4d
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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        # 0x9bb3
movl $0x8, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x3320
testb $0x1, %r15b
jne 0x9b9a
sarl %r14d
movslq %r14d, %rax
movsd -0x8(%rbx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
mulsd 0xc5d0(%rip), %xmm0     # 0x16168
jmp 0x9ba8
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_O1/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), %xmm2
movl %esi, %r12d
movapd %xmm2, %xmm0
testl %esi, %esi
jle 0x9cbc
xorl %eax, %eax
movapd %xmm2, %xmm1
movsd (%r15,%rax,8), %xmm0
minsd %xmm1, %xmm0
incq %rax
movapd %xmm0, %xmm1
cmpq %rax, %r12
jne 0x9ca6
testl %r14d, %r14d
jle 0x9cdb
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
maxsd %xmm2, %xmm1
incq %rax
movapd %xmm1, %xmm2
cmpq %rax, %r12
jne 0x9cc3
jmp 0x9cdf
movapd %xmm2, %xmm1
movsd %xmm1, -0x30(%rbp)
leaq 0xc8e5(%rip), %rdi      # 0x165d0
xorl %esi, %esi
xorl %edx, %edx
movb $0x1, %al
movsd %xmm0, -0x38(%rbp)
callq 0x3040
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
testl %ebx, %ebx
jle 0x9dbf
subsd %xmm1, %xmm2
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %r13d
movsd 0xc30d(%rip), %xmm3     # 0x16038
movapd %xmm1, %xmm4
movsd %xmm2, -0x30(%rbp)
movapd %xmm2, %xmm0
mulsd %xmm3, %xmm0
divsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
testl %r14d, %r14d
movsd %xmm3, -0x48(%rbp)
jle 0x9d7b
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 0x9d53
jmp 0x9d7d
xorl %edx, %edx
leaq 0xc84c(%rip), %rdi      # 0x165d0
movl %r13d, %esi
movb $0x1, %al
movapd %xmm0, -0x60(%rbp)
callq 0x3040
movsd -0x48(%rbp), %xmm3
addsd 0xc298(%rip), %xmm3     # 0x16038
leal 0x1(%r13), %eax
movapd -0x60(%rbp), %xmm4
cmpl %ebx, %r13d
movl %eax, %r13d
movsd -0x38(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
jne 0x9d34
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm2
movl %esi, %r12d
movapd %xmm2, %xmm0
testl %esi, %esi
jle 0x9e12
xorl %eax, %eax
movapd %xmm2, %xmm1
movsd (%r15,%rax,8), %xmm0
minsd %xmm1, %xmm0
incq %rax
movapd %xmm0, %xmm1
cmpq %rax, %r12
jne 0x9dfc
testl %r14d, %r14d
jle 0x9e31
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
maxsd %xmm2, %xmm1
incq %rax
movapd %xmm1, %xmm2
cmpq %rax, %r12
jne 0x9e19
jmp 0x9e35
movapd %xmm2, %xmm1
movsd %xmm1, -0x30(%rbp)
leaq 0xc7a0(%rip), %rdi      # 0x165e1
xorpd %xmm1, %xmm1
xorl %esi, %esi
xorl %edx, %edx
movb $0x2, %al
movsd %xmm0, -0x38(%rbp)
callq 0x3040
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
testl %ebx, %ebx
jle 0x9f07
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 0xc1a6(%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 0x9ec5
xorl %eax, %eax
xorl %edx, %edx
ucomisd (%r15,%rax,8), %xmm0
sbbl $-0x1, %edx
incq %rax
cmpq %rax, %r12
jne 0x9eb2
jmp 0x9ec7
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd -0x40(%rbp), %xmm1
leaq 0xc71e(%rip), %rdi      # 0x165f8
movl %r13d, %esi
movb $0x2, %al
callq 0x3040
movsd -0x50(%rbp), %xmm2
addsd 0xc147(%rip), %xmm2     # 0x16038
leal 0x1(%r13), %eax
cmpl %ebx, %r13d
movl %eax, %r13d
movsd -0x38(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
jne 0x9e97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm0
movl %esi, %r13d
movapd %xmm0, %xmm2
testl %esi, %esi
jle 0x9f5a
xorl %eax, %eax
movapd %xmm0, %xmm1
movsd (%r15,%rax,8), %xmm2
minsd %xmm1, %xmm2
incq %rax
movapd %xmm2, %xmm1
cmpq %rax, %r13
jne 0x9f44
testl %r14d, %r14d
movapd %xmm2, -0x40(%rbp)
jle 0x9f7e
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm1
maxsd %xmm0, %xmm1
incq %rax
movapd %xmm1, %xmm0
cmpq %rax, %r13
jne 0x9f66
jmp 0x9f82
movapd %xmm0, %xmm1
movapd %xmm1, -0x50(%rbp)
leaq 0xc66a(%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 0xa073
andpd 0xc5ea(%rip), %xmm0     # 0x165a0
movapd -0x50(%rbp), %xmm2
andpd 0xc5dd(%rip), %xmm2     # 0x165a0
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd %xmm1, -0x60(%rbp)
maxsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14d, %xmm1
movsd %xmm1, -0x58(%rbp)
movl $0x1, %r12d
movsd 0xc04a(%rip), %xmm1     # 0x16038
movapd 0xc5aa(%rip), %xmm2     # 0x165a0
movapd %xmm0, -0x40(%rbp)
mulsd %xmm1, %xmm0
divsd -0x60(%rbp), %xmm0
testl %r14d, %r14d
movsd %xmm1, -0x50(%rbp)
jle 0xa02d
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 0xa012
jmp 0xa02f
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd -0x58(%rbp), %xmm1
leaq 0xc5cb(%rip), %rdi      # 0x1660d
movl %r12d, %esi
movb $0x2, %al
callq 0x3040
movapd 0xc54c(%rip), %xmm2     # 0x165a0
movsd -0x50(%rbp), %xmm1
addsd 0xbfd7(%rip), %xmm1     # 0x16038
leal 0x1(%r12), %eax
cmpl %ebx, %r12d
movl %eax, %r12d
movapd -0x40(%rbp), %xmm0
jne 0x9ffb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x139fc(%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 0xd230(%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 0xa134
movq 0xe8(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0xc0(%r14), %rdi
testq %rdi, %rdi
je 0xa14f
movq 0xd0(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0xa8(%r14), %rdi
testq %rdi, %rdi
je 0xa16a
movq 0xb8(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0xa185
movq 0xa0(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0xa19d
movq 0x88(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0xa1b2
movq 0x70(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq (%r12), %rdi
testq %rdi, %rdi
je 0xa1c7
movq 0x58(%r14), %rsi
subq %rdi, %rsi
callq 0x31a0
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0xa1db
movq (%r13), %rsi
incq %rsi
callq 0x31a0
movq %r15, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/MdlBase.cpp
// Function: MdlBase::RegisterState(double&, double&)
void MdlBase::RegisterState(double &state, double &deriv)
{
  double *ptr;
  ptr = &state; 
  m_state.push_back(ptr);

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

  intEn = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
movq 0x50(%rdi), %rsi
cmpq 0x58(%rdi), %rsi
je 0xa3a2
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0xa3af
leaq 0x48(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0xa9c8
movq %r14, -0x18(%rbp)
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0xa3c7
movq %r14, (%rsi)
addq $0x8, 0x68(%rbx)
jmp 0xa3d4
leaq 0x60(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0xa9c8
movb $0x1, 0x40(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa084
leaq 0x12db3(%rip), %rax     # 0x1daf8
movq %rax, (%rbx)
movabsq $0x426d132148c00000, %rax # imm = 0x426D132148C00000
movq %rax, 0x8(%rbx)
movq %rax, 0xf8(%rbx)
movabsq $0x408f400000000000, %rax # imm = 0x408F400000000000
movq %rax, 0x100(%rbx)
movabsq $0x403e000000000000, %rax # imm = 0x403E000000000000
movq %rax, 0x108(%rbx)
leaq 0x130(%rbx), %rsi
leaq 0x150(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xa376
leaq 0x138(%rbx), %rsi
leaq 0x160(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa376
leaq 0x118(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa376
leaq 0x128(%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa376
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa1e4
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Missile.cpp
// Function: Missile::Initialize()
void Missile::Initialize()
{
  ResetAll();

  simTime = GetSimTime();
  
  nextFrameTime = initFrameTime;

  vxb = 0.0;
  vyb = 0.0;

  vxf = vxb;
  vyf = vxb;

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

}

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

    vxb = initVxb;
    vyb = 0.0;

    vxf = vxb;
    vyf = vyb;

  }
}

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

  simTime = GetSimTime();

  ayb = pAp->ayb;

  theta = atan2( vyf, vxf );
  cth = cos( theta );
  sth = sin( theta );

  axf = axb * cth - ayb * sth;
  ayf = axb * sth + ayb * cth;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x170(%rdi)
movq 0x178(%rdi), %rax
movsd 0x118(%rax), %xmm0
movsd %xmm0, 0x120(%rdi)
movsd 0x160(%rdi), %xmm0
movsd 0x150(%rdi), %xmm1
callq 0x3060
movsd %xmm0, 0x140(%rbx)
callq 0x3310
movsd %xmm0, -0x10(%rbp)
movsd 0x140(%rbx), %xmm0
callq 0x3080
movsd 0x110(%rbx), %xmm1
movsd 0x120(%rbx), %xmm2
movapd %xmm1, %xmm3
mulsd %xmm0, %xmm1
mulsd %xmm2, %xmm0
movsd -0x10(%rbp), %xmm4
mulsd %xmm4, %xmm3
subsd %xmm0, %xmm3
movsd %xmm3, 0x118(%rbx)
mulsd %xmm2, %xmm4
addsd %xmm4, %xmm1
movsd %xmm1, 0x128(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/MslTse6.cpp
// Function: MslTse6::Initialize()
void MslTse6::Initialize()
{
  int idx;

  ResetAll();

  simTime = GetSimTime();

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

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

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

  HT = Transpose( HH );

  initFrameTime = pMsl->launchTime;

  nextFrameTime = initFrameTime;

  nextUpLinkTime = pMsl->launchTime;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0xb9ec
movq 0x38(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x4d0(%rbx)
cmpq $0x0, 0x510(%rbx)
je 0xb8f0
cmpq $0x0, 0x518(%rbx)
je 0xb90f
cmpq $0x0, 0x520(%rbx)
je 0xb92e
cmpq $0x0, 0x528(%rbx)
je 0xb94d
cmpq $0x0, 0x530(%rbx)
je 0xb96c
cmpq $0x0, 0x538(%rbx)
je 0xb98b
cmpq $0x0, 0x540(%rbx)
je 0xb9aa
leaq 0x310(%rbx), %r14
xorl %r15d, %r15d
movabsq $0x3ff0000000000000, %r12 # imm = 0x3FF0000000000000
movq %r14, %rdi
movl %r15d, %esi
callq 0x13b48
movq %r12, (%rax,%r15,8)
incq %r15
cmpq $0x6, %r15
jne 0xb827
leaq 0x328(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x13b48
movq %r12, (%rax)
movq %r14, %rdi
movl $0x1, %esi
callq 0x13b48
movq %r12, 0x10(%rax)
movq %r14, %rdi
movl $0x2, %esi
callq 0x13b48
movq %r12, 0x18(%rax)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x13576
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x15940
leaq 0x340(%rbx), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x13b92
leaq -0x68(%rbp), %rdi
callq 0x13642
leaq -0x38(%rbp), %rdi
callq 0x13642
leaq -0x50(%rbp), %rdi
callq 0x13642
movq 0x518(%rbx), %rax
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0xf8(%rbx)
movsd %xmm0, 0x30(%rbx)
movsd %xmm0, 0x108(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xac15(%rip), %rdi      # 0x1650c
leaq 0xadda(%rip), %rsi      # 0x166d8
leaq 0xade6(%rip), %rcx      # 0x166eb
movl $0x7f, %edx
callq 0x30f0
leaq 0xabfc(%rip), %rdi      # 0x16512
leaq 0xadbb(%rip), %rsi      # 0x166d8
leaq 0xadc7(%rip), %rcx      # 0x166eb
movl $0x80, %edx
callq 0x30f0
leaq 0xabea(%rip), %rdi      # 0x1651f
leaq 0xad9c(%rip), %rsi      # 0x166d8
leaq 0xada8(%rip), %rcx      # 0x166eb
movl $0x81, %edx
callq 0x30f0
leaq 0xadba(%rip), %rdi      # 0x1670e
leaq 0xad7d(%rip), %rsi      # 0x166d8
leaq 0xad89(%rip), %rcx      # 0x166eb
movl $0x82, %edx
callq 0x30f0
leaq 0xabb1(%rip), %rdi      # 0x16524
leaq 0xad5e(%rip), %rsi      # 0x166d8
leaq 0xad6a(%rip), %rcx      # 0x166eb
movl $0x83, %edx
callq 0x30f0
leaq 0xab97(%rip), %rdi      # 0x16529
leaq 0xad3f(%rip), %rsi      # 0x166d8
leaq 0xad4b(%rip), %rcx      # 0x166eb
movl $0x84, %edx
callq 0x30f0
leaq 0xad62(%rip), %rdi      # 0x16713
leaq 0xad20(%rip), %rsi      # 0x166d8
leaq 0xad2c(%rip), %rcx      # 0x166eb
movl $0x85, %edx
callq 0x30f0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x13642
jmp 0xb9da
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x13642
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/Seeker.cpp
// Function: Seeker::Seeker()
Seeker::Seeker() :
pExec(0),
pMsl(0),
pTgt(0),
MdlBase()
{
  //
  // Input parameter defaults
  //
  frameTimeStep = 1.0/180.0; // sec    Frame update interval
  initFrameTime = 0.0;       // sec    Time of first FrameUpdate

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

  //
  // Other variable initialization
  //

}

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

  simTime = GetSimTime();

  initFrameTime = pMsl->launchTime;

  nextFrameTime = initFrameTime;

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

}

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

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

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

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

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

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

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

  truAng = atan2( relPosY, relPosX );

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

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

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

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

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


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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x38(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x168(%rdi)
testl %esi, %esi
je 0xf50e
leaq 0x6bf0(%rip), %r14      # 0x16040
leaq 0x76cd(%rip), %rdx      # 0x16b24
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x76c5(%rip), %rdx      # 0x16b30
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x76bf(%rip), %rdx      # 0x16b3e
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x76b6(%rip), %rdx      # 0x16b49
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x76b0(%rip), %rdx      # 0x16b57
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x76a7(%rip), %rdx      # 0x16b62
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x769f(%rip), %rdx      # 0x16b6e
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x7696(%rip), %rdx      # 0x16b79
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x768a(%rip), %rdx      # 0x16b81
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
movq %rdi, %r14
movsd 0x118(%rdi), %xmm0
leaq 0x6b4a(%rip), %r15      # 0x1606a
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movzbl 0x120(%r14), %edx
leaq 0x764d(%rip), %rsi      # 0x16b89
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3230
movsd 0x110(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x128(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x130(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x180(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x188(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x1a0(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x3230
movsd 0x1a8(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::AddModel(MdlBase*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SimExec::AddModel( MdlBase *pMdl, string mdlName )
{
  mdlVec.push_back( pMdl );

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

  pMdl->mdlName = mdlName;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movq %rsi, -0x18(%rbp)
movq 0x220(%rdi), %rsi
cmpq 0x228(%rdi), %rsi
je 0xfa0f
movq %rax, (%rsi)
addq $0x8, 0x220(%r14)
jmp 0xfa1f
leaq 0x218(%r14), %rdi
leaq -0x18(%rbp), %rdx
callq 0x1272e
movq -0x18(%rbp), %rdi
addq $0x208, %r14            # imm = 0x208
movq %r14, 0x38(%rdi)
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x30d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::Initialize()
void  SimExec::Initialize()
{
  int idx;

  ResetAll();

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

  outputTimeStep = 1.0 / outputRate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x258(%rdi)
movw $0x0, 0x260(%rdi)
movq %rax, 0x190(%rdi)
movq %rax, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1a8(%rdi)
movq %rax, 0x1b8(%rdi)
movups %xmm0, 0x1c8(%rdi)
movups %xmm0, 0x1d8(%rdi)
movups %xmm0, 0x1e8(%rdi)
movq %rax, 0x1f8(%rdi)
movups %xmm0, 0x208(%rdi)
movups %xmm0, 0x308(%rdi)
movq %rax, 0x318(%rdi)
movups %xmm0, 0x388(%rdi)
movups %xmm0, 0x394(%rdi)
movups %xmm0, 0x3b0(%rdi)
movq 0x218(%rdi), %rax
cmpq %rax, 0x220(%rdi)
je 0xfafc
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
incq %r14
movq 0x218(%rbx), %rax
movq 0x220(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0xfad5
movsd 0x6534(%rip), %xmm0     # 0x16038
divsd 0x158(%rbx), %xmm0
movsd %xmm0, 0x390(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::FrameUpdate()
void SimExec::FrameUpdate()
{
  int    idx;
  double temp;

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

    outputTime += outputTimeStep;
  }

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

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

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

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

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

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

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

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

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movsd 0x208(%rdi), %xmm0
ucomisd 0x388(%rdi), %xmm0
jb 0xfc8b
movq 0x210(%rbx), %rdx
testq %rdx, %rdx
je 0xfc8b
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
movsd 0x390(%rbx), %xmm0
addsd 0x388(%rbx), %xmm0
movsd %xmm0, 0x388(%rbx)
movsd 0x30(%rbx), %xmm2
movsd 0x180(%rbx), %xmm1
movsd %xmm1, 0x258(%rbx)
movsd 0x208(%rbx), %xmm0
movsd 0x6a20(%rip), %xmm3     # 0x166d0
addsd %xmm2, %xmm3
ucomisd %xmm3, %xmm0
jb 0xfcc3
addsd %xmm1, %xmm2
movsd %xmm2, 0x30(%rbx)
movsd 0x30(%rbx), %xmm2
subsd %xmm0, %xmm2
subsd %xmm2, %xmm1
ucomisd 0x6ec0(%rip), %xmm1     # 0x16b98
jbe 0xfce2
movsd %xmm2, 0x258(%rbx)
cmpq $0x0, 0x210(%rbx)
je 0xfd16
movsd 0x258(%rbx), %xmm2
movsd 0x388(%rbx), %xmm1
subsd %xmm0, %xmm1
subsd %xmm1, %xmm2
ucomisd 0x6e8c(%rip), %xmm2     # 0x16b98
jbe 0xfd16
movsd %xmm1, 0x258(%rbx)
movq 0x218(%rbx), %rax
cmpq %rax, 0x220(%rbx)
je 0xfdda
xorl %r14d, %r14d
movsd 0x699b(%rip), %xmm2     # 0x166d0
movsd 0x6e5b(%rip), %xmm3     # 0x16b98
movq (%rax,%r14,8), %rdi
movq %rdi, 0x230(%rbx)
movsd 0x208(%rbx), %xmm0
movsd 0x30(%rdi), %xmm1
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0xfd8b
movq (%rdi), %rax
callq *0x28(%rax)
movsd 0x6e2b(%rip), %xmm3     # 0x16b98
movsd 0x695b(%rip), %xmm2     # 0x166d0
movq 0x230(%rbx), %rax
movsd 0x8(%rax), %xmm0
addsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movq 0x230(%rbx), %rax
movsd 0x30(%rax), %xmm0
subsd 0x208(%rbx), %xmm0
movsd 0x258(%rbx), %xmm1
subsd %xmm0, %xmm1
ucomisd %xmm3, %xmm1
jbe 0xfdb9
movsd %xmm0, 0x258(%rbx)
incq %r14
movq 0x218(%rbx), %rax
movq 0x220(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0xfd3d
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::process_command_line(int, char**)
void SimExec::process_command_line( int argc,
                                    char *argv[] )
{
  int  i;
  char name[512];
  char val[512];

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

      parse_symbols(name, val);
    }
  }
}

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

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

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

  fprintf( pOutFile, "\n" );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
testl %esi, %esi
je 0x1106b
leaq 0x4fff(%rip), %r12      # 0x16040
leaq 0x5c9d(%rip), %rdx      # 0x16ce5
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3230
leaq 0x5bd8(%rip), %rdx      # 0x16c34
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3230
jmp 0x1109d
movsd 0x208(%r14), %xmm0
leaq 0x4fef(%rip), %rsi      # 0x1606a
movq %rbx, %rdi
movb $0x1, %al
callq 0x3230
movl 0x3ac(%r14), %edx
leaq 0x5c5a(%rip), %rsi      # 0x16ced
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3230
movq 0x218(%r14), %rax
cmpq %rax, 0x220(%r14)
je 0x110e1
xorl %r12d, %r12d
movzbl %r15b, %r15d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movl %r15d, %esi
movq %rbx, %rdx
callq *0x30(%rax)
incq %r12
movq 0x218(%r14), %rax
movq 0x220(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x110b4
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O1/DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::get_args(char*, char*, char*)
void SimExec::get_args( char *in, char *name, char *val )
{
  int  i;
  int  length;

  char *ptr;

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

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

    name[i] = '\0';

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

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

  ptr = NULL;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
callq 0x30a0
testl %eax, %eax
je 0x11177
movb (%r14), %dl
cmpb $0x3d, %dl
sete %sil
testl %eax, %eax
setle %dil
xorl %ecx, %ecx
orb %sil, %dil
jne 0x1114f
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb %dl, (%r15,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
cmpb $0x3d, %dl
je 0x1114c
cmpq %rsi, %rcx
jb 0x11136
addq %rcx, %r14
movl %ecx, %edx
movb $0x0, (%r15,%rdx)
cmpl %eax, %ecx
je 0x11182
movb 0x1(%r14), %al
testb %al, %al
je 0x1117d
xorl %ecx, %ecx
movb %al, (%rbx,%rcx)
movb 0x2(%r14,%rcx), %al
incq %rcx
testb %al, %al
jne 0x11164
movl %ecx, %eax
jmp 0x1117f
movb $0x0, (%r15)
jmp 0x11182
xorl %eax, %eax
addq %rax, %rbx
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq