#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int countparval(char *);
double fabs(float);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ getparfloat(char *, float *);
int /*<<< orphan*/ getparint(char *, int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
void getreccfp(int *xi, int *zi, int *nrec, int nx, float dx, float dz,
               float ox, float oz, int verbose) {
  int nrx, i, j, ndeltx, np, lint;
  float xprev, deltx;
  float *xrcv, zrcv, dxrcv;
  if (!getparint("lint", &lint))
    lint = 1;
  if (!getparfloat("zrcv", &zrcv))
    zrcv = 0.0;
  if (!getparfloat("dxrcv", &dxrcv))
    dxrcv = dx;
  if (fabs(dxrcv / dx - ((int)((dxrcv / dx) > 0.0 ? (dxrcv / dx) + 0.5
                                                  : (dxrcv / dx) - 0.5))) >
      0.001)
    fprintf(stderr, "    getreccfp: dxrcv does not fit on grid; rounded to "
                    "nearest position\n");
  zrcv -= oz;
  *zi = ((int)((zrcv / dz) > 0.0 ? (zrcv / dz) + 0.5 : (zrcv / dz) - 0.5));
  nrx = countparval("xrcv");
  if (nrx == 0) {
    if (verbose)
      fprintf(stderr,
              "    getreccfp: no xrcv specified: receivers over full model "
              "with dx=%.1f\n",
              dxrcv);
    *nrec =
        ((int)(((nx - 1) * dx / dxrcv) > 0.0 ? ((nx - 1) * dx / dxrcv) + 0.5
                                             : ((nx - 1) * dx / dxrcv) - 0.5)) +
        1;
    for (i = 0; i < *nrec; i++)
      xi[i] = ((int)((i * dxrcv / dx) > 0.0 ? (i * dxrcv / dx) + 0.5
                                            : (i * dxrcv / dx) - 0.5));
    if (xi[*nrec - 1] >= nx)
      *nrec -= 1;
    return;
  }
  xrcv = (float *)malloc(nrx * sizeof(float));
  getparfloat("xrcv", xrcv);
  for (i = 0; i < nrx; i++)
    xrcv[i] -= ox;
  if (lint == 1) {
    if (verbose)
      fprintf(stderr,
              "    getreccfp: interpolating receivers with interval %f between "
              "positions defined by xrcv\n",
              dxrcv);
    xprev = xrcv[0];
    np = 0;
    for (i = 1; i < nrx; i++) {
      deltx = xrcv[i] - xprev;
      ndeltx =
          ((int)((fabs(deltx / dxrcv)) > 0.0 ? (fabs(deltx / dxrcv)) + 0.5
                                             : (fabs(deltx / dxrcv)) - 0.5));
      for (j = 0; j <= ndeltx; j++) {
        xi[np++] =
            ((int)(((xprev + (j * dxrcv * deltx) / deltx) / dx) > 0.0
                       ? ((xprev + (j * dxrcv * deltx) / deltx) / dx) + 0.5
                       : ((xprev + (j * dxrcv * deltx) / deltx) / dx) - 0.5));
      }
      xprev = xrcv[i];
      np--;
    }
    xi[np] = ((int)((xrcv[nrx - 1] / dx) > 0.0 ? (xrcv[nrx - 1] / dx) + 0.5
                                               : (xrcv[nrx - 1] / dx) - 0.5));
    *nrec = np + 1;
  } else {
    if (verbose)
      fprintf(stderr,
              "    getreccfp: receivers at positions defined by xrcv\n");
    for (i = 0; i < nrx; i++)
      xi[i] = ((int)((xrcv[i] / dx) > 0.0 ? (xrcv[i] / dx) + 0.5
                                          : (xrcv[i] / dx) - 0.5));
    *nrec = nrx;
  }
  free(xrcv);
  return;
}


x86 assembly (clang, -O0):
<getreccfp>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movss  %xmm0,-0x20(%rbp)
movss  %xmm1,-0x24(%rbp)
movss  %xmm2,-0x28(%rbp)
movss  %xmm3,-0x2c(%rbp)
mov    %r8d,-0x30(%rbp)
lea    0xe67(%rip),%rdi
lea    -0x48(%rbp),%rsi
call   1090 <getparint@plt>
cmp    $0x0,%eax
jne    11c2 <getreccfp+0x52>
movl   $0x1,-0x48(%rbp)
lea    0xe4c(%rip),%rdi
lea    -0x5c(%rbp),%rsi
call   1070 <getparfloat@plt>
cmp    $0x0,%eax
jne    11e3 <getreccfp+0x73>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
lea    0xe30(%rip),%rdi
lea    -0x60(%rbp),%rsi
call   1070 <getparfloat@plt>
cmp    $0x0,%eax
jne    1206 <getreccfp+0x96>
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x60(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1254 <getreccfp+0xe4>
movss  -0x60(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdba(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1273 <getreccfp+0x103>
movss  -0x60(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd96(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  -0x64(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
cvttsd2si %xmm1,%eax
cvtsi2ss %eax,%xmm1
subss  %xmm1,%xmm0
call   1050 <fabs@plt>
movsd  0xd72(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12b7 <getreccfp+0x147>
mov    0x2d39(%rip),%rax
mov    (%rax),%edi
lea    0xd70(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movss  -0x2c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
divss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1309 <getreccfp+0x199>
movss  -0x5c(%rbp),%xmm0
divss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd05(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1328 <getreccfp+0x1b8>
movss  -0x5c(%rbp),%xmm0
divss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce1(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
lea    0xcdd(%rip),%rdi
call   1040 <countparval@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    14e2 <getreccfp+0x372>
cmpl   $0x0,-0x30(%rbp)
je     137a <getreccfp+0x20a>
mov    0x2c7f(%rip),%rax
mov    (%rax),%edi
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcf5(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
mulss  -0x20(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13cd <getreccfp+0x25d>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
mulss  -0x20(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc41(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    13f6 <getreccfp+0x286>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
mulss  -0x20(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc13(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
cvttsd2si %xmm0,%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    14b6 <getreccfp+0x346>
cvtsi2ssl -0x38(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    146a <getreccfp+0x2fa>
cvtsi2ssl -0x38(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xba7(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1491 <getreccfp+0x321>
cvtsi2ssl -0x38(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb7b(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
cvttsd2si %xmm0,%edx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    140f <getreccfp+0x29f>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jl     14dd <getreccfp+0x36d>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    %ecx,(%rax)
jmp    18da <getreccfp+0x76a>
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rsi
lea    0xb1b(%rip),%rdi
call   1070 <getparfloat@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1541 <getreccfp+0x3d1>
movss  -0x28(%rbp),%xmm1
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    150c <getreccfp+0x39c>
cmpl   $0x1,-0x48(%rbp)
jne    17f3 <getreccfp+0x683>
cmpl   $0x0,-0x30(%rbp)
je     1575 <getreccfp+0x405>
mov    0x2a84(%rip),%rax
mov    (%rax),%edi
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb44(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1740 <getreccfp+0x5d0>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
call   1050 <fabs@plt>
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15f7 <getreccfp+0x487>
movss  -0x50(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
call   1050 <fabs@plt>
movsd  0xa1a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    161a <getreccfp+0x4aa>
movss  -0x50(%rbp),%xmm0
divss  -0x60(%rbp),%xmm0
call   1050 <fabs@plt>
movsd  0x9f2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1717 <getreccfp+0x5a7>
movss  -0x4c(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
divss  -0x50(%rbp),%xmm1
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16ae <getreccfp+0x53e>
movss  -0x4c(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
divss  -0x50(%rbp),%xmm1
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x963(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    16e8 <getreccfp+0x578>
movss  -0x4c(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
divss  -0x50(%rbp),%xmm1
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x924(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
cvttsd2si %xmm0,%edx
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x44(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1630 <getreccfp+0x4c0>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1590 <getreccfp+0x420>
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    179c <getreccfp+0x62c>
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x875(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    17cb <getreccfp+0x65b>
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x841(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%edx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    18d1 <getreccfp+0x761>
cmpl   $0x0,-0x30(%rbp)
je     1814 <getreccfp+0x6a4>
mov    0x27dc(%rip),%rax
mov    (%rax),%edi
lea    0x900(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    18c8 <getreccfp+0x758>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1879 <getreccfp+0x709>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x798(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    18a3 <getreccfp+0x733>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x769(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%edx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    181b <getreccfp+0x6ab>
mov    -0x34(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getreccfp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r8d,%r12d
movss  %xmm3,0x40(%rsp)
movaps %xmm2,0x50(%rsp)
movss  %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
mov    %ecx,%r15d
mov    %rdx,%rbp
mov    %rsi,%r14
mov    %rdi,%rbx
lea    0xeb7(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1090 <getparint@plt>
test   %eax,%eax
jne    11c3 <getreccfp+0x53>
movl   $0x1,0xc(%rsp)
lea    0xe9f(%rip),%rdi
lea    0x8(%rsp),%rsi
call   1070 <getparfloat@plt>
test   %eax,%eax
jne    11e0 <getreccfp+0x70>
movl   $0x0,0x8(%rsp)
lea    0xe87(%rip),%rdi
lea    0x4(%rsp),%rsi
call   1070 <getparfloat@plt>
test   %eax,%eax
je     1202 <getreccfp+0x92>
movss  0x4(%rsp),%xmm0
movaps 0x10(%rsp),%xmm1
jmp    1210 <getreccfp+0xa0>
movaps 0x10(%rsp),%xmm1
movss  %xmm1,0x4(%rsp)
movaps %xmm1,%xmm0
divss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %al
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
lea    0xdd3(%rip),%r13
addsd  0x0(%r13,%rax,8),%xmm1
cvttpd2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm1
subss  %xmm1,%xmm0
call   1050 <fabs@plt>
ucomisd 0xe04(%rip),%xmm0
jbe    1265 <getreccfp+0xf5>
mov    0x2d8b(%rip),%rax
mov    (%rax),%edi
lea    0xe16(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
movss  0x8(%rsp),%xmm0
subss  0x40(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
divss  0x20(%rsp),%xmm0
xor    %eax,%eax
ucomiss 0xdda(%rip),%xmm0
seta   %al
cvtss2sd %xmm0,%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,(%r14)
lea    0xdcd(%rip),%rdi
call   1040 <countparval@plt>
test   %eax,%eax
je     12ef <getreccfp+0x17f>
mov    %eax,%r14d
lea    0x0(,%r14,4),%edi
call   1080 <malloc@plt>
mov    %rax,%r15
lea    0xdaa(%rip),%rdi
mov    %rax,%rsi
call   1070 <getparfloat@plt>
test   %r14d,%r14d
movaps 0x50(%rsp),%xmm5
jle    1469 <getreccfp+0x2f9>
mov    %r14d,%eax
cmp    $0x8,%r14d
jae    13af <getreccfp+0x23f>
xor    %ecx,%ecx
jmp    1450 <getreccfp+0x2e0>
test   %r12d,%r12d
je     1315 <getreccfp+0x1a5>
mov    0x2ce5(%rip),%rax
mov    (%rax),%edi
movss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdae(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
lea    -0x1(%r15),%eax
cvtsi2ss %eax,%xmm2
movaps 0x10(%rsp),%xmm3
mulss  %xmm3,%xmm2
movss  0x4(%rsp),%xmm0
divss  %xmm0,%xmm2
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm2
seta   %al
cvtss2sd %xmm2,%xmm2
addsd  0x0(%r13,%rax,8),%xmm2
cvttsd2si %xmm2,%eax
lea    0x1(%rax),%ecx
mov    %ecx,0x0(%rbp)
test   %eax,%eax
js     1396 <getreccfp+0x226>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  %xmm0,%xmm2
divss  %xmm3,%xmm2
xor    %ecx,%ecx
ucomiss %xmm1,%xmm2
seta   %cl
cvtss2sd %xmm2,%xmm2
addsd  0x0(%r13,%rcx,8),%xmm2
cvttsd2si %xmm2,%ecx
mov    %ecx,(%rbx,%rax,4)
add    $0x1,%rax
movslq 0x0(%rbp),%rcx
cmp    %rcx,%rax
jl     1360 <getreccfp+0x1f0>
movslq %ecx,%rax
cmp    %r15d,-0x4(%rbx,%rax,4)
jl     197a <getreccfp+0x80a>
add    $0xffffffff,%ecx
mov    %ecx,0x0(%rbp)
jmp    197a <getreccfp+0x80a>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movaps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm0
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     198c <getreccfp+0x81c>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movups (%r15,%rdx,4),%xmm1
movups 0x10(%r15,%rdx,4),%xmm2
movups 0x20(%r15,%rdx,4),%xmm3
movups 0x30(%r15,%rdx,4),%xmm4
subps  %xmm0,%xmm1
subps  %xmm0,%xmm2
movups %xmm1,(%r15,%rdx,4)
movups %xmm2,0x10(%r15,%rdx,4)
subps  %xmm0,%xmm3
subps  %xmm0,%xmm4
movups %xmm3,0x20(%r15,%rdx,4)
movups %xmm4,0x30(%r15,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    13e0 <getreccfp+0x270>
test   $0x1,%sil
je     1446 <getreccfp+0x2d6>
movups (%r15,%rdx,4),%xmm1
movups 0x10(%r15,%rdx,4),%xmm2
subps  %xmm0,%xmm1
subps  %xmm0,%xmm2
movups %xmm1,(%r15,%rdx,4)
movups %xmm2,0x10(%r15,%rdx,4)
cmp    %rax,%rcx
je     1469 <getreccfp+0x2f9>
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rcx,4),%xmm0
subss  %xmm5,%xmm0
movss  %xmm0,(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1450 <getreccfp+0x2e0>
cmpl   $0x1,0xc(%rsp)
jne    16f9 <getreccfp+0x589>
mov    %rbp,0x68(%rsp)
test   %r12d,%r12d
je     149f <getreccfp+0x32f>
mov    0x2b5b(%rip),%rax
mov    (%rax),%edi
movss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc6e(%rip),%rsi
mov    $0x1,%al
call   1060 <fprintf@plt>
xor    %ebp,%ebp
mov    %r14,0x38(%rsp)
cmp    $0x2,%r14d
movaps 0x10(%rsp),%xmm1
jl     1734 <getreccfp+0x5c4>
mov    0x38(%rsp),%eax
mov    %rax,0x50(%rsp)
movaps %xmm1,%xmm10
shufps $0x0,%xmm1,%xmm10
xor    %ebp,%ebp
mov    $0x1,%r12d
mov    %r15,%rax
movaps %xmm10,0x70(%rsp)
jmp    14fb <getreccfp+0x38b>
nopw   0x0(%rax,%rax,1)
movaps 0x10(%rsp),%xmm1
lea    (%r15,%r12,4),%rax
add    $0xffffffff,%ebp
add    $0x1,%r12
cmp    0x50(%rsp),%r12
je     1734 <getreccfp+0x5c4>
movsd  (%rax),%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps %xmm0,0x40(%rsp)
subps  %xmm0,%xmm1
movaps %xmm1,0x20(%rsp)
movaps %xmm1,%xmm0
divss  0x4(%rsp),%xmm0
call   1050 <fabs@plt>
xor    %r14d,%r14d
ucomisd 0xb2c(%rip),%xmm0
seta   %r14b
movaps 0x20(%rsp),%xmm0
divss  0x4(%rsp),%xmm0
call   1050 <fabs@plt>
addsd  0x0(%r13,%r14,8),%xmm0
cvttsd2si %xmm0,%eax
test   %eax,%eax
js     14e0 <getreccfp+0x370>
movss  0x4(%rsp),%xmm8
movslq %ebp,%rdx
xor    %ecx,%ecx
cmp    $0x3,%eax
jae    1580 <getreccfp+0x410>
mov    %rdx,%rbp
movaps 0x10(%rsp),%xmm1
xorps  %xmm2,%xmm2
movaps 0x40(%rsp),%xmm14
movaps 0x20(%rsp),%xmm15
jmp    16a2 <getreccfp+0x532>
nopl   0x0(%rax)
mov    %eax,%r8d
add    $0x1,%r8
mov    %r8,%rcx
and    $0xfffffffffffffffc,%rcx
lea    (%rcx,%rdx,1),%rbp
movaps %xmm8,%xmm9
shufps $0x0,%xmm8,%xmm9
movaps 0x20(%rsp),%xmm15
movaps %xmm15,%xmm2
shufps $0x0,%xmm15,%xmm2
movaps 0x40(%rsp),%xmm14
movaps %xmm14,%xmm11
shufps $0x0,%xmm14,%xmm11
lea    0x0(,%r8,4),%rsi
and    $0xfffffffffffffff0,%rsi
lea    (%rbx,%rdx,4),%rdi
xor    %edx,%edx
movaps 0xa5e(%rip),%xmm4
movaps 0x70(%rsp),%xmm10
movdqa 0xa30(%rip),%xmm3
movdqa 0xa37(%rip),%xmm12
movdqa 0xa4e(%rip),%xmm13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cvtdq2ps %xmm4,%xmm5
mulps  %xmm9,%xmm5
mulps  %xmm2,%xmm5
divps  %xmm2,%xmm5
addps  %xmm11,%xmm5
divps  %xmm10,%xmm5
xorpd  %xmm0,%xmm0
cvtps2pd %xmm5,%xmm7
cmpltps %xmm5,%xmm0
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
movaps %xmm0,%xmm6
unpckhpd %xmm0,%xmm6
xorps  %xmm1,%xmm1
pcmpgtd %xmm6,%xmm1
punpckldq %xmm1,%xmm6
pxor   %xmm1,%xmm1
pcmpgtd %xmm0,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm12,%xmm1
pand   %xmm0,%xmm1
pandn  %xmm3,%xmm0
por    %xmm1,%xmm0
movdqa %xmm12,%xmm1
pand   %xmm6,%xmm1
addpd  %xmm7,%xmm0
pandn  %xmm3,%xmm6
por    %xmm1,%xmm6
cvttpd2dq %xmm0,%xmm0
addpd  %xmm5,%xmm6
cvttpd2dq %xmm6,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rdi,%rdx,1)
paddd  %xmm13,%xmm4
add    $0x10,%rdx
cmp    %rdx,%rsi
jne    1600 <getreccfp+0x490>
cmp    %rcx,%r8
movaps 0x10(%rsp),%xmm1
xorps  %xmm2,%xmm2
je     14e5 <getreccfp+0x375>
add    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mulss  %xmm8,%xmm0
mulss  %xmm15,%xmm0
divss  %xmm15,%xmm0
addss  %xmm14,%xmm0
divss  %xmm1,%xmm0
xor    %edx,%edx
ucomiss %xmm2,%xmm0
seta   %dl
cvtss2sd %xmm0,%xmm0
addsd  0x0(%r13,%rdx,8),%xmm0
cvttsd2si %xmm0,%edx
mov    %edx,(%rbx,%rbp,4)
add    $0x1,%rbp
add    $0x1,%ecx
cmp    %ecx,%eax
jne    16b0 <getreccfp+0x540>
jmp    14e5 <getreccfp+0x375>
test   %r12d,%r12d
je     1715 <getreccfp+0x5a5>
mov    0x28db(%rip),%rax
mov    (%rax),%edi
lea    0xa53(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
test   %r14d,%r14d
jle    196e <getreccfp+0x7fe>
mov    %r14d,%eax
cmp    $0x4,%r14d
jae    1773 <getreccfp+0x603>
xor    %ecx,%ecx
movaps 0x10(%rsp),%xmm8
jmp    193a <getreccfp+0x7ca>
movslq 0x38(%rsp),%rax
movss  -0x4(%r15,%rax,4),%xmm0
divss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %al
cvtss2sd %xmm0,%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
movslq %ebp,%r14
mov    %eax,(%rbx,%r14,4)
add    $0x1,%r14d
mov    0x68(%rsp),%rbp
jmp    196e <getreccfp+0x7fe>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movaps 0x10(%rsp),%xmm8
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     199d <getreccfp+0x82d>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0x860(%rip),%xmm1
movdqa 0x868(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movups (%r15,%rdx,4),%xmm3
divps  %xmm0,%xmm3
cvtps2pd %xmm3,%xmm4
xorps  %xmm5,%xmm5
cmpltps %xmm3,%xmm5
movhlps %xmm3,%xmm3
cvtps2pd %xmm3,%xmm3
movaps %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm6,%xmm7
punpckldq %xmm7,%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm5,%xmm7
punpckldq %xmm7,%xmm5
movdqa %xmm2,%xmm7
pand   %xmm5,%xmm7
pandn  %xmm1,%xmm5
por    %xmm7,%xmm5
addpd  %xmm4,%xmm5
movdqa %xmm2,%xmm4
pand   %xmm6,%xmm4
pandn  %xmm1,%xmm6
por    %xmm4,%xmm6
addpd  %xmm3,%xmm6
cvttpd2dq %xmm5,%xmm3
cvttpd2dq %xmm6,%xmm4
unpcklpd %xmm4,%xmm3
movupd %xmm3,(%rbx,%rdx,4)
movups 0x10(%r15,%rdx,4),%xmm3
divps  %xmm0,%xmm3
cvtps2pd %xmm3,%xmm4
xorpd  %xmm5,%xmm5
cmpltps %xmm3,%xmm5
movhlps %xmm3,%xmm3
cvtps2pd %xmm3,%xmm3
movaps %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm6,%xmm7
punpckldq %xmm7,%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm5,%xmm7
punpckldq %xmm7,%xmm5
movdqa %xmm2,%xmm7
pand   %xmm5,%xmm7
pandn  %xmm1,%xmm5
por    %xmm7,%xmm5
addpd  %xmm4,%xmm5
movdqa %xmm2,%xmm4
pand   %xmm6,%xmm4
pandn  %xmm1,%xmm6
por    %xmm4,%xmm6
addpd  %xmm3,%xmm6
cvttpd2dq %xmm5,%xmm3
cvttpd2dq %xmm6,%xmm4
unpcklpd %xmm4,%xmm3
movupd %xmm3,0x10(%rbx,%rdx,4)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    17c0 <getreccfp+0x650>
test   $0x1,%sil
je     1935 <getreccfp+0x7c5>
movups (%r15,%rdx,4),%xmm1
divps  %xmm0,%xmm1
cvtps2pd %xmm1,%xmm0
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
cvtps2pd %xmm2,%xmm2
xorps  %xmm3,%xmm3
cmpltps %xmm1,%xmm3
xorps  %xmm1,%xmm1
movaps %xmm3,%xmm4
unpckhpd %xmm3,%xmm4
xorps  %xmm5,%xmm5
pcmpgtd %xmm4,%xmm5
punpckldq %xmm5,%xmm4
pcmpgtd %xmm3,%xmm1
punpckldq %xmm1,%xmm3
movdqa 0x718(%rip),%xmm1
movdqa 0x720(%rip),%xmm5
movdqa %xmm5,%xmm6
pand   %xmm3,%xmm6
pandn  %xmm1,%xmm3
por    %xmm6,%xmm3
addpd  %xmm0,%xmm3
pand   %xmm4,%xmm5
pandn  %xmm1,%xmm4
por    %xmm5,%xmm4
addpd  %xmm2,%xmm4
cvttpd2dq %xmm3,%xmm0
cvttpd2dq %xmm4,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rbx,%rdx,4)
cmp    %rax,%rcx
je     196e <getreccfp+0x7fe>
xorps  %xmm0,%xmm0
nopl   (%rax)
movss  (%r15,%rcx,4),%xmm1
divss  %xmm8,%xmm1
xor    %edx,%edx
ucomiss %xmm0,%xmm1
seta   %dl
cvtss2sd %xmm1,%xmm1
addsd  0x0(%r13,%rdx,8),%xmm1
cvttsd2si %xmm1,%edx
mov    %edx,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1940 <getreccfp+0x7d0>
mov    %r14d,0x0(%rbp)
mov    %r15,%rdi
call   1030 <free@plt>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    142a <getreccfp+0x2ba>
jmp    1446 <getreccfp+0x2d6>
xor    %edx,%edx
test   $0x1,%sil
jne    18b7 <getreccfp+0x747>
jmp    1935 <getreccfp+0x7c5>

LLVM IR (-O0):
@.str = [5 x i8] c"lint\00"
@.str.1 = [5 x i8] c"zrcv\00"
@.str.2 = [6 x i8] c"dxrcv\00"
@stderr = global i32 0
@.str.3 = [72 x i8] c" getreccfp: dxrcv does not fit on grid; rounded to nearest position\0A\00"
@.str.4 = [5 x i8] c"xrcv\00"
@.str.5 = [74 x i8] c" getreccfp: no xrcv specified: receivers over full model with dx=%.1f\0A\00"
@.str.6 = [91 x i8] c" getreccfp: interpolating receivers with interval %f between positions defined by xrcv\0A\00"
@.str.7 = [55 x i8] c" getreccfp: receivers at positions defined by xrcv\0A\00"
define void @getreccfp(i32* %0, i32* %1, i32* %2, i32 %3, float %4, float %5, float %6, float %7, i32 %8) {
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca float
%26 = alloca float
%27 = alloca float*
%28 = alloca float
%29 = alloca float
store i32* %0, i32** %10
store i32* %1, i32** %11
store i32* %2, i32** %12
store i32 %3, i32* %13
store float %4, float* %14
store float %5, float* %15
store float %6, float* %16
store float %7, float* %17
store i32 %8, i32* %18
%30 = call i32 @getparint(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32* %24)
%31 = icmp ne i32 %30, 0
br i1 %31, label %33, label %32
32: ; preds = %9
store i32 1, i32* %24
br label %33
33: ; preds = %32, %9
%34 = call i32 @getparfloat(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), float* %28)
%35 = icmp ne i32 %34, 0
br i1 %35, label %37, label %36
36: ; preds = %33
store float 0.000000e+00, float* %28
br label %37
37: ; preds = %36, %33
%38 = call i32 @getparfloat(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), float* %29)
%39 = icmp ne i32 %38, 0
br i1 %39, label %42, label %40
40: ; preds = %37
%41 = load float, float* %14
store float %41, float* %29
br label %42
42: ; preds = %40, %37
%43 = load float, float* %29
%44 = load float, float* %14
%45 = fdiv float %43, %44
%46 = load float, float* %29
%47 = load float, float* %14
%48 = fdiv float %46, %47
%49 = fpext float %48 to double
%50 = fcmp ogt double %49, 0.000000e+00
br i1 %50, label %51, label %57
51: ; preds = %42
%52 = load float, float* %29
%53 = load float, float* %14
%54 = fdiv float %52, %53
%55 = fpext float %54 to double
%56 = fadd double %55, 5.000000e-01
br label %63
57: ; preds = %42
%58 = load float, float* %29
%59 = load float, float* %14
%60 = fdiv float %58, %59
%61 = fpext float %60 to double
%62 = fsub double %61, 5.000000e-01
br label %63
63: ; preds = %57, %51
%64 = phi double [ %56, %51 ], [ %62, %57 ]
%65 = fptosi double %64 to i32
%66 = sitofp i32 %65 to float
%67 = fsub float %45, %66
%68 = call double @fabs(float %67)
%69 = fcmp ogt double %68, 1.000000e-03
br i1 %69, label %70, label %73
70: ; preds = %63
%71 = load i32, i32* @stderr
%72 = call i32 (i32, i8*, ...) @fprintf(i32 %71, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.3, i64 0, i64 0))
br label %73
73: ; preds = %70, %63
%74 = load float, float* %17
%75 = load float, float* %28
%76 = fsub float %75, %74
store float %76, float* %28
%77 = load float, float* %28
%78 = load float, float* %15
%79 = fdiv float %77, %78
%80 = fpext float %79 to double
%81 = fcmp ogt double %80, 0.000000e+00
br i1 %81, label %82, label %88
82: ; preds = %73
%83 = load float, float* %28
%84 = load float, float* %15
%85 = fdiv float %83, %84
%86 = fpext float %85 to double
%87 = fadd double %86, 5.000000e-01
br label %94
88: ; preds = %73
%89 = load float, float* %28
%90 = load float, float* %15
%91 = fdiv float %89, %90
%92 = fpext float %91 to double
%93 = fsub double %92, 5.000000e-01
br label %94
94: ; preds = %88, %82
%95 = phi double [ %87, %82 ], [ %93, %88 ]
%96 = fptosi double %95 to i32
%97 = load i32*, i32** %11
store i32 %96, i32* %97
%98 = call i32 @countparval(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
store i32 %98, i32* %19
%99 = load i32, i32* %19
%100 = icmp eq i32 %99, 0
br i1 %100, label %101, label %201
101: ; preds = %94
%102 = load i32, i32* %18
%103 = icmp ne i32 %102, 0
br i1 %103, label %104, label %109
104: ; preds = %101
%105 = load i32, i32* @stderr
%106 = load float, float* %29
%107 = fpext float %106 to double
%108 = call i32 (i32, i8*, ...) @fprintf(i32 %105, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.5, i64 0, i64 0), double %107)
br label %109
109: ; preds = %104, %101
%110 = load i32, i32* %13
%111 = sub nsw i32 %110, 1
%112 = sitofp i32 %111 to float
%113 = load float, float* %14
%114 = fmul float %112, %113
%115 = load float, float* %29
%116 = fdiv float %114, %115
%117 = fpext float %116 to double
%118 = fcmp ogt double %117, 0.000000e+00
br i1 %118, label %119, label %129
119: ; preds = %109
%120 = load i32, i32* %13
%121 = sub nsw i32 %120, 1
%122 = sitofp i32 %121 to float
%123 = load float, float* %14
%124 = fmul float %122, %123
%125 = load float, float* %29
%126 = fdiv float %124, %125
%127 = fpext float %126 to double
%128 = fadd double %127, 5.000000e-01
br label %139
129: ; preds = %109
%130 = load i32, i32* %13
%131 = sub nsw i32 %130, 1
%132 = sitofp i32 %131 to float
%133 = load float, float* %14
%134 = fmul float %132, %133
%135 = load float, float* %29
%136 = fdiv float %134, %135
%137 = fpext float %136 to double
%138 = fsub double %137, 5.000000e-01
br label %139
139: ; preds = %129, %119
%140 = phi double [ %128, %119 ], [ %138, %129 ]
%141 = fptosi double %140 to i32
%142 = add nsw i32 %141, 1
%143 = load i32*, i32** %12
store i32 %142, i32* %143
store i32 0, i32* %20
br label %144
144: ; preds = %183, %139
%145 = load i32, i32* %20
%146 = load i32*, i32** %12
%147 = load i32, i32* %146
%148 = icmp slt i32 %145, %147
br i1 %148, label %149, label %186
149: ; preds = %144
%150 = load i32, i32* %20
%151 = sitofp i32 %150 to float
%152 = load float, float* %29
%153 = fmul float %151, %152
%154 = load float, float* %14
%155 = fdiv float %153, %154
%156 = fpext float %155 to double
%157 = fcmp ogt double %156, 0.000000e+00
br i1 %157, label %158, label %167
158: ; preds = %149
%159 = load i32, i32* %20
%160 = sitofp i32 %159 to float
%161 = load float, float* %29
%162 = fmul float %160, %161
%163 = load float, float* %14
%164 = fdiv float %162, %163
%165 = fpext float %164 to double
%166 = fadd double %165, 5.000000e-01
br label %176
167: ; preds = %149
%168 = load i32, i32* %20
%169 = sitofp i32 %168 to float
%170 = load float, float* %29
%171 = fmul float %169, %170
%172 = load float, float* %14
%173 = fdiv float %171, %172
%174 = fpext float %173 to double
%175 = fsub double %174, 5.000000e-01
br label %176
176: ; preds = %167, %158
%177 = phi double [ %166, %158 ], [ %175, %167 ]
%178 = fptosi double %177 to i32
%179 = load i32*, i32** %10
%180 = load i32, i32* %20
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %179, i64 %181
store i32 %178, i32* %182
br label %183
183: ; preds = %176
%184 = load i32, i32* %20
%185 = add nsw i32 %184, 1
store i32 %185, i32* %20
br label %144
186: ; preds = %144
%187 = load i32*, i32** %10
%188 = load i32*, i32** %12
%189 = load i32, i32* %188
%190 = sub nsw i32 %189, 1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %187, i64 %191
%193 = load i32, i32* %192
%194 = load i32, i32* %13
%195 = icmp sge i32 %193, %194
br i1 %195, label %196, label %200
196: ; preds = %186
%197 = load i32*, i32** %12
%198 = load i32, i32* %197
%199 = sub nsw i32 %198, 1
store i32 %199, i32* %197
br label %200
200: ; preds = %196, %186
br label %443
201: ; preds = %94
%202 = load i32, i32* %19
%203 = sext i32 %202 to i64
%204 = mul i64 %203, 4
%205 = trunc i64 %204 to i32
%206 = call i64 @malloc(i32 %205)
%207 = inttoptr i64 %206 to float*
store float* %207, float** %27
%208 = load float*, float** %27
%209 = call i32 @getparfloat(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), float* %208)
store i32 0, i32* %20
br label %210
210: ; preds = %222, %201
%211 = load i32, i32* %20
%212 = load i32, i32* %19
%213 = icmp slt i32 %211, %212
br i1 %213, label %214, label %225
214: ; preds = %210
%215 = load float, float* %16
%216 = load float*, float** %27
%217 = load i32, i32* %20
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %216, i64 %218
%220 = load float, float* %219
%221 = fsub float %220, %215
store float %221, float* %219
br label %222
222: ; preds = %214
%223 = load i32, i32* %20
%224 = add nsw i32 %223, 1
store i32 %224, i32* %20
br label %210
225: ; preds = %210
%226 = load i32, i32* %24
%227 = icmp eq i32 %226, 1
br i1 %227, label %228, label %386
228: ; preds = %225
%229 = load i32, i32* %18
%230 = icmp ne i32 %229, 0
br i1 %230, label %231, label %236
231: ; preds = %228
%232 = load i32, i32* @stderr
%233 = load float, float* %29
%234 = fpext float %233 to double
%235 = call i32 (i32, i8*, ...) @fprintf(i32 %232, i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.6, i64 0, i64 0), double %234)
br label %236
236: ; preds = %231, %228
%237 = load float*, float** %27
%238 = getelementptr inbounds float, float* %237, i64 0
%239 = load float, float* %238
store float %239, float* %25
store i32 0, i32* %23
store i32 1, i32* %20
br label %240
240: ; preds = %340, %236
%241 = load i32, i32* %20
%242 = load i32, i32* %19
%243 = icmp slt i32 %241, %242
br i1 %243, label %244, label %343
244: ; preds = %240
%245 = load float*, float** %27
%246 = load i32, i32* %20
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %245, i64 %247
%249 = load float, float* %248
%250 = load float, float* %25
%251 = fsub float %249, %250
store float %251, float* %26
%252 = load float, float* %26
%253 = load float, float* %29
%254 = fdiv float %252, %253
%255 = call double @fabs(float %254)
%256 = fcmp ogt double %255, 0.000000e+00
br i1 %256, label %257, label %263
257: ; preds = %244
%258 = load float, float* %26
%259 = load float, float* %29
%260 = fdiv float %258, %259
%261 = call double @fabs(float %260)
%262 = fadd double %261, 5.000000e-01
br label %269
263: ; preds = %244
%264 = load float, float* %26
%265 = load float, float* %29
%266 = fdiv float %264, %265
%267 = call double @fabs(float %266)
%268 = fsub double %267, 5.000000e-01
br label %269
269: ; preds = %263, %257
%270 = phi double [ %262, %257 ], [ %268, %263 ]
%271 = fptosi double %270 to i32
store i32 %271, i32* %22
store i32 0, i32* %21
br label %272
272: ; preds = %329, %269
%273 = load i32, i32* %21
%274 = load i32, i32* %22
%275 = icmp sle i32 %273, %274
br i1 %275, label %276, label %332
276: ; preds = %272
%277 = load float, float* %25
%278 = load i32, i32* %21
%279 = sitofp i32 %278 to float
%280 = load float, float* %29
%281 = fmul float %279, %280
%282 = load float, float* %26
%283 = fmul float %281, %282
%284 = load float, float* %26
%285 = fdiv float %283, %284
%286 = fadd float %277, %285
%287 = load float, float* %14
%288 = fdiv float %286, %287
%289 = fpext float %288 to double
%290 = fcmp ogt double %289, 0.000000e+00
br i1 %290, label %291, label %306
291: ; preds = %276
%292 = load float, float* %25
%293 = load i32, i32* %21
%294 = sitofp i32 %293 to float
%295 = load float, float* %29
%296 = fmul float %294, %295
%297 = load float, float* %26
%298 = fmul float %296, %297
%299 = load float, float* %26
%300 = fdiv float %298, %299
%301 = fadd float %292, %300
%302 = load float, float* %14
%303 = fdiv float %301, %302
%304 = fpext float %303 to double
%305 = fadd double %304, 5.000000e-01
br label %321
306: ; preds = %276
%307 = load float, float* %25
%308 = load i32, i32* %21
%309 = sitofp i32 %308 to float
%310 = load float, float* %29
%311 = fmul float %309, %310
%312 = load float, float* %26
%313 = fmul float %311, %312
%314 = load float, float* %26
%315 = fdiv float %313, %314
%316 = fadd float %307, %315
%317 = load float, float* %14
%318 = fdiv float %316, %317
%319 = fpext float %318 to double
%320 = fsub double %319, 5.000000e-01
br label %321
321: ; preds = %306, %291
%322 = phi double [ %305, %291 ], [ %320, %306 ]
%323 = fptosi double %322 to i32
%324 = load i32*, i32** %10
%325 = load i32, i32* %23
%326 = add nsw i32 %325, 1
store i32 %326, i32* %23
%327 = sext i32 %325 to i64
%328 = getelementptr inbounds i32, i32* %324, i64 %327
store i32 %323, i32* %328
br label %329
329: ; preds = %321
%330 = load i32, i32* %21
%331 = add nsw i32 %330, 1
store i32 %331, i32* %21
br label %272
332: ; preds = %272
%333 = load float*, float** %27
%334 = load i32, i32* %20
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %333, i64 %335
%337 = load float, float* %336
store float %337, float* %25
%338 = load i32, i32* %23
%339 = add nsw i32 %338, -1
store i32 %339, i32* %23
br label %340
340: ; preds = %332
%341 = load i32, i32* %20
%342 = add nsw i32 %341, 1
store i32 %342, i32* %20
br label %240
343: ; preds = %240
%344 = load float*, float** %27
%345 = load i32, i32* %19
%346 = sub nsw i32 %345, 1
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds float, float* %344, i64 %347
%349 = load float, float* %348
%350 = load float, float* %14
%351 = fdiv float %349, %350
%352 = fpext float %351 to double
%353 = fcmp ogt double %352, 0.000000e+00
br i1 %353, label %354, label %365
354: ; preds = %343
%355 = load float*, float** %27
%356 = load i32, i32* %19
%357 = sub nsw i32 %356, 1
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds float, float* %355, i64 %358
%360 = load float, float* %359
%361 = load float, float* %14
%362 = fdiv float %360, %361
%363 = fpext float %362 to double
%364 = fadd double %363, 5.000000e-01
br label %376
365: ; preds = %343
%366 = load float*, float** %27
%367 = load i32, i32* %19
%368 = sub nsw i32 %367, 1
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds float, float* %366, i64 %369
%371 = load float, float* %370
%372 = load float, float* %14
%373 = fdiv float %371, %372
%374 = fpext float %373 to double
%375 = fsub double %374, 5.000000e-01
br label %376
376: ; preds = %365, %354
%377 = phi double [ %364, %354 ], [ %375, %365 ]
%378 = fptosi double %377 to i32
%379 = load i32*, i32** %10
%380 = load i32, i32* %23
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i32, i32* %379, i64 %381
store i32 %378, i32* %382
%383 = load i32, i32* %23
%384 = add nsw i32 %383, 1
%385 = load i32*, i32** %12
store i32 %384, i32* %385
br label %440
386: ; preds = %225
%387 = load i32, i32* %18
%388 = icmp ne i32 %387, 0
br i1 %388, label %389, label %392
389: ; preds = %386
%390 = load i32, i32* @stderr
%391 = call i32 (i32, i8*, ...) @fprintf(i32 %390, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.7, i64 0, i64 0))
br label %392
392: ; preds = %389, %386
store i32 0, i32* %20
br label %393
393: ; preds = %434, %392
%394 = load i32, i32* %20
%395 = load i32, i32* %19
%396 = icmp slt i32 %394, %395
br i1 %396, label %397, label %437
397: ; preds = %393
%398 = load float*, float** %27
%399 = load i32, i32* %20
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %398, i64 %400
%402 = load float, float* %401
%403 = load float, float* %14
%404 = fdiv float %402, %403
%405 = fpext float %404 to double
%406 = fcmp ogt double %405, 0.000000e+00
br i1 %406, label %407, label %417
407: ; preds = %397
%408 = load float*, float** %27
%409 = load i32, i32* %20
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %408, i64 %410
%412 = load float, float* %411
%413 = load float, float* %14
%414 = fdiv float %412, %413
%415 = fpext float %414 to double
%416 = fadd double %415, 5.000000e-01
br label %427
417: ; preds = %397
%418 = load float*, float** %27
%419 = load i32, i32* %20
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds float, float* %418, i64 %420
%422 = load float, float* %421
%423 = load float, float* %14
%424 = fdiv float %422, %423
%425 = fpext float %424 to double
%426 = fsub double %425, 5.000000e-01
br label %427
427: ; preds = %417, %407
%428 = phi double [ %416, %407 ], [ %426, %417 ]
%429 = fptosi double %428 to i32
%430 = load i32*, i32** %10
%431 = load i32, i32* %20
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i32, i32* %430, i64 %432
store i32 %429, i32* %433
br label %434
434: ; preds = %427
%435 = load i32, i32* %20
%436 = add nsw i32 %435, 1
store i32 %436, i32* %20
br label %393
437: ; preds = %393
%438 = load i32, i32* %19
%439 = load i32*, i32** %12
store i32 %438, i32* %439
br label %440
440: ; preds = %437, %376
%441 = load float*, float** %27
%442 = call i32 @free(float* %441)
br label %443
443: ; preds = %440, %200
ret void
}

LLVM IR (-O2):
@.str = [5 x i8] c"lint\00"
@.str.1 = [5 x i8] c"zrcv\00"
@.str.2 = [6 x i8] c"dxrcv\00"
@stderr = global i32 0
@.str.3 = [72 x i8] c" getreccfp: dxrcv does not fit on grid; rounded to nearest position\0A\00"
@.str.4 = [5 x i8] c"xrcv\00"
@.str.5 = [74 x i8] c" getreccfp: no xrcv specified: receivers over full model with dx=%.1f\0A\00"
@.str.6 = [91 x i8] c" getreccfp: interpolating receivers with interval %f between positions defined by xrcv\0A\00"
@.str.7 = [55 x i8] c" getreccfp: receivers at positions defined by xrcv\0A\00"
define void @getreccfp(i32* nocapture %0, i32* nocapture writeonly %1, i32* nocapture %2, i32 %3, float %4, float %5, float %6, float %7, i32 %8) {
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = bitcast i32* %10 to i8*
%14 = bitcast float* %11 to i8*
%15 = bitcast float* %12 to i8*
%16 = call i32 @getparint(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32* %10)
%17 = icmp eq i32 %16, 0
br i1 %17, label %18, label %19
18: ; preds = %9
store i32 1, i32* %10
br label %19
19: ; preds = %18, %9
%20 = call i32 @getparfloat(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), float* %11)
%21 = icmp eq i32 %20, 0
br i1 %21, label %22, label %23
22: ; preds = %19
store float 0.000000e+00, float* %11
br label %23
23: ; preds = %22, %19
%24 = call i32 @getparfloat(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), float* %12)
%25 = icmp eq i32 %24, 0
br i1 %25, label %28, label %26
26: ; preds = %23
%27 = load float, float* %12
br label %29
28: ; preds = %23
store float %4, float* %12
br label %29
29: ; preds = %26, %28
%30 = phi float [ %27, %26 ], [ %4, %28 ]
%31 = fdiv float %30, %4
%32 = fpext float %31 to double
%33 = fcmp ogt float %31, 0.000000e+00
%34 = select i1 %33, double 5.000000e-01, double -5.000000e-01
%35 = fadd double %34, %32
%36 = fptosi double %35 to i32
%37 = sitofp i32 %36 to float
%38 = fsub float %31, %37
%39 = call double @fabs(float %38)
%40 = fcmp ogt double %39, 1.000000e-03
br i1 %40, label %41, label %44
41: ; preds = %29
%42 = load i32, i32* @stderr
%43 = call i32 (i32, i8*, ...) @fprintf(i32 %42, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.3, i64 0, i64 0))
br label %44
44: ; preds = %41, %29
%45 = load float, float* %11
%46 = fsub float %45, %7
store float %46, float* %11
%47 = fdiv float %46, %5
%48 = fpext float %47 to double
%49 = fcmp ogt float %47, 0.000000e+00
%50 = select i1 %49, double 5.000000e-01, double -5.000000e-01
%51 = fadd double %50, %48
%52 = fptosi double %51 to i32
store i32 %52, i32* %1
%53 = call i32 @countparval(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%54 = icmp eq i32 %53, 0
br i1 %54, label %55, label %99
55: ; preds = %44
%56 = icmp eq i32 %8, 0
br i1 %56, label %62, label %57
57: ; preds = %55
%58 = load i32, i32* @stderr
%59 = load float, float* %12
%60 = fpext float %59 to double
%61 = call i32 (i32, i8*, ...) @fprintf(i32 %58, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.5, i64 0, i64 0), double %60)
br label %62
62: ; preds = %57, %55
%63 = add nsw i32 %3, -1
%64 = sitofp i32 %63 to float
%65 = fmul float %64, %4
%66 = load float, float* %12
%67 = fdiv float %65, %66
%68 = fpext float %67 to double
%69 = fcmp ogt float %67, 0.000000e+00
%70 = select i1 %69, double 5.000000e-01, double -5.000000e-01
%71 = fadd double %70, %68
%72 = fptosi double %71 to i32
%73 = add nsw i32 %72, 1
store i32 %73, i32* %2
%74 = icmp sgt i32 %72, -1
br i1 %74, label %75, label %91
75: ; preds = %62, %75
%76 = phi i64 [ %87, %75 ], [ 0, %62 ]
%77 = trunc i64 %76 to i32
%78 = sitofp i32 %77 to float
%79 = fmul float %66, %78
%80 = fdiv float %79, %4
%81 = fpext float %80 to double
%82 = fcmp ogt float %80, 0.000000e+00
%83 = select i1 %82, double 5.000000e-01, double -5.000000e-01
%84 = fadd double %83, %81
%85 = fptosi double %84 to i32
%86 = getelementptr inbounds i32, i32* %0, i64 %76
store i32 %85, i32* %86
%87 = add nuw nsw i64 %76, 1
%88 = load i32, i32* %2
%89 = sext i32 %88 to i64
%90 = icmp slt i64 %87, %89
br i1 %90, label %75, label %91
91: ; preds = %75, %62
%92 = phi i32 [ %73, %62 ], [ %88, %75 ]
%93 = add nsw i32 %92, -1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %0, i64 %94
%96 = load i32, i32* %95
%97 = icmp slt i32 %96, %3
br i1 %97, label %374, label %98
98: ; preds = %91
store i32 %93, i32* %2
br label %374
99: ; preds = %44
%100 = shl i32 %53, 2
%101 = call i64 @malloc(i32 %100)
%102 = inttoptr i64 %101 to float*
%103 = call i32 @getparfloat(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), float* %102)
%104 = icmp sgt i32 %53, 0
br i1 %104, label %105, label %173
105: ; preds = %99
%106 = zext i32 %53 to i64
%107 = icmp ult i32 %53, 8
br i1 %107, label %164, label %108
108: ; preds = %105
%109 = and i64 %106, 4294967288
%110 = insertelement <4 x float> poison, float %6, i64 0
%111 = shufflevector <4 x float> %110, <4 x float> poison, <4 x i32> zeroinitializer
%112 = insertelement <4 x float> poison, float %6, i64 0
%113 = shufflevector <4 x float> %112, <4 x float> poison, <4 x i32> zeroinitializer
%114 = add nsw i64 %109, -8
%115 = lshr exact i64 %114, 3
%116 = add nuw nsw i64 %115, 1
%117 = and i64 %116, 1
%118 = icmp eq i64 %114, 0
br i1 %118, label %148, label %119
119: ; preds = %108
%120 = and i64 %116, 4611686018427387902
br label %121
121: ; preds = %121, %119
%122 = phi i64 [ 0, %119 ], [ %145, %121 ]
%123 = phi i64 [ 0, %119 ], [ %146, %121 ]
%124 = getelementptr inbounds float, float* %102, i64 %122
%125 = bitcast float* %124 to <4 x float>*
%126 = load <4 x float>, <4 x float>* %125
%127 = getelementptr inbounds float, float* %124, i64 4
%128 = bitcast float* %127 to <4 x float>*
%129 = load <4 x float>, <4 x float>* %128
%130 = fsub <4 x float> %126, %111
%131 = fsub <4 x float> %129, %113
%132 = bitcast float* %124 to <4 x float>*
store <4 x float> %130, <4 x float>* %132
%133 = bitcast float* %127 to <4 x float>*
store <4 x float> %131, <4 x float>* %133
%134 = or i64 %122, 8
%135 = getelementptr inbounds float, float* %102, i64 %134
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = getelementptr inbounds float, float* %135, i64 4
%139 = bitcast float* %138 to <4 x float>*
%140 = load <4 x float>, <4 x float>* %139
%141 = fsub <4 x float> %137, %111
%142 = fsub <4 x float> %140, %113
%143 = bitcast float* %135 to <4 x float>*
store <4 x float> %141, <4 x float>* %143
%144 = bitcast float* %138 to <4 x float>*
store <4 x float> %142, <4 x float>* %144
%145 = add nuw i64 %122, 16
%146 = add i64 %123, 2
%147 = icmp eq i64 %146, %120
br i1 %147, label %148, label %121
148: ; preds = %121, %108
%149 = phi i64 [ 0, %108 ], [ %145, %121 ]
%150 = icmp eq i64 %117, 0
br i1 %150, label %162, label %151
151: ; preds = %148
%152 = getelementptr inbounds float, float* %102, i64 %149
%153 = bitcast float* %152 to <4 x float>*
%154 = load <4 x float>, <4 x float>* %153
%155 = getelementptr inbounds float, float* %152, i64 4
%156 = bitcast float* %155 to <4 x float>*
%157 = load <4 x float>, <4 x float>* %156
%158 = fsub <4 x float> %154, %111
%159 = fsub <4 x float> %157, %113
%160 = bitcast float* %152 to <4 x float>*
store <4 x float> %158, <4 x float>* %160
%161 = bitcast float* %155 to <4 x float>*
store <4 x float> %159, <4 x float>* %161
br label %162
162: ; preds = %148, %151
%163 = icmp eq i64 %109, %106
br i1 %163, label %173, label %164
164: ; preds = %105, %162
%165 = phi i64 [ 0, %105 ], [ %109, %162 ]
br label %166
166: ; preds = %164, %166
%167 = phi i64 [ %171, %166 ], [ %165, %164 ]
%168 = getelementptr inbounds float, float* %102, i64 %167
%169 = load float, float* %168
%170 = fsub float %169, %6
store float %170, float* %168
%171 = add nuw nsw i64 %167, 1
%172 = icmp eq i64 %171, %106
br i1 %172, label %173, label %166
173: ; preds = %166, %162, %99
%174 = load i32, i32* %10
%175 = icmp eq i32 %174, 1
%176 = icmp eq i32 %8, 0
br i1 %175, label %177, label %291
177: ; preds = %173
br i1 %176, label %183, label %178
178: ; preds = %177
%179 = load i32, i32* @stderr
%180 = load float, float* %12
%181 = fpext float %180 to double
%182 = call i32 (i32, i8*, ...) @fprintf(i32 %179, i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.6, i64 0, i64 0), double %181)
br label %183
183: ; preds = %178, %177
%184 = icmp sgt i32 %53, 1
br i1 %184, label %185, label %276
185: ; preds = %183
%186 = zext i32 %53 to i64
%187 = insertelement <4 x float> poison, float %4, i64 0
%188 = shufflevector <4 x float> %187, <4 x float> poison, <4 x i32> zeroinitializer
br label %189
189: ; preds = %185, %271
%190 = phi i64 [ 1, %185 ], [ %274, %271 ]
%191 = phi float* [ %102, %185 ], [ %193, %271 ]
%192 = phi i32 [ 0, %185 ], [ %273, %271 ]
%193 = getelementptr inbounds float, float* %102, i64 %190
%194 = bitcast float* %191 to <2 x float>*
%195 = load <2 x float>, <2 x float>* %194
%196 = extractelement <2 x float> %195, i64 0
%197 = shufflevector <2 x float> %195, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%198 = fsub <2 x float> %197, %195
%199 = extractelement <2 x float> %198, i64 0
%200 = load float, float* %12
%201 = fdiv float %199, %200
%202 = call double @fabs(float %201)
%203 = fcmp ogt double %202, 0.000000e+00
%204 = load float, float* %12
%205 = fdiv float %199, %204
%206 = call double @fabs(float %205)
%207 = select i1 %203, double 5.000000e-01, double -5.000000e-01
%208 = fadd double %206, %207
%209 = fptosi double %208 to i32
%210 = icmp slt i32 %209, 0
br i1 %210, label %271, label %211
211: ; preds = %189
%212 = load float, float* %12
%213 = sext i32 %192 to i64
%214 = zext i32 %209 to i64
%215 = add nuw nsw i64 %214, 1
%216 = icmp ult i32 %209, 3
br i1 %216, label %247, label %217
217: ; preds = %211
%218 = and i64 %215, 8589934588
%219 = add nsw i64 %218, %213
%220 = trunc i64 %218 to i32
%221 = insertelement <4 x float> poison, float %212, i64 0
%222 = shufflevector <4 x float> %221, <4 x float> poison, <4 x i32> zeroinitializer
%223 = shufflevector <2 x float> %198, <2 x float> undef, <4 x i32> zeroinitializer
%224 = shufflevector <2 x float> %195, <2 x float> undef, <4 x i32> zeroinitializer
br label %225
225: ; preds = %225, %217
%226 = phi i64 [ 0, %217 ], [ %242, %225 ]
%227 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %217 ], [ %243, %225 ]
%228 = add i64 %226, %213
%229 = sitofp <4 x i32> %227 to <4 x float>
%230 = fmul <4 x float> %222, %229
%231 = fmul <4 x float> %223, %230
%232 = fdiv <4 x float> %231, %223
%233 = fadd <4 x float> %224, %232
%234 = fdiv <4 x float> %233, %188
%235 = fpext <4 x float> %234 to <4 x double>
%236 = fcmp ogt <4 x float> %234, zeroinitializer
%237 = select <4 x i1> %236, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%238 = fadd <4 x double> %237, %235
%239 = fptosi <4 x double> %238 to <4 x i32>
%240 = getelementptr inbounds i32, i32* %0, i64 %228
%241 = bitcast i32* %240 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %241
%242 = add nuw i64 %226, 4
%243 = add <4 x i32> %227, <i32 4, i32 4, i32 4, i32 4>
%244 = icmp eq i64 %242, %218
br i1 %244, label %245, label %225
245: ; preds = %225
%246 = icmp eq i64 %215, %218
br i1 %246, label %268, label %247
247: ; preds = %211, %245
%248 = phi i64 [ %213, %211 ], [ %219, %245 ]
%249 = phi i32 [ 0, %211 ], [ %220, %245 ]
br label %250
250: ; preds = %247, %250
%251 = phi i64 [ %264, %250 ], [ %248, %247 ]
%252 = phi i32 [ %266, %250 ], [ %249, %247 ]
%253 = sitofp i32 %252 to float
%254 = fmul float %212, %253
%255 = fmul float %199, %254
%256 = fdiv float %255, %199
%257 = fadd float %196, %256
%258 = fdiv float %257, %4
%259 = fpext float %258 to double
%260 = fcmp ogt float %258, 0.000000e+00
%261 = select i1 %260, double 5.000000e-01, double -5.000000e-01
%262 = fadd double %261, %259
%263 = fptosi double %262 to i32
%264 = add nsw i64 %251, 1
%265 = getelementptr inbounds i32, i32* %0, i64 %251
store i32 %263, i32* %265
%266 = add nuw i32 %252, 1
%267 = icmp eq i32 %252, %209
br i1 %267, label %268, label %250
268: ; preds = %250, %245
%269 = phi i64 [ %219, %245 ], [ %264, %250 ]
%270 = trunc i64 %269 to i32
br label %271
271: ; preds = %268, %189
%272 = phi i32 [ %192, %189 ], [ %270, %268 ]
%273 = add nsw i32 %272, -1
%274 = add nuw nsw i64 %190, 1
%275 = icmp eq i64 %274, %186
br i1 %275, label %276, label %189
276: ; preds = %271, %183
%277 = phi i32 [ 0, %183 ], [ %273, %271 ]
%278 = add nsw i32 %53, -1
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %102, i64 %279
%281 = load float, float* %280
%282 = fdiv float %281, %4
%283 = fpext float %282 to double
%284 = fcmp ogt float %282, 0.000000e+00
%285 = select i1 %284, double 5.000000e-01, double -5.000000e-01
%286 = fadd double %285, %283
%287 = fptosi double %286 to i32
%288 = sext i32 %277 to i64
%289 = getelementptr inbounds i32, i32* %0, i64 %288
store i32 %287, i32* %289
%290 = add nsw i32 %277, 1
br label %371
291: ; preds = %173
br i1 %176, label %295, label %292
292: ; preds = %291
%293 = load i32, i32* @stderr
%294 = call i32 (i32, i8*, ...) @fprintf(i32 %293, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.7, i64 0, i64 0))
br label %295
295: ; preds = %292, %291
br i1 %104, label %296, label %371
296: ; preds = %295
%297 = zext i32 %53 to i64
%298 = icmp ult i32 %53, 4
br i1 %298, label %356, label %299
299: ; preds = %296
%300 = and i64 %297, 4294967292
%301 = insertelement <4 x float> poison, float %4, i64 0
%302 = shufflevector <4 x float> %301, <4 x float> poison, <4 x i32> zeroinitializer
%303 = add nsw i64 %300, -4
%304 = lshr exact i64 %303, 2
%305 = add nuw nsw i64 %304, 1
%306 = and i64 %305, 1
%307 = icmp eq i64 %303, 0
br i1 %307, label %339, label %308
308: ; preds = %299
%309 = and i64 %305, 9223372036854775806
br label %310
310: ; preds = %310, %308
%311 = phi i64 [ 0, %308 ], [ %336, %310 ]
%312 = phi i64 [ 0, %308 ], [ %337, %310 ]
%313 = getelementptr inbounds float, float* %102, i64 %311
%314 = bitcast float* %313 to <4 x float>*
%315 = load <4 x float>, <4 x float>* %314
%316 = fdiv <4 x float> %315, %302
%317 = fpext <4 x float> %316 to <4 x double>
%318 = fcmp ogt <4 x float> %316, zeroinitializer
%319 = select <4 x i1> %318, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%320 = fadd <4 x double> %319, %317
%321 = fptosi <4 x double> %320 to <4 x i32>
%322 = getelementptr inbounds i32, i32* %0, i64 %311
%323 = bitcast i32* %322 to <4 x i32>*
store <4 x i32> %321, <4 x i32>* %323
%324 = or i64 %311, 4
%325 = getelementptr inbounds float, float* %102, i64 %324
%326 = bitcast float* %325 to <4 x float>*
%327 = load <4 x float>, <4 x float>* %326
%328 = fdiv <4 x float> %327, %302
%329 = fpext <4 x float> %328 to <4 x double>
%330 = fcmp ogt <4 x float> %328, zeroinitializer
%331 = select <4 x i1> %330, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%332 = fadd <4 x double> %331, %329
%333 = fptosi <4 x double> %332 to <4 x i32>
%334 = getelementptr inbounds i32, i32* %0, i64 %324
%335 = bitcast i32* %334 to <4 x i32>*
store <4 x i32> %333, <4 x i32>* %335
%336 = add nuw i64 %311, 8
%337 = add i64 %312, 2
%338 = icmp eq i64 %337, %309
br i1 %338, label %339, label %310
339: ; preds = %310, %299
%340 = phi i64 [ 0, %299 ], [ %336, %310 ]
%341 = icmp eq i64 %306, 0
br i1 %341, label %354, label %342
342: ; preds = %339
%343 = getelementptr inbounds float, float* %102, i64 %340
%344 = bitcast float* %343 to <4 x float>*
%345 = load <4 x float>, <4 x float>* %344
%346 = fdiv <4 x float> %345, %302
%347 = fpext <4 x float> %346 to <4 x double>
%348 = fcmp ogt <4 x float> %346, zeroinitializer
%349 = select <4 x i1> %348, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%350 = fadd <4 x double> %349, %347
%351 = fptosi <4 x double> %350 to <4 x i32>
%352 = getelementptr inbounds i32, i32* %0, i64 %340
%353 = bitcast i32* %352 to <4 x i32>*
store <4 x i32> %351, <4 x i32>* %353
br label %354
354: ; preds = %339, %342
%355 = icmp eq i64 %300, %297
br i1 %355, label %371, label %356
356: ; preds = %296, %354
%357 = phi i64 [ 0, %296 ], [ %300, %354 ]
br label %358
358: ; preds = %356, %358
%359 = phi i64 [ %369, %358 ], [ %357, %356 ]
%360 = getelementptr inbounds float, float* %102, i64 %359
%361 = load float, float* %360
%362 = fdiv float %361, %4
%363 = fpext float %362 to double
%364 = fcmp ogt float %362, 0.000000e+00
%365 = select i1 %364, double 5.000000e-01, double -5.000000e-01
%366 = fadd double %365, %363
%367 = fptosi double %366 to i32
%368 = getelementptr inbounds i32, i32* %0, i64 %359
store i32 %367, i32* %368
%369 = add nuw nsw i64 %359, 1
%370 = icmp eq i64 %369, %297
br i1 %370, label %371, label %358
371: ; preds = %358, %354, %295, %276
%372 = phi i32 [ %290, %276 ], [ %53, %295 ], [ %53, %354 ], [ %53, %358 ]
store i32 %372, i32* %2
%373 = call i32 @free(float* %102)
br label %374
374: ; preds = %91, %98, %371
ret void
}