LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x18201(%rip), %xmm1    # 0x245d0
ucomisd %xmm1, %xmm0
jbe 0xc444
movsd -0x8(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cvttsd2si -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
subsd %xmm1, %xmm0
movaps 0x181ef(%rip), %xmm1    # 0x245f0
pand %xmm1, %xmm0
movsd 0x181cb(%rip), %xmm1    # 0x245d8
ucomisd %xmm1, %xmm0
jb 0xc42f
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xc230
movl -0x2c(%rbp), %eax
cvttsd2si %xmm0, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xc44e
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xce44
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xce1a
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xcebd
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xce7e
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x4(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x3190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0xcf02
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xcfca
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xcf3b
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xcf11
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xcfa6
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
subsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xcf5d
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x17050(%rip), %xmm2    # 0x24008
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x3190
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xd03a
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0xd02d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xd02f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcfff
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xd0b0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd0a3
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xd0a5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd06f
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x4(%rbp), %rsi
movl $0x8, %edx
leaq 0xad(%rip), %rcx        # 0xd190
callq 0x3450
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xd150
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm1
movsd 0x17493(%rip), %xmm0    # 0x245d8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xd179
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DavidLBruce[P]sim3dof/build/../src/MathUtils.cpp
// Function: compDbl(void const*, void const*)
int compDbl(const void *arg1, const void *arg2)
{
  double ansDbl;

  ansDbl = *(double*)arg1 - *(double*)arg2;

  if (ansDbl < 0.0){
    return -1;
  } else if ( ansDbl == 0 ) {
    return 0;
  } else {
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xd1c4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd1e4
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd1dd
jp 0xd1dd
movl $0x0, -0x4(%rbp)
jmp 0xd1e4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0xd050
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0xcfe0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
leaq 0x172fe(%rip), %rdi     # 0x24600
xorl %edx, %edx
movl %edx, %esi
movb $0x1, %al
callq 0x3050
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0xd3d3
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm2
mulsd %xmm2, %xmm1
cvtsi2sdl -0x10(%rbp), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd3a2
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd395
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x30(%rbp), %xmm0
jb 0xd395
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xd397
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd358
movl -0x14(%rbp), %esi
movsd -0x38(%rbp), %xmm0
movl -0x3c(%rbp), %edx
leaq 0x1724c(%rip), %rdi     # 0x24600
movb $0x1, %al
callq 0x3050
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd314
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0xd050
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0xcfe0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
leaq 0x171e9(%rip), %rdi     # 0x24611
xorl %edx, %edx
xorps %xmm1, %xmm1
movl %edx, %esi
movb $0x2, %al
callq 0x3050
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0xd4ec
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm2
mulsd %xmm2, %xmm1
cvtsi2sdl -0x10(%rbp), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd4b7
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xd4aa
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd4ac
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd481
movl -0x14(%rbp), %esi
movsd -0x30(%rbp), %xmm0
movl -0x34(%rbp), %edx
cvtsi2sdl -0x34(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm2
divsd %xmm2, %xmm1
leaq 0x17151(%rip), %rdi     # 0x24628
movb $0x2, %al
callq 0x3050
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd43d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0xd050
movaps 0x170cb(%rip), %xmm1    # 0x245f0
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0xcfe0
movaps 0x170af(%rip), %xmm1    # 0x245f0
pand %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0xc2b0
movsd %xmm0, -0x40(%rbp)
leaq 0x170bb(%rip), %rdi     # 0x24628
xorl %edx, %edx
xorps %xmm1, %xmm1
movl %edx, %esi
movaps %xmm1, %xmm0
movb $0x2, %al
callq 0x3050
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0xd631
movsd -0x40(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd5fc
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movaps 0x17019(%rip), %xmm0    # 0x245f0
pand %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xd5ef
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd5f1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd5bb
movl -0x14(%rbp), %esi
movsd -0x30(%rbp), %xmm0
movl -0x34(%rbp), %edx
cvtsi2sdl -0x34(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm2
divsd %xmm2, %xmm1
leaq 0x17021(%rip), %rdi     # 0x2463d
movb $0x2, %al
callq 0x3050
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd585
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x213ed(%rip), %rax     # 0x2ea48
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x20(%rbp)
callq 0x3310
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0xe400
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x58(%rbp)
callq 0xe400
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x50(%rbp)
callq 0xe420
movq -0x28(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x48(%rbp)
callq 0xe420
movq -0x28(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x40(%rbp)
callq 0xe420
movq -0x28(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x38(%rbp)
callq 0xe420
movq -0x28(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x30(%rbp)
callq 0xe420
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movabsq $0x426d132148c00000, %rcx # imm = 0x426D132148C00000
movq %rcx, 0x30(%rax)
movq %rcx, 0x8(%rax)
leaq 0x17af7(%rip), %rsi     # 0x25206
callq 0x3300
jmp 0xd716
movq -0x28(%rbp), %rax
movq $0x0, 0x38(%rax)
movb $0x0, 0xf0(%rax)
movb $0x0, 0x40(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xe440
movq -0x38(%rbp), %rdi
callq 0xe440
movq -0x40(%rbp), %rdi
callq 0xe440
movq -0x48(%rbp), %rdi
callq 0xe440
movq -0x50(%rbp), %rdi
callq 0xe440
movq -0x58(%rbp), %rdi
callq 0xe4a0
movq -0x60(%rbp), %rdi
callq 0xe4a0
movq -0x20(%rbp), %rdi
callq 0x3140
movq -0x10(%rbp), %rdi
callq 0x33d0
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x48, %rdi
leaq -0x20(%rbp), %rsi
callq 0xe790
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
leaq -0x20(%rbp), %rsi
callq 0xe790
movq -0x28(%rbp), %rax
movb $0x1, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xd640
movq -0x20(%rbp), %rdi
leaq 0x1da64(%rip), %rax     # 0x2eaa8
movq %rax, (%rdi)
movabsq $0x426d132148c00000, %rax # imm = 0x426D132148C00000
movq %rax, 0x8(%rdi)
movq %rax, 0xf8(%rdi)
movabsq $0x408f400000000000, %rax # imm = 0x408F400000000000
movq %rax, 0x100(%rdi)
movabsq $0x403e000000000000, %rax # imm = 0x403E000000000000
movq %rax, 0x108(%rdi)
movq %rdi, %rsi
addq $0x130, %rsi            # imm = 0x130
movq %rdi, %rdx
addq $0x150, %rdx            # imm = 0x150
callq 0xd9d0
jmp 0x11099
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x138, %rsi            # imm = 0x138
movq %rdi, %rdx
addq $0x160, %rdx            # imm = 0x160
callq 0xd9d0
jmp 0x110b8
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x150, %rsi            # imm = 0x150
movq %rdi, %rdx
addq $0x118, %rdx            # imm = 0x118
callq 0xd9d0
jmp 0x110d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x160, %rsi            # imm = 0x160
movq %rdi, %rdx
addq $0x128, %rdx            # imm = 0x128
callq 0xd9d0
jmp 0x110f6
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd790
movq -0x10(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x11230
movq -0x10(%rbp), %rdi
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x170(%rax)
movsd 0xf8(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rax)
movsd 0x148(%rax), %xmm0
movsd %xmm0, 0x150(%rax)
movsd 0x148(%rax), %xmm0
movsd %xmm0, 0x160(%rax)
movq 0x180(%rax), %rcx
movsd 0x178(%rcx), %xmm0
subsd 0x108(%rax), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd 0x100(%rax), %xmm0
movsd %xmm0, 0x130(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x138(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: DavidLBruce[P]sim3dof/build/../src/Missile.cpp
// Function: Missile::ResetAll()
void Missile::ResetAll()
{
  axb         = 0.0;
  axf         = 0.0;
  ayb         = 0.0;
  ayf         = 0.0;
  initialized = false;
  pxf         = 0.0;
  pyf         = 0.0;
  simTime     = 0.0;
  theta       = 0.0;
  vxb         = 0.0;
  vxf         = 0.0;
  vyb         = 0.0;
  vyf         = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x110(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x118(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x120(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x128(%rax)
movb $0x0, 0x168(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x130(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x138(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x170(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x140(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x160(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x170(%rax)
movsd 0x170(%rax), %xmm0
ucomisd 0x108(%rax), %xmm0
jbe 0x1138a
movq -0x10(%rbp), %rax
testb $0x1, 0x168(%rax)
jne 0x1138a
movq -0x10(%rbp), %rax
movb $0x1, 0x168(%rax)
movsd 0x100(%rax), %xmm0
movsd %xmm0, 0x148(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rax)
movsd 0x148(%rax), %xmm0
movsd %xmm0, 0x150(%rax)
movsd 0x158(%rax), %xmm0
movsd %xmm0, 0x160(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3c40
movq -0x20(%rbp), %rax
movsd %xmm0, 0x170(%rax)
movq 0x178(%rax), %rcx
movsd 0x118(%rcx), %xmm0
movsd %xmm0, 0x120(%rax)
movsd 0x160(%rax), %xmm0
movsd 0x150(%rax), %xmm1
callq 0x3070
movq -0x20(%rbp), %rax
movsd %xmm0, 0x140(%rax)
movsd 0x140(%rax), %xmm0
callq 0x3430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x10(%rbp)
movsd 0x140(%rax), %xmm0
callq 0x30a0
movq -0x20(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd 0x110(%rax), %xmm0
movsd -0x10(%rbp), %xmm2
movsd 0x120(%rax), %xmm1
mulsd -0x18(%rbp), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x118(%rax)
movsd 0x110(%rax), %xmm0
movsd -0x18(%rbp), %xmm2
movsd 0x120(%rax), %xmm1
mulsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x128(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xd640
movq -0x10(%rbp), %rax
leaq 0x17974(%rip), %rcx     # 0x2eb68
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x1b0(%rax)
movq $0x0, 0x1b8(%rax)
movq $0x0, 0x1c0(%rax)
movsd 0xd99c(%rip), %xmm0     # 0x24bc0
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x108(%rax)
movsd 0xd97c(%rip), %xmm0     # 0x24bb8
movsd %xmm0, 0xf8(%rax)
movsd 0xd964(%rip), %xmm0     # 0x24bb0
movsd %xmm0, 0x100(%rax)
movsd 0xd94c(%rip), %xmm0     # 0x24ba8
movsd %xmm0, 0x110(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x17350
movq -0x10(%rbp), %rdi
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x168(%rax)
movq 0x1b8(%rax), %rcx
movsd 0x108(%rcx), %xmm0
movsd %xmm0, 0x108(%rax)
movsd 0x108(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
movq 0x1b8(%rax), %rcx
movsd 0x130(%rcx), %xmm0
movsd %xmm0, 0x138(%rax)
movq 0x1b8(%rax), %rcx
movsd 0x138(%rcx), %xmm0
movsd %xmm0, 0x140(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DavidLBruce[P]sim3dof/build/../src/Seeker.cpp
// Function: Seeker::ResetAll()
void Seeker::ResetAll()
{
  measAng   = 0.0;
  measValid = false;
  pxf       = 0.0;
  pyf       = 0.0;
  relPosX   = 0.0;
  relPosY   = 0.0;
  relVelX   = 0.0;
  relVelY   = 0.0;
  simTime   = 0.0;
  timeStamp = 0.0; 
  truAng    = 0.0;
  truPosX   = 0.0;
  truPosY   = 0.0;
  truRdot   = 0.0;
  truRng    = 0.0;
  truVelX   = 0.0;
  truVelY   = 0.0;
  vxf       = 0.0;
  vyf       = 0.0; 
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x118(%rax)
movb $0x0, 0x120(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x138(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x140(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x148(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x158(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x160(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x168(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x128(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x130(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x170(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x178(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x180(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x188(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x190(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x198(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1a0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1a8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3c40
movq -0x10(%rbp), %rax
movsd %xmm0, 0x168(%rax)
movq 0x1b8(%rax), %rcx
movsd 0x130(%rcx), %xmm0
movsd %xmm0, 0x138(%rax)
movq 0x1b8(%rax), %rcx
movsd 0x138(%rcx), %xmm0
movsd %xmm0, 0x140(%rax)
movq 0x1b8(%rax), %rcx
movsd 0x150(%rcx), %xmm0
movsd %xmm0, 0x1a0(%rax)
movq 0x1b8(%rax), %rcx
movsd 0x160(%rcx), %xmm0
movsd %xmm0, 0x1a8(%rax)
movq 0x1c0(%rax), %rcx
movsd 0x160(%rcx), %xmm0
movsd %xmm0, 0x170(%rax)
movq 0x1c0(%rax), %rcx
movsd 0x168(%rcx), %xmm0
movsd %xmm0, 0x178(%rax)
movq 0x1c0(%rax), %rcx
movsd 0x180(%rcx), %xmm0
movsd %xmm0, 0x190(%rax)
movq 0x1c0(%rax), %rcx
movsd 0x190(%rcx), %xmm0
movsd %xmm0, 0x198(%rax)
movsd 0x170(%rax), %xmm0
subsd 0x138(%rax), %xmm0
movsd %xmm0, 0x148(%rax)
movsd 0x178(%rax), %xmm0
subsd 0x140(%rax), %xmm0
movsd %xmm0, 0x150(%rax)
movsd 0x190(%rax), %xmm0
subsd 0x1a0(%rax), %xmm0
movsd %xmm0, 0x158(%rax)
movsd 0x198(%rax), %xmm0
subsd 0x1a8(%rax), %xmm0
movsd %xmm0, 0x160(%rax)
movsd 0x150(%rax), %xmm0
movsd 0x148(%rax), %xmm1
callq 0x3070
movq -0x10(%rbp), %rax
movsd %xmm0, 0x130(%rax)
movsd 0x148(%rax), %xmm0
callq 0x4450
movq -0x10(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd 0x150(%rax), %xmm0
callq 0x4450
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x3190
movq -0x10(%rbp), %rax
movsd %xmm0, 0x188(%rax)
movsd 0x158(%rax), %xmm0
movsd 0x148(%rax), %xmm2
movsd 0x160(%rax), %xmm1
mulsd 0x150(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd 0x188(%rax), %xmm0
movsd %xmm0, 0x180(%rax)
movsd 0x188(%rax), %xmm1
movsd 0xf8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x17658
movq -0x10(%rbp), %rax
movsd 0x130(%rax), %xmm0
movsd 0x110(%rax), %xmm1
movq 0x1b0(%rax), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0xcca0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x118(%rax)
movb $0x1, 0x120(%rax)
jmp 0x1766e
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x118(%rax)
movb $0x0, 0x120(%rax)
movq -0x10(%rbp), %rax
movsd 0x168(%rax), %xmm0
movsd %xmm0, 0x128(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdx, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x218, %rdi            # imm = 0x218
leaq -0x10(%rbp), %rsi
callq 0x1bea0
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x208, %rsi            # imm = 0x208
callq 0x1bf10
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3040
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x17e50
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x1bf30
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x17e2c
movq -0x18(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movslq -0xc(%rbp), %rsi
callq 0x1bf50
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17de0
movq -0x18(%rbp), %rax
movsd 0xc1d0(%rip), %xmm0     # 0x24008
divsd 0x158(%rax), %xmm0
movsd %xmm0, 0x390(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::ResetAll()
void SimExec::ResetAll()
{
  deltaTime    = 0.0;
  done         = false;
  filename[0]  = '\0';
  maxMiss      = 0.0;
  medMiss      = 0.0;
  minMiss      = 0.0;
  miss         = 0.0;
  miss70       = 0.0;
  missX        = 0.0;
  missY        = 0.0;
  nextFrameTime = 0.0;
  outputTime   = 0.0;
  outputTimeStep = 0.0;
  pHit         = 0.0;
  pOutFile     = NULL;
  qtyFly       = 0;
  range        = 0.0;
  rDot         = 0.0;
  relPxf       = 0.0;
  relPyf       = 0.0;
  relVmag      = 0.0;
  relVxf       = 0.0;
  relVyf       = 0.0;
  simTime      = 0.0;
  stdMissX     = 0.0;
  stdMissY     = 0.0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x258(%rax)
movb $0x0, 0x260(%rax)
movb $0x0, 0x261(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x308(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x310(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x318(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x190(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1a8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1b0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1b8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x388(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x390(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x398(%rax)
movq $0x0, 0x210(%rax)
movl $0x0, 0x3a0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1c8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1d0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1d8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1e0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1e8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1f0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x1f8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x208(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x3b0(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x3b8(%rax)
popq %rbp
retq
// File: DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::Integrate()
void SimExec::Integrate()
{
  int idx;
  MdlBase *pMdl;
  

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x1bf30
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x17ff5
movq -0x20(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movslq -0xc(%rbp), %rsi
callq 0x1bf50
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x40(%rax)
je 0x17fe8
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x258, %rsi            # imm = 0x258
callq 0xda30
jmp 0x17fea
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17f8b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x428(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x1a158
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x1a156
movq -0x428(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x220(%rbp), %rdx
leaq -0x420(%rbp), %rcx
callq 0x1a390
movq -0x428(%rbp), %rdi
leaq -0x220(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq 0x1a4c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a0fe
jmp 0x1a158
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::CalcStdDev(std::vector<double, std::allocator<double>>)
double SimExec::CalcStdDev( vectorDbl dataVec )
{
  int    idx;
  double mean = 0.0;
  int    qtyElem = dataVec.size();
  double stdDev = 0.0;

  if ( qtyElem != 1 && qtyElem != 0 )
  {
    for ( idx = 0; idx < qtyElem; ++idx )
    {
      mean += dataVec[idx];
    }
    mean /= qtyElem;

    for ( idx = 0; idx < qtyElem; ++idx )
    {
      stdDev += SQ( dataVec[idx] - mean );
    }
    stdDev = sqrt( stdDev / (static_cast<double>(qtyElem) - 1.0) );
  }
  return( stdDev );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x10e90
movl %eax, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
cmpl $0x1, -0x24(%rbp)
je 0x1a266
cmpl $0x0, -0x24(%rbp)
je 0x1a266
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1a1f0
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xe910
movsd (%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a1c2
cvtsi2sdl -0x24(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1a242
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xe910
movsd (%rax), %xmm0
subsd -0x20(%rbp), %xmm0
callq 0x4450
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a20a
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
movsd 0x9db4(%rip), %xmm2     # 0x24008
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x3190
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1a2da
movq -0x18(%rbp), %rdi
leaq 0x9d77(%rip), %rsi      # 0x24028
leaq 0xaaf8(%rip), %rdx      # 0x24db0
movb $0x0, %al
callq 0x3330
movq -0x18(%rbp), %rdi
leaq 0x9d5e(%rip), %rsi      # 0x24028
leaq 0xaa2b(%rip), %rdx      # 0x24cfc
movb $0x0, %al
callq 0x3330
jmp 0x1a314
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movsd 0x208(%rax), %xmm0
leaq 0x9d61(%rip), %rsi      # 0x24052
movb $0x1, %al
callq 0x3330
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x3ac(%rax), %edx
leaq 0xaaab(%rip), %rsi      # 0x24db8
movb $0x0, %al
callq 0x3330
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x1bf30
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a374
movq -0x28(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movslq -0x1c(%rbp), %rsi
callq 0x1bf50
movq (%rax), %rdi
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %esi
callq *0x30(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a31b
movq -0x18(%rbp), %rdi
leaq 0xae86(%rip), %rsi      # 0x25205
movb $0x0, %al
callq 0x3330
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x1a3df
movq -0x18(%rbp), %rdi
leaq 0xae41(%rip), %rsi      # 0x25206
callq 0x31f0
movq -0x20(%rbp), %rdi
leaq 0xae31(%rip), %rsi      # 0x25206
callq 0x31f0
jmp 0x1a4ae
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3d, %ecx
movb %al, -0x31(%rbp)
je 0x1a40b
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1a414
jmp 0x1a43c
movq -0x30(%rbp), %rax
movb (%rax), %dl
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1a3ee
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x1a459
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x1a4ac
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1a4a0
movq -0x30(%rbp), %rax
movb (%rax), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1a46c
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1a4ae
movq $0x0, -0x30(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::read_file(char*)
void SimExec::read_file( char *filename )
{
  FILE *fp;
  char name[512];
  char val[512];
  char line[512];
  int  num_syms = 0;


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

    while (!feof(fp)) 
    {

      fgets(line, 512, fp);

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

        parse_symbols(name, val);

        num_syms++;
      }
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x630, %rsp            # imm = 0x630
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x630(%rbp)
movl $0x0, -0x624(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9de2(%rip), %rsi      # 0x25005
callq 0x32b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1b2de
jmp 0x1b238
movq -0x18(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1b252
jmp 0x1b2d3
leaq -0x620(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x200, %esi            # imm = 0x200
callq 0x3380
movsbl -0x620(%rbp), %eax
cmpl $0x23, %eax
je 0x1b2ce
movsbl -0x620(%rbp), %edi
callq 0x3060
cmpl $0x0, %eax
jne 0x1b2ce
movq -0x630(%rbp), %rdi
leaq -0x620(%rbp), %rsi
leaq -0x220(%rbp), %rdx
leaq -0x420(%rbp), %rcx
callq 0x1a390
movq -0x630(%rbp), %rdi
leaq -0x220(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq 0x1a4c0
movl -0x624(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x624(%rbp)
jmp 0x1b238
movq -0x18(%rbp), %rdi
callq 0x3220
jmp 0x1b2f0
movq -0x10(%rbp), %rsi
leaq 0x9ad4(%rip), %rdi      # 0x24dbd
movb $0x0, %al
callq 0x3050
addq $0x630, %rsp            # imm = 0x630
popq %rbp
retq
nopl (%rax)
// File: DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::boolean_string(int)
const char* SimExec::boolean_string(int val)
{
  const char *TRUE_STR = "true";
  const char *FALSE_STR = "false";

  if (val)
    return TRUE_STR;
  else
    return FALSE_STR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x9acb(%rip), %rax      # 0x24ddd
movq %rax, -0x20(%rbp)
leaq 0x9ac5(%rip), %rax      # 0x24de2
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1b331
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b339
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: DavidLBruce[P]sim3dof/build/../src/SimExec.cpp
// Function: SimExec::get_boolean(char*)
int SimExec::get_boolean(char *str)
{
  if ( (strcmp(str, "0\n") == 0) ||
    (strcmp(str, "0") == 0) ||
    (strcmp(str, "false\n") == 0) ||
    (strcmp(str, "false") == 0) )
    return 0;

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

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

  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xa99c(%rip), %rsi      # 0x26537
callq 0x3320
cmpl $0x0, %eax
je 0x1bbe4
movq -0x18(%rbp), %rdi
leaq 0x875b(%rip), %rsi      # 0x2430b
callq 0x3320
cmpl $0x0, %eax
je 0x1bbe4
movq -0x18(%rbp), %rdi
leaq 0xa975(%rip), %rsi      # 0x2653a
callq 0x3320
cmpl $0x0, %eax
je 0x1bbe4
movq -0x18(%rbp), %rdi
leaq 0x9208(%rip), %rsi      # 0x24de2
callq 0x3320
cmpl $0x0, %eax
jne 0x1bbed
movl $0x0, -0x4(%rbp)
jmp 0x1bc63
movq -0x18(%rbp), %rdi
leaq 0xa949(%rip), %rsi      # 0x26541
callq 0x3320
cmpl $0x0, %eax
je 0x1bc41
movq -0x18(%rbp), %rdi
leaq 0x8709(%rip), %rsi      # 0x24316
callq 0x3320
cmpl $0x0, %eax
je 0x1bc41
movq -0x18(%rbp), %rdi
leaq 0xa922(%rip), %rsi      # 0x26544
callq 0x3320
cmpl $0x0, %eax
je 0x1bc41
movq -0x18(%rbp), %rdi
leaq 0x91a6(%rip), %rsi      # 0x24ddd
callq 0x3320
cmpl $0x0, %eax
jne 0x1bc4a
movl $0x1, -0x4(%rbp)
jmp 0x1bc63
movq -0x18(%rbp), %rsi
leaq 0xa8f5(%rip), %rdi      # 0x2654a
movb $0x0, %al
callq 0x3050
xorl %edi, %edi
callq 0x32c0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)