#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int FSize(char *);
scalar_t__ atan2(float, float);
scalar_t__ atof(char *);
scalar_t__ cos(float);
scalar_t__ fabs(float);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(float *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ fwrite(float *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ hcconvolve(float *, float *, int);
scalar_t__ hypot(float, float);
int log10(double);
scalar_t__ malloc(int);
int /*<<< orphan*/ perror(char *);
int /*<<< orphan*/ printf(char *, double, ...);
int /*<<< orphan*/ rdft(int, int, float *);
scalar_t__ sin(float);
int /*<<< orphan*/ sputs(char *);
int /*<<< orphan*/ sputsp(char *, char *);
scalar_t__ sqrt(double);
int /*<<< orphan*/ stdout;
int main(int argc, char *argv[]) {
  char *SweepFile;
  char *InverseFile;
  char *OutFile;
  char *RefSweepFile;
  float MinGain;
  float DLStart;
  int SS;
  int IS;
  int RS;
  int CS;
  int CL;
  int I;
  int J;
  float *Sweep;
  float *Inverse;
  float RF;
  float RMSLevel;
  float RMSMin;
  float DLSLevel;
  float DLLevel;
  float DLGFactor;
  float DLAbs;
  float DLTheta;
  int MP;
  float AMax;
  FILE *IOF;
  sputs("\nLSConv 1.1.0: log sweep and inverse filter convolution.");
  sputs("Copyright (C) 2002-2011 Denis Sbragion");
  sputs("\nCompiled with single precision arithmetic.");
  sputs("\nThis program may be freely redistributed under the terms of");
  sputs("the GNU GPL and is provided to you as is, without any warranty");
  sputs("of any kind. Please read the file \"COPYING\" for details.");
  if (argc < 4 || (argc > 4 && argc < 6)) {
    sputs("\nUsage: LSConv sweepfile inversefile outfile [refsweep mingain "
          "[dlstart]]");
    sputs("\nParameters:\n");
    sputs("  sweepfile: sweep file name");
    sputs("  inversefile: inverse sweep file name");
    sputs("  outfile: output impulse response file");
    sputs("  refsweep: reference channel sweep file name");
    sputs("  mingain: min gain for reference channel inversion");
    sputs("  dlstart: dip limiting start for reference channel inversion");
    sputs("\nExample: lsconv sweep.pcm inverse.pcm impulse.pcm refchannel.pcm "
          "0.1 0.8\n");
    return 0;
  }
  sputs("\nCommand line parsing.");
  SweepFile = argv[1];
  InverseFile = argv[2];
  OutFile = argv[3];
  if (argc > 4) {
    RefSweepFile = argv[4];
    MinGain = (float)atof(argv[5]);
  } else
    RefSweepFile = NULL;
  if (argc >= 7)
    DLStart = (float)atof(argv[6]);
  else
    DLStart = (float)2.0;
  sputs("Convolution length computation.");
  SS = FSize(SweepFile) / sizeof(float);
  IS = FSize(InverseFile) / sizeof(float);
  if (RefSweepFile != NULL)
    RS = FSize(RefSweepFile) / sizeof(float);
  else
    RS = 1;
  CL = SS + IS + RS - 2;
  for (CS = 1; CS < CL; CS <<= 1)
    ;
  sputs("Convolution arrays allocation.");
  if ((Sweep = (float *)malloc(sizeof(float) * CS)) == NULL) {
    sputs("Memory allocation failure.");
    return 1;
  }
  if ((Inverse = (float *)malloc(sizeof(float) * CS)) == NULL) {
    sputs("Memory allocation failure.");
    free(Sweep);
    return 1;
  }
  sputsp("Reading inverse file: ", InverseFile);
  if ((IOF = fopen(InverseFile, "rb")) == NULL) {
    perror("Unable to open inverse file");
    return 1;
  }
  for (I = 0; I < IS; I++) {
    fread(&RF, sizeof(float), 1, IOF);
    Inverse[I] = (float)RF;
  }
  for (I = IS; I < CS; I++)
    Inverse[I] = (float)0.0;
  fclose(IOF);
  sputs("Inverse filter FFT...");
  rdft(CS, (1), Inverse);
  if (RefSweepFile != NULL) {
    sputsp("Reading reference file: ", RefSweepFile);
    if ((IOF = fopen(RefSweepFile, "rb")) == NULL) {
      perror("Unable to open reference file");
      return 1;
    }
    for (I = 0; I < CS; I++)
      Sweep[I] = (float)0.0;
    for (I = CS - IS, J = 0; J < RS; I++, J++) {
      fread(&RF, sizeof(float), 1, IOF);
      Sweep[I % CS] = (float)RF;
    }
    fclose(IOF);
    sputs("Reference inversion and convolution...");
    rdft(CS, (1), Sweep);
    hcconvolve(Sweep, Inverse, CS);
    RMSLevel = Sweep[0] * Sweep[0];
    for (I = 2, J = 3; I < CS; I += 2, J += 2)
      RMSLevel += Sweep[I] * Sweep[I] + Sweep[J] * Sweep[J];
    RMSLevel = (float)sqrt(2.0 * RMSLevel / CS);
    RMSMin = MinGain * RMSLevel;
    if (DLStart >= (float)1.0) {
      if (Sweep[0] < RMSMin)
        Sweep[0] = ((float)1.0) / RMSMin;
      else
        Sweep[0] = ((float)1.0) / Sweep[0];
      if (Sweep[1] < RMSMin)
        Sweep[1] = ((float)1.0) / RMSMin;
      else
        Sweep[1] = ((float)1.0) / Sweep[1];
      for (I = 2, J = 3; I < CS; I += 2, J += 2) {
        DLAbs = (float)hypot(Sweep[I], Sweep[J]);
        if (DLAbs < RMSMin) {
          DLTheta = (float)atan2(Sweep[J], Sweep[I]);
          DLAbs = ((float)1.0) / RMSMin;
          Sweep[I] = DLAbs * (float)cos(-DLTheta);
          Sweep[J] = DLAbs * (float)sin(-DLTheta);
        } else {
          DLAbs = ((float)1.0) / (DLAbs * DLAbs);
          Sweep[I] *= DLAbs;
          Sweep[J] *= -DLAbs;
        }
      }
    } else {
      DLSLevel = RMSMin / DLStart;
      DLGFactor = DLSLevel - RMSMin;
      if (Sweep[0] < DLSLevel) {
        DLLevel = (DLSLevel - Sweep[0]) / DLGFactor;
        DLLevel = DLLevel / (((float)1.0) + DLLevel);
        Sweep[0] = ((float)1.0) / (DLSLevel - DLGFactor * DLLevel);
      } else
        Sweep[0] = ((float)1.0) / Sweep[0];
      if (Sweep[1] < DLSLevel) {
        DLLevel = (DLSLevel - Sweep[1]) / DLGFactor;
        DLLevel = DLLevel / (((float)1.0) + DLLevel);
        Sweep[1] = ((float)1.0) / (DLSLevel - DLGFactor * DLLevel);
      } else
        Sweep[1] = ((float)1.0) / Sweep[1];
      for (I = 2, J = 3; I < CS; I += 2, J += 2) {
        DLAbs = (float)hypot(Sweep[I], Sweep[J]);
        if (DLAbs <= (float)0.0) {
          Sweep[I] = ((float)1.0) / RMSMin;
          Sweep[J] = 0;
        } else if (DLAbs < DLSLevel) {
          DLLevel = (DLSLevel - DLAbs) / DLGFactor;
          DLLevel = DLLevel / (((float)1.0) + DLLevel);
          DLAbs = ((float)1.0) / (DLSLevel - DLGFactor * DLLevel);
          DLTheta = (float)atan2(Sweep[J], Sweep[I]);
          Sweep[I] = DLAbs * (float)cos(-DLTheta);
          Sweep[J] = DLAbs * (float)sin(-DLTheta);
        } else {
          DLAbs = ((float)1.0) / (DLAbs * DLAbs);
          Sweep[I] *= DLAbs;
          Sweep[J] *= -DLAbs;
        }
      }
    }
    hcconvolve(Inverse, Sweep, CS);
  }
  sputsp("Reading sweep file: ", SweepFile);
  if ((IOF = fopen(SweepFile, "rb")) == NULL) {
    perror("Unable to open sweep file");
    return 1;
  }
  for (I = 0; I < SS; I++) {
    fread(&RF, sizeof(float), 1, IOF);
    Sweep[I] = (float)RF;
  }
  fclose(IOF);
  for (I = SS; I < CS; I++)
    Sweep[I] = (float)0.0;
  sputs("Sweep and inverse convolution...");
  rdft(CS, (1), Sweep);
  hcconvolve(Sweep, Inverse, CS);
  rdft(CS, (-1), Sweep);
  for (I = 0; I < CS; I++)
    Sweep[I] *= (float)(2.0 / CS);
  sputs("Finding impulse response peak value...");
  MP = 0;
  AMax = (float)0.0;
  for (I = 0; I < CS; I++)
    if ((float)fabs(Sweep[I]) > AMax) {
      MP = I;
      AMax = (float)fabs(Sweep[I]);
    }
  printf("Peak position: %d\n", MP);
  if (AMax > (float)0.0)
    printf("Peak value: %f (%f dB)\n", (double)AMax,
           (double)(20 * log10((double)AMax)));
  else
    printf("Peak value: %f (-inf dB)\n", (double)AMax);
  fflush(stdout);
  sputsp("Writing output file: ", OutFile);
  if ((IOF = fopen(OutFile, "wb")) == NULL) {
    perror("Unable to open output file");
    return 1;
  }
  for (I = 0; I < CL; I++) {
    RF = (float)Sweep[I];
    fwrite(&RF, sizeof(float), 1, IOF);
  }
  fclose(IOF);
  free(Sweep);
  free(Inverse);
  sputs("Completed.");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0x1d90(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1dbd(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1dd8(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1df8(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1e29(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1e5c(%rip),%rdi
call   1030 <sputs@plt>
cmpl   $0x4,-0x8(%rbp)
jl     12df <main+0x7f>
cmpl   $0x4,-0x8(%rbp)
jle    1357 <main+0xf7>
cmpl   $0x6,-0x8(%rbp)
jge    1357 <main+0xf7>
lea    0x1e6b(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1ea9(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1eab(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1ebc(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1ed7(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1ef3(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1f15(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1f3d(%rip),%rdi
call   1030 <sputs@plt>
lea    0x1f6f(%rip),%rdi
call   1030 <sputs@plt>
movl   $0x0,-0x4(%rbp)
jmp    2154 <main+0xef4>
lea    0x1fa2(%rip),%rdi
call   1030 <sputs@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x28(%rbp)
cmpl   $0x4,-0x8(%rbp)
jle    13b9 <main+0x159>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rdi
call   1070 <atof@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    13c1 <main+0x161>
movq   $0x0,-0x30(%rbp)
cmpl   $0x7,-0x8(%rbp)
jl     13e7 <main+0x187>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rdi
call   1070 <atof@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    13f4 <main+0x194>
movss  0x1c11(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
lea    0x1f1c(%rip),%rdi
call   1030 <sputs@plt>
mov    -0x18(%rbp),%rdi
call   1110 <FSize@plt>
cltq
shr    $0x2,%rax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rdi
call   1110 <FSize@plt>
cltq
shr    $0x2,%rax
mov    %eax,-0x40(%rbp)
cmpq   $0x0,-0x30(%rbp)
je     1446 <main+0x1e6>
mov    -0x30(%rbp),%rdi
call   1110 <FSize@plt>
cltq
shr    $0x2,%rax
mov    %eax,-0x44(%rbp)
jmp    144d <main+0x1ed>
movl   $0x1,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
add    -0x44(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1482 <main+0x222>
jmp    1474 <main+0x214>
mov    -0x48(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1463 <main+0x203>
lea    0x1eae(%rip),%rdi
call   1030 <sputs@plt>
movslq -0x48(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10e0 <malloc@plt>
mov    %rax,-0x60(%rbp)
cmp    $0x0,%rax
jne    14c3 <main+0x263>
lea    0x1ea4(%rip),%rdi
call   1030 <sputs@plt>
movl   $0x1,-0x4(%rbp)
jmp    2154 <main+0xef4>
movslq -0x48(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10e0 <malloc@plt>
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
jne    1501 <main+0x2a1>
lea    0x1e6f(%rip),%rdi
call   1030 <sputs@plt>
mov    -0x60(%rbp),%rdi
call   1040 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    2154 <main+0xef4>
mov    -0x20(%rbp),%rsi
lea    0x1e65(%rip),%rdi
call   1050 <sputsp@plt>
mov    -0x20(%rbp),%rdi
lea    0x1e6c(%rip),%rsi
call   1130 <fopen@plt>
mov    %rax,-0x98(%rbp)
cmp    $0x0,%rax
jne    154a <main+0x2ea>
lea    0x1e52(%rip),%rdi
call   1140 <perror@plt>
movl   $0x1,-0x4(%rbp)
jmp    2154 <main+0xef4>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1597 <main+0x337>
mov    -0x98(%rbp),%rcx
lea    -0x6c(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
call   1060 <fread@plt>
movss  -0x6c(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1551 <main+0x2f1>
mov    -0x40(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15c7 <main+0x367>
mov    -0x68(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    159d <main+0x33d>
mov    -0x98(%rbp),%rdi
call   1090 <fclose@plt>
lea    0x1dcd(%rip),%rdi
call   1030 <sputs@plt>
mov    -0x48(%rbp),%edi
mov    -0x68(%rbp),%rdx
mov    $0x1,%esi
call   10b0 <rdft@plt>
cmpq   $0x0,-0x30(%rbp)
je     1e09 <main+0xba9>
mov    -0x30(%rbp),%rsi
lea    0x1db7(%rip),%rdi
call   1050 <sputsp@plt>
mov    -0x30(%rbp),%rdi
lea    0x1d72(%rip),%rsi
call   1130 <fopen@plt>
mov    %rax,-0x98(%rbp)
cmp    $0x0,%rax
jne    1644 <main+0x3e4>
lea    0x1da3(%rip),%rdi
call   1140 <perror@plt>
movl   $0x1,-0x4(%rbp)
jmp    2154 <main+0xef4>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1675 <main+0x415>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    164b <main+0x3eb>
mov    -0x48(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    16e8 <main+0x488>
mov    -0x98(%rbp),%rcx
lea    -0x6c(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
call   1060 <fread@plt>
movss  -0x6c(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x50(%rbp),%eax
cltd
idivl  -0x48(%rbp)
mov    -0xa0(%rbp),%rax
movslq %edx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1685 <main+0x425>
mov    -0x98(%rbp),%rdi
call   1090 <fclose@plt>
lea    0x1cf9(%rip),%rdi
call   1030 <sputs@plt>
mov    -0x48(%rbp),%edi
mov    -0x60(%rbp),%rdx
mov    $0x1,%esi
call   10b0 <rdft@plt>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x48(%rbp),%edx
call   1180 <hcconvolve@plt>
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x2,-0x50(%rbp)
movl   $0x3,-0x54(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    17ad <main+0x54d>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
jmp    1744 <main+0x4e4>
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x184a(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1160 <sqrt@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x38(%rbp),%xmm0
movss  0x180e(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     1a4b <main+0x7eb>
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x74(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    182f <main+0x5cf>
movss  0x17e7(%rip),%xmm0
divss  -0x74(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1847 <main+0x5e7>
mov    -0x60(%rbp),%rax
movss  0x17c9(%rip),%xmm0
divss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm1
movss  -0x74(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1879 <main+0x619>
movss  0x179e(%rip),%xmm0
divss  -0x74(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    1893 <main+0x633>
mov    -0x60(%rbp),%rax
movss  0x177f(%rip),%xmm0
divss  0x4(%rax),%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x2,-0x50(%rbp)
movl   $0x3,-0x54(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1a46 <main+0x7e6>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
call   1100 <hypot@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm1
ff
movss  -0x74(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    19c5 <main+0x765>
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
call   1080 <atan2@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  0x16e1(%rip),%xmm0
divss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1120 <cos@plt>
movss  -0xa8(%rbp),%xmm0
ff
cvtsi2ss %rax,%xmm1
mulss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   10d0 <sin@plt>
movss  -0xa4(%rbp),%xmm0
ff
cvtsi2ss %rax,%xmm1
mulss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1a2a <main+0x7ca>
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  0x1627(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1a2f <main+0x7cf>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
jmp    18a1 <main+0x641>
jmp    1df9 <main+0xb99>
movss  -0x74(%rbp),%xmm0
divss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x78(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1aee <main+0x88e>
movss  -0x78(%rbp),%xmm0
mov    -0x60(%rbp),%rax
subss  (%rax),%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  0x1561(%rip),%xmm1
addss  -0x7c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1527(%rip),%xmm0
divss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1b06 <main+0x8a6>
mov    -0x60(%rbp),%rax
movss  0x150a(%rip),%xmm0
divss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x60(%rbp),%rax
movss  0x4(%rax),%xmm1
movss  -0x78(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1b8e <main+0x92e>
movss  -0x78(%rbp),%xmm0
mov    -0x60(%rbp),%rax
subss  0x4(%rax),%xmm0
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  0x14c2(%rip),%xmm1
addss  -0x7c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1488(%rip),%xmm0
divss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
jmp    1ba8 <main+0x948>
mov    -0x60(%rbp),%rax
movss  0x146a(%rip),%xmm0
divss  0x4(%rax),%xmm0
mov    -0x60(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x2,-0x50(%rbp)
movl   $0x3,-0x54(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1df4 <main+0xb94>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
call   1100 <hypot@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
xorps  %xmm0,%xmm0
ucomiss -0x84(%rbp),%xmm0
jb     1c2d <main+0x9cd>
movss  0x13fe(%rip),%xmm0
divss  -0x74(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1dd8 <main+0xb78>
movss  -0x84(%rbp),%xmm1
ff
movss  -0x78(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1d6e <main+0xb0e>
movss  -0x78(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
divss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  0x139d(%rip),%xmm1
addss  -0x7c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x1363(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
call   1080 <atan2@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   1120 <cos@plt>
movss  -0xb0(%rbp),%xmm0
ff
cvtsi2ss %rax,%xmm1
mulss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
call   10d0 <sin@plt>
movss  -0xac(%rbp),%xmm0
ff
cvtsi2ss %rax,%xmm1
mulss  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1dd3 <main+0xb73>
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  0x127e(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1dd8 <main+0xb78>
jmp    1ddd <main+0xb7d>
mov    -0x50(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
jmp    1bb6 <main+0x956>
jmp    1df9 <main+0xb99>
mov    -0x68(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x48(%rbp),%edx
call   1180 <hcconvolve@plt>
mov    -0x18(%rbp),%rsi
lea    0x1607(%rip),%rdi
call   1050 <sputsp@plt>
mov    -0x18(%rbp),%rdi
lea    0x1564(%rip),%rsi
call   1130 <fopen@plt>
mov    %rax,-0x98(%rbp)
cmp    $0x0,%rax
jne    1e52 <main+0xbf2>
lea    0x15ef(%rip),%rdi
call   1140 <perror@plt>
movl   $0x1,-0x4(%rbp)
jmp    2154 <main+0xef4>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1e9f <main+0xc3f>
mov    -0x98(%rbp),%rcx
lea    -0x6c(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
call   1060 <fread@plt>
movss  -0x6c(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1e59 <main+0xbf9>
mov    -0x98(%rbp),%rdi
call   1090 <fclose@plt>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1edb <main+0xc7b>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1eb1 <main+0xc51>
lea    0x1568(%rip),%rdi
call   1030 <sputs@plt>
mov    -0x48(%rbp),%edi
mov    -0x60(%rbp),%rdx
mov    $0x1,%esi
call   10b0 <rdft@plt>
mov    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x48(%rbp),%edx
call   1180 <hcconvolve@plt>
mov    -0x48(%rbp),%edi
mov    -0x60(%rbp),%rdx
mov    $0xffffffff,%esi
call   10b0 <rdft@plt>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1f61 <main+0xd01>
cvtsi2sdl -0x48(%rbp),%xmm1
movsd  0x10cf(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1f20 <main+0xcc0>
lea    0x1503(%rip),%rdi
call   1030 <sputs@plt>
movl   $0x0,-0x8c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1ff4 <main+0xd94>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   10c0 <fabs@plt>
cvtsi2ss %rax,%xmm0
ucomiss -0x90(%rbp),%xmm0
jbe    1fe1 <main+0xd81>
mov    -0x50(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   10c0 <fabs@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
jmp    1fe6 <main+0xd86>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1f89 <main+0xd29>
cvtsi2sdl -0x8c(%rbp),%xmm0
ff
lea    0x148f(%rip),%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
movss  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    2065 <main+0xe05>
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1150 <log10@plt>
movsd  -0xb8(%rbp),%xmm0
ff
imul   $0x14,%eax,%eax
cvtsi2sd %eax,%xmm1
lea    0x144c(%rip),%rdi
mov    $0x2,%al
call   10a0 <printf@plt>
jmp    207f <main+0xe1f>
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x1445(%rip),%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
mov    0x2f5a(%rip),%rax
mov    (%rax),%edi
call   10f0 <fflush@plt>
mov    -0x28(%rbp),%rsi
lea    0x143f(%rip),%rdi
call   1050 <sputsp@plt>
mov    -0x28(%rbp),%rdi
lea    0x1445(%rip),%rsi
call   1130 <fopen@plt>
mov    %rax,-0x98(%rbp)
cmp    $0x0,%rax
jne    20d6 <main+0xe76>
lea    0x142b(%rip),%rdi
call   1140 <perror@plt>
movl   $0x1,-0x4(%rbp)
jmp    2154 <main+0xef4>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    2123 <main+0xec3>
mov    -0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x98(%rbp),%rcx
lea    -0x6c(%rbp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
call   1170 <fwrite@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    20dd <main+0xe7d>
mov    -0x98(%rbp),%rdi
call   1090 <fclose@plt>
mov    -0x60(%rbp),%rdi
call   1040 <free@plt>
mov    -0x68(%rbp),%rdi
call   1040 <free@plt>
lea    0x13c3(%rip),%rdi
call   1030 <sputs@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rsi,%rbx
mov    %edi,%ebp
lea    0xd9b(%rip),%rdi
call   1030 <sputs@plt>
lea    0xdc8(%rip),%rdi
call   1030 <sputs@plt>
lea    0xde3(%rip),%rdi
call   1030 <sputs@plt>
lea    0xe03(%rip),%rdi
call   1030 <sputs@plt>
lea    0xe34(%rip),%rdi
call   1030 <sputs@plt>
lea    0xe67(%rip),%rdi
call   1030 <sputs@plt>
cmp    $0x4,%ebp
jl     12e2 <main+0x72>
je     1362 <main+0xf2>
cmp    $0x5,%ebp
ja     1362 <main+0xf2>
lea    0xe80(%rip),%rdi
call   1030 <sputs@plt>
lea    0xebe(%rip),%rdi
call   1030 <sputs@plt>
lea    0xec0(%rip),%rdi
call   1030 <sputs@plt>
lea    0xed1(%rip),%rdi
call   1030 <sputs@plt>
lea    0xeec(%rip),%rdi
call   1030 <sputs@plt>
lea    0xf08(%rip),%rdi
call   1030 <sputs@plt>
lea    0xf2a(%rip),%rdi
call   1030 <sputs@plt>
lea    0xf52(%rip),%rdi
call   1030 <sputs@plt>
lea    0xf84(%rip),%rdi
call   1030 <sputs@plt>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xfaf(%rip),%rdi
call   1030 <sputs@plt>
mov    0x8(%rbx),%r14
mov    0x10(%rbx),%r13
mov    0x18(%rbx),%rax
movss  0xc7e(%rip),%xmm0
cmp    $0x4,%ebp
mov    %rax,0x80(%rsp)
movss  %xmm0,0x40(%rsp)
je     13ce <main+0x15e>
mov    0x20(%rbx),%r12
mov    0x28(%rbx),%rdi
call   1070 <atof@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cmp    $0x7,%ebp
movss  %xmm0,0x8(%rsp)
jb     13d1 <main+0x161>
mov    0x30(%rbx),%rdi
call   1070 <atof@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x40(%rsp)
jmp    13d1 <main+0x161>
xor    %r12d,%r12d
lea    0xf57(%rip),%rdi
call   1030 <sputs@plt>
mov    %r14,%rdi
call   1120 <FSize@plt>
mov    %eax,0x3c(%rsp)
mov    %eax,%ebx
sar    $0x2,%ebx
mov    %r13,%rdi
call   1120 <FSize@plt>
mov    %eax,0x28(%rsp)
mov    %eax,%ecx
sar    $0x2,%ecx
mov    $0x1,%ebp
mov    $0x1,%r15d
test   %r12,%r12
je     1424 <main+0x1b4>
mov    %r12,%rdi
mov    %rcx,%r15
call   1120 <FSize@plt>
mov    %r15,%rcx
mov    %eax,%r15d
sar    $0x2,%r15d
mov    %r12,0x60(%rsp)
mov    %r14,0x88(%rsp)
mov    %rbx,0x58(%rsp)
mov    %rcx,0x18(%rsp)
lea    (%rbx,%rcx,1),%eax
lea    (%r15,%rax,1),%ebx
add    $0xfffffffe,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebp,%r12d
lea    (%r12,%r12,1),%ebp
cmp    %ebx,%r12d
jl     1450 <main+0x1e0>
lea    0xeec(%rip),%rdi
call   1030 <sputs@plt>
lea    0x0(,%r12,4),%r14d
mov    %r14d,%edi
call   10f0 <malloc@plt>
test   %rax,%rax
je     18c7 <main+0x657>
mov    %rax,%rbp
mov    %r14d,%edi
call   10f0 <malloc@plt>
mov    %rax,0x20(%rsp)
test   %rax,%rax
je     18dd <main+0x66d>
lea    0xee8(%rip),%rdi
mov    %r13,%rsi
call   1050 <sputsp@plt>
lea    0xef0(%rip),%rsi
mov    %r13,%rdi
call   1140 <fopen@plt>
test   %rax,%rax
je     1e4d <main+0xbdd>
mov    %rax,%r13
mov    %ebx,0x34(%rsp)
mov    %rbp,0x78(%rsp)
cmpl   $0x4,0x28(%rsp)
mov    0x20(%rsp),%rbx
jl     151c <main+0x2ac>
mov    0x18(%rsp),%rax
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovge %eax,%ebp
xor    %r14d,%r14d
nopl   0x0(%rax)
lea    0x14(%rsp),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1060 <fread@plt>
movss  0x14(%rsp),%xmm0
movss  %xmm0,(%rbx,%r14,4)
add    $0x1,%r14
cmp    %r14,%rbp
jne    14f0 <main+0x280>
mov    %r12d,%ebp
mov    0x18(%rsp),%rdx
sub    %edx,%ebp
mov    0x78(%rsp),%r14
jle    154d <main+0x2dd>
movslq %edx,%rax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
not    %edx
add    %r12d,%edx
lea    0x4(,%rdx,4),%rdx
xor    %esi,%esi
call   10b0 <memset@plt>
mov    %r13,%rdi
call   1090 <fclose@plt>
lea    0xe63(%rip),%rdi
call   1030 <sputs@plt>
mov    %r12d,%edi
mov    $0x1,%esi
mov    0x20(%rsp),%rdx
call   10c0 <rdft@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x60(%rsp),%rbx
test   %rbx,%rbx
je     1a31 <main+0x7c1>
lea    0xe3f(%rip),%rdi
mov    %rbx,%rsi
call   1050 <sputsp@plt>
lea    0xdfb(%rip),%rsi
mov    %rbx,%rdi
call   1140 <fopen@plt>
test   %rax,%rax
je     1e68 <main+0xbf8>
mov    %rax,%rbx
test   %r12d,%r12d
jle    15cf <main+0x35f>
mov    %r12d,%edx
shl    $0x2,%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   10b0 <memset@plt>
test   %r15d,%r15d
jle    1613 <main+0x3a3>
lea    0x14(%rsp),%r13
nopl   0x0(%rax)
mov    %r13,%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1060 <fread@plt>
movss  0x14(%rsp),%xmm0
mov    %ebp,%eax
cltd
idiv   %r12d
movslq %edx,%rax
movss  %xmm0,(%r14,%rax,4)
add    $0x1,%ebp
add    $0xffffffff,%r15d
jne    15e0 <main+0x370>
mov    %rbx,%rdi
call   1090 <fclose@plt>
lea    0xdea(%rip),%rdi
call   1030 <sputs@plt>
mov    %r12d,%edi
mov    $0x1,%esi
mov    %r14,%rdx
call   10c0 <rdft@plt>
mov    %r14,%rdi
mov    0x20(%rsp),%r15
mov    %r15,%rsi
mov    %r12d,%edx
call   1190 <hcconvolve@plt>
movss  (%r14),%xmm0
mulss  %xmm0,%xmm0
cmp    $0x3,%r12d
jl     1696 <main+0x426>
mov    %r12d,%eax
mov    $0x2,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rcx,4),%xmm1
movss  0x4(%r14,%rcx,4),%xmm2
mulss  %xmm2,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
addss  %xmm1,%xmm0
add    $0x2,%rcx
cmp    %rax,%rcx
jb     1670 <main+0x400>
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
divsd  0x28(%rsp),%xmm0
call   1170 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  0x8(%rsp),%xmm2
mulss  %xmm0,%xmm2
movss  0x40(%rsp),%xmm0
ucomiss 0x93c(%rip),%xmm0
movss  %xmm2,0x8(%rsp)
jae    18fb <main+0x68b>
movaps %xmm2,%xmm3
divss  %xmm0,%xmm3
movaps %xmm3,%xmm0
subss  %xmm2,%xmm0
movaps %xmm0,%xmm2
movss  (%r14),%xmm0
ucomiss %xmm0,%xmm3
jbe    1715 <main+0x4a5>
movaps %xmm3,%xmm1
subss  %xmm0,%xmm1
divss  %xmm2,%xmm1
movss  0x902(%rip),%xmm0
addss  %xmm1,%xmm0
divss  %xmm0,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm3,%xmm0
subss  %xmm1,%xmm0
movss  0x8e7(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movss  0x4(%r14),%xmm0
ucomiss %xmm0,%xmm3
movss  %xmm3,0x18(%rsp)
movaps %xmm2,0x60(%rsp)
jbe    1762 <main+0x4f2>
movaps %xmm3,%xmm1
subss  %xmm0,%xmm1
divss  %xmm2,%xmm1
movss  0x8b5(%rip),%xmm0
addss  %xmm1,%xmm0
divss  %xmm0,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm3,%xmm0
subss  %xmm1,%xmm0
movss  0x89a(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%r14)
cmp    $0x3,%r12d
jl     1a23 <main+0x7b3>
movaps 0x88b(%rip),%xmm0
xorps  0x60(%rsp),%xmm0
movaps %xmm0,0x90(%rsp)
movss  0x86a(%rip),%xmm0
divss  0x8(%rsp),%xmm0
movss  %xmm0,0x38(%rsp)
mov    %r12d,%ebx
mov    $0x2,%ebp
jmp    17d3 <main+0x563>
movss  0x38(%rsp),%xmm0
movss  %xmm0,(%r14,%rbp,4)
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%r14,%rbp,4)
add    $0x2,%rbp
cmp    %rbx,%rbp
jae    1a23 <main+0x7b3>
movss  (%r14,%rbp,4),%xmm0
movss  0x4(%r14,%rbp,4),%xmm1
call   1110 <hypot@plt>
test   %rax,%rax
jle    17b0 <main+0x540>
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
movss  0x18(%rsp),%xmm2
ucomiss %xmm1,%xmm2
jbe    1894 <main+0x624>
movaps %xmm2,%xmm0
subss  %xmm1,%xmm0
divss  0x60(%rsp),%xmm0
movaps %xmm0,%xmm1
movss  0x7eb(%rip),%xmm3
addss  %xmm3,%xmm1
divss  %xmm1,%xmm0
mulss  0x90(%rsp),%xmm0
addss  %xmm2,%xmm0
divss  %xmm0,%xmm3
movss  %xmm3,0x8(%rsp)
movss  (%r14,%rbp,4),%xmm1
movss  0x4(%r14,%rbp,4),%xmm0
call   1080 <atan2@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  0x7b7(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
call   1130 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0x8(%rsp),%xmm0
movss  %xmm0,(%r14,%rbp,4)
movaps 0x40(%rsp),%xmm0
call   10e0 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0x8(%rsp),%xmm0
jmp    17bf <main+0x54f>
mulss  %xmm1,%xmm1
movss  0x764(%rip),%xmm0
divss  %xmm1,%xmm0
movss  (%r14,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r14,%rbp,4)
xorps  0x755(%rip),%xmm0
mulss  0x4(%r14,%rbp,4),%xmm0
jmp    17bf <main+0x54f>
lea    0xaa0(%rip),%rdi
call   1030 <sputs@plt>
mov    $0x1,%eax
jmp    1350 <main+0xe0>
lea    0xa8a(%rip),%rdi
call   1030 <sputs@plt>
mov    %rbp,%rdi
call   1040 <free@plt>
mov    $0x1,%eax
jmp    1350 <main+0xe0>
movaps %xmm2,%xmm0
maxss  (%r14),%xmm0
movss  0x6f9(%rip),%xmm3
movaps %xmm3,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movaps %xmm2,%xmm0
maxss  0x4(%r14),%xmm0
movaps %xmm3,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%r14)
cmp    $0x3,%r12d
jl     1a23 <main+0x7b3>
movss  0x6c5(%rip),%xmm0
divss  0x8(%rsp),%xmm0
movss  %xmm0,0x18(%rsp)
mov    %r12d,%ebx
mov    $0x2,%ebp
jmp    19a2 <main+0x732>
cs nopw 0x0(%rax,%rax,1)
nop
mulss  %xmm1,%xmm1
movss  0x698(%rip),%xmm0
divss  %xmm1,%xmm0
movss  (%r14,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r14,%rbp,4)
xorps  0x689(%rip),%xmm0
mulss  0x4(%r14,%rbp,4),%xmm0
movss  %xmm0,0x4(%r14,%rbp,4)
add    $0x2,%rbp
cmp    %rbx,%rbp
jae    1a23 <main+0x7b3>
movss  (%r14,%rbp,4),%xmm0
movss  0x4(%r14,%rbp,4),%xmm1
call   1110 <hypot@plt>
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
movss  0x8(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1960 <main+0x6f0>
movss  (%r14,%rbp,4),%xmm1
movss  0x4(%r14,%rbp,4),%xmm0
call   1080 <atan2@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  0x628(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
call   1130 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0x18(%rsp),%xmm0
movss  %xmm0,(%r14,%rbp,4)
movaps 0x40(%rsp),%xmm0
call   10e0 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0x18(%rsp),%xmm0
jmp    198e <main+0x71e>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12d,%edx
call   1190 <hcconvolve@plt>
lea    0x9fb(%rip),%rdi
mov    0x88(%rsp),%rbx
mov    %rbx,%rsi
call   1050 <sputsp@plt>
lea    0x951(%rip),%rsi
mov    %rbx,%rdi
call   1140 <fopen@plt>
test   %rax,%rax
je     1e56 <main+0xbe6>
mov    %rax,%r15
cmpl   $0x4,0x3c(%rsp)
jl     1aba <main+0x84a>
mov    0x58(%rsp),%rax
cmp    $0x2,%eax
mov    $0x1,%r13d
cmovge %eax,%r13d
xor    %ebp,%ebp
lea    0x14(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %r15,%rcx
call   1060 <fread@plt>
movss  0x14(%rsp),%xmm0
movss  %xmm0,(%r14,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1a90 <main+0x820>
mov    %r15,%rdi
call   1090 <fclose@plt>
mov    0x58(%rsp),%rcx
cmp    %r12d,%ecx
jge    1ae7 <main+0x877>
movslq %ecx,%rax
lea    (%r14,%rax,4),%rdi
not    %ecx
add    %r12d,%ecx
lea    0x4(,%rcx,4),%rdx
xor    %esi,%esi
call   10b0 <memset@plt>
lea    0x974(%rip),%rdi
call   1030 <sputs@plt>
mov    %r12d,%edi
mov    $0x1,%esi
mov    %r14,%rdx
call   10c0 <rdft@plt>
mov    %r14,%rdi
mov    0x20(%rsp),%r13
mov    %r13,%rsi
mov    %r12d,%edx
call   1190 <hcconvolve@plt>
mov    %r12d,%edi
mov    $0xffffffff,%esi
mov    %r14,%rdx
call   10c0 <rdft@plt>
test   %r12d,%r12d
jle    1b4d <main+0x8dd>
movsd  0x4ed(%rip),%xmm0
divsd  0x28(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    %r12d,%ebp
cmp    $0x8,%r12d
jae    1b5e <main+0x8ee>
xor    %eax,%eax
jmp    1c00 <main+0x990>
lea    0x92f(%rip),%rdi
call   1030 <sputs@plt>
jmp    1ce5 <main+0xa75>
mov    %ebp,%eax
and    $0xfffffff8,%eax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1bd6 <main+0x966>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups (%r14,%rcx,4),%xmm2
movups 0x10(%r14,%rcx,4),%xmm3
movups 0x20(%r14,%rcx,4),%xmm4
movups 0x30(%r14,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r14,%rcx,4)
movups %xmm3,0x10(%r14,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%r14,%rcx,4)
movups %xmm5,0x30(%r14,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1b90 <main+0x920>
jmp    1bd8 <main+0x968>
xor    %ecx,%ecx
test   $0x1,%dl
je     1bf9 <main+0x989>
movups (%r14,%rcx,4),%xmm2
movups 0x10(%r14,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r14,%rcx,4)
movups %xmm3,0x10(%r14,%rcx,4)
cmp    %rbp,%rax
je     1c19 <main+0x9a9>
xchg   %ax,%ax
movss  (%r14,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1c00 <main+0x990>
lea    0x863(%rip),%rdi
call   1030 <sputs@plt>
test   %r12d,%r12d
jle    1ce5 <main+0xa75>
cmp    $0x1,%r12d
jne    1dae <main+0xb3e>
xor    %ebx,%ebx
xorps  %xmm0,%xmm0
xor    %r12d,%r12d
test   $0x1,%bpl
je     1c82 <main+0xa12>
movss  %xmm0,0x8(%rsp)
movss  (%r14,%rbx,4),%xmm0
call   10d0 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
ucomiss 0x8(%rsp),%xmm0
movss  0x8(%rsp),%xmm0
jbe    1c82 <main+0xa12>
movss  (%r14,%rbx,4),%xmm0
call   10d0 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    %ebx,%r12d
movss  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
lea    0x813(%rip),%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
xorpd  %xmm0,%xmm0
movss  0x8(%rsp),%xmm1
ucomiss %xmm0,%xmm1
movss  0x8(%rsp),%xmm0
jbe    1cfb <main+0xa8b>
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
call   1160 <log10@plt>
shl    $0x2,%eax
lea    (%rax,%rax,4),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
lea    0x7e7(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x2,%al
call   10a0 <printf@plt>
jmp    1d0d <main+0xa9d>
lea    0x7be(%rip),%rdi
xorpd  %xmm0,%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
xorpd  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x7cf(%rip),%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
mov    0x22cc(%rip),%rax
mov    (%rax),%edi
call   1100 <fflush@plt>
lea    0x7cd(%rip),%rdi
mov    0x80(%rsp),%rbx
mov    %rbx,%rsi
call   1050 <sputsp@plt>
lea    0x7cc(%rip),%rsi
mov    %rbx,%rdi
call   1140 <fopen@plt>
test   %rax,%rax
je     1e5f <main+0xbef>
mov    %rax,%r15
mov    0x34(%rsp),%eax
test   %eax,%eax
jle    1d8a <main+0xb1a>
mov    %eax,%ebp
xor    %ebx,%ebx
lea    0x14(%rsp),%r12
xchg   %ax,%ax
movss  (%r14,%rbx,4),%xmm0
movss  %xmm0,0x14(%rsp)
mov    %r12,%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %r15,%rcx
call   1180 <fwrite@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1d60 <main+0xaf0>
mov    %r15,%rdi
call   1090 <fclose@plt>
mov    %r14,%rdi
call   1040 <free@plt>
mov    %r13,%rdi
call   1040 <free@plt>
lea    0x77a(%rip),%rdi
jmp    1349 <main+0xd9>
mov    %ebp,%r15d
and    $0xfffffffe,%r15d
xor    %ebx,%ebx
xorps  %xmm0,%xmm0
xor    %r12d,%r12d
jmp    1dcd <main+0xb5d>
nop
add    $0x2,%rbx
cmp    %rbx,%r15
je     1c40 <main+0x9d0>
movss  %xmm0,0x8(%rsp)
movss  (%r14,%rbx,4),%xmm0
call   10d0 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
ucomiss 0x8(%rsp),%xmm0
movss  0x8(%rsp),%xmm0
jbe    1e09 <main+0xb99>
movss  (%r14,%rbx,4),%xmm0
call   10d0 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    %ebx,%r12d
movss  %xmm0,0x8(%rsp)
movss  0x4(%r14,%rbx,4),%xmm0
call   10d0 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
ucomiss 0x8(%rsp),%xmm0
movss  0x8(%rsp),%xmm0
jbe    1dc0 <main+0xb50>
movss  0x4(%r14,%rbx,4),%xmm0
call   10d0 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
lea    0x1(%rbx),%r12d
jmp    1dc0 <main+0xb50>
lea    0x54f(%rip),%rdi
jmp    1e6f <main+0xbff>
lea    0x5eb(%rip),%rdi
jmp    1e6f <main+0xbff>
lea    0x6a2(%rip),%rdi
jmp    1e6f <main+0xbff>
lea    0x57f(%rip),%rdi
call   1150 <perror@plt>
mov    $0x1,%eax
jmp    1350 <main+0xe0>

LLVM IR (-O0):
@.str = [57 x i8] c"\0ALSConv 1.1.0: log sweep and inverse filter convolution.\00"
@.str.1 = [39 x i8] c"Copyright (C) 2002-2011 Denis Sbragion\00"
@.str.2 = [44 x i8] c"\0ACompiled with single precision arithmetic.\00"
@.str.3 = [61 x i8] c"\0AThis program may be freely redistributed under the terms of\00"
@.str.4 = [63 x i8] c"the GNU GPL and is provided to you as is, without any warranty\00"
@.str.5 = [57 x i8] c"of any kind. Please read the file \22COPYING\22 for details.\00"
@.str.6 = [74 x i8] c"\0AUsage: LSConv sweepfile inversefile outfile [refsweep mingain [dlstart]]\00"
@.str.7 = [14 x i8] c"\0AParameters:\0A\00"
@.str.8 = [29 x i8] c" sweepfile: sweep file name\00"
@.str.9 = [39 x i8] c" inversefile: inverse sweep file name\00"
@.str.10 = [40 x i8] c" outfile: output impulse response file\00"
@.str.11 = [46 x i8] c" refsweep: reference channel sweep file name\00"
@.str.12 = [52 x i8] c" mingain: min gain for reference channel inversion\00"
@.str.13 = [62 x i8] c" dlstart: dip limiting start for reference channel inversion\00"
@.str.14 = [75 x i8] c"\0AExample: lsconv sweep.pcm inverse.pcm impulse.pcm refchannel.pcm 0.1 0.8\0A\00"
@.str.15 = [23 x i8] c"\0ACommand line parsing.\00"
@.str.16 = [32 x i8] c"Convolution length computation.\00"
@.str.17 = [31 x i8] c"Convolution arrays allocation.\00"
@.str.18 = [27 x i8] c"Memory allocation failure.\00"
@.str.19 = [23 x i8] c"Reading inverse file: \00"
@.str.20 = [3 x i8] c"rb\00"
@.str.21 = [28 x i8] c"Unable to open inverse file\00"
@.str.22 = [22 x i8] c"Inverse filter FFT...\00"
@.str.23 = [25 x i8] c"Reading reference file: \00"
@.str.24 = [30 x i8] c"Unable to open reference file\00"
@.str.25 = [39 x i8] c"Reference inversion and convolution...\00"
@.str.26 = [21 x i8] c"Reading sweep file: \00"
@.str.27 = [26 x i8] c"Unable to open sweep file\00"
@.str.28 = [33 x i8] c"Sweep and inverse convolution...\00"
@.str.29 = [39 x i8] c"Finding impulse response peak value...\00"
@.str.30 = [19 x i8] c"Peak position: %d\0A\00"
@.str.31 = [24 x i8] c"Peak value: %f (%f dB)\0A\00"
@.str.32 = [26 x i8] c"Peak value: %f (-inf dB)\0A\00"
@stdout = global i32 0
@.str.33 = [22 x i8] c"Writing output file: \00"
@.str.34 = [3 x i8] c"wb\00"
@.str.35 = [27 x i8] c"Unable to open output file\00"
@.str.36 = [11 x i8] c"Completed.\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca float
%11 = alloca float
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca float*
%20 = alloca float*
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca i32
%30 = alloca float
%31 = alloca i32*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%32 = call i32 @sputs(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
%33 = call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
%34 = call i32 @sputs(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%35 = call i32 @sputs(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.3, i64 0, i64 0))
%36 = call i32 @sputs(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.4, i64 0, i64 0))
%37 = call i32 @sputs(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.5, i64 0, i64 0))
%38 = load i32, i32* %4
%39 = icmp slt i32 %38, 4
br i1 %39, label %46, label %40
40: ; preds = %2
%41 = load i32, i32* %4
%42 = icmp sgt i32 %41, 4
br i1 %42, label %43, label %56
43: ; preds = %40
%44 = load i32, i32* %4
%45 = icmp slt i32 %44, 6
br i1 %45, label %46, label %56
46: ; preds = %43, %2
%47 = call i32 @sputs(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.6, i64 0, i64 0))
%48 = call i32 @sputs(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i64 0, i64 0))
%49 = call i32 @sputs(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.8, i64 0, i64 0))
%50 = call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.9, i64 0, i64 0))
%51 = call i32 @sputs(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.10, i64 0, i64 0))
%52 = call i32 @sputs(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.11, i64 0, i64 0))
%53 = call i32 @sputs(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.12, i64 0, i64 0))
%54 = call i32 @sputs(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.13, i64 0, i64 0))
%55 = call i32 @sputs(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.14, i64 0, i64 0))
store i32 0, i32* %3
br label %764
56: ; preds = %43, %40
%57 = call i32 @sputs(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.15, i64 0, i64 0))
%58 = load i8**, i8*** %5
%59 = getelementptr inbounds i8*, i8** %58, i64 1
%60 = load i8*, i8** %59
store i8* %60, i8** %6
%61 = load i8**, i8*** %5
%62 = getelementptr inbounds i8*, i8** %61, i64 2
%63 = load i8*, i8** %62
store i8* %63, i8** %7
%64 = load i8**, i8*** %5
%65 = getelementptr inbounds i8*, i8** %64, i64 3
%66 = load i8*, i8** %65
store i8* %66, i8** %8
%67 = load i32, i32* %4
%68 = icmp sgt i32 %67, 4
br i1 %68, label %69, label %78
69: ; preds = %56
%70 = load i8**, i8*** %5
%71 = getelementptr inbounds i8*, i8** %70, i64 4
%72 = load i8*, i8** %71
store i8* %72, i8** %9
%73 = load i8**, i8*** %5
%74 = getelementptr inbounds i8*, i8** %73, i64 5
%75 = load i8*, i8** %74
%76 = call i64 @atof(i8* %75)
%77 = sitofp i64 %76 to float
store float %77, float* %10
br label %79
78: ; preds = %56
store i8* null, i8** %9
br label %79
79: ; preds = %78, %69
%80 = load i32, i32* %4
%81 = icmp sge i32 %80, 7
br i1 %81, label %82, label %88
82: ; preds = %79
%83 = load i8**, i8*** %5
%84 = getelementptr inbounds i8*, i8** %83, i64 6
%85 = load i8*, i8** %84
%86 = call i64 @atof(i8* %85)
%87 = sitofp i64 %86 to float
store float %87, float* %11
br label %89
88: ; preds = %79
store float 2.000000e+00, float* %11
br label %89
89: ; preds = %88, %82
%90 = call i32 @sputs(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.16, i64 0, i64 0))
%91 = load i8*, i8** %6
%92 = call i32 @FSize(i8* %91)
%93 = sext i32 %92 to i64
%94 = udiv i64 %93, 4
%95 = trunc i64 %94 to i32
store i32 %95, i32* %12
%96 = load i8*, i8** %7
%97 = call i32 @FSize(i8* %96)
%98 = sext i32 %97 to i64
%99 = udiv i64 %98, 4
%100 = trunc i64 %99 to i32
store i32 %100, i32* %13
%101 = load i8*, i8** %9
%102 = icmp ne i8* %101, null
br i1 %102, label %103, label %109
103: ; preds = %89
%104 = load i8*, i8** %9
%105 = call i32 @FSize(i8* %104)
%106 = sext i32 %105 to i64
%107 = udiv i64 %106, 4
%108 = trunc i64 %107 to i32
store i32 %108, i32* %14
br label %110
109: ; preds = %89
store i32 1, i32* %14
br label %110
110: ; preds = %109, %103
%111 = load i32, i32* %12
%112 = load i32, i32* %13
%113 = add nsw i32 %111, %112
%114 = load i32, i32* %14
%115 = add nsw i32 %113, %114
%116 = sub nsw i32 %115, 2
store i32 %116, i32* %16
store i32 1, i32* %15
br label %117
117: ; preds = %122, %110
%118 = load i32, i32* %15
%119 = load i32, i32* %16
%120 = icmp slt i32 %118, %119
br i1 %120, label %121, label %125
121: ; preds = %117
br label %122
122: ; preds = %121
%123 = load i32, i32* %15
%124 = shl i32 %123, 1
store i32 %124, i32* %15
br label %117
125: ; preds = %117
%126 = call i32 @sputs(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
%127 = load i32, i32* %15
%128 = sext i32 %127 to i64
%129 = mul i64 4, %128
%130 = trunc i64 %129 to i32
%131 = call i64 @malloc(i32 %130)
%132 = inttoptr i64 %131 to float*
store float* %132, float** %19
%133 = icmp eq float* %132, null
br i1 %133, label %134, label %136
134: ; preds = %125
%135 = call i32 @sputs(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.18, i64 0, i64 0))
store i32 1, i32* %3
br label %764
136: ; preds = %125
%137 = load i32, i32* %15
%138 = sext i32 %137 to i64
%139 = mul i64 4, %138
%140 = trunc i64 %139 to i32
%141 = call i64 @malloc(i32 %140)
%142 = inttoptr i64 %141 to float*
store float* %142, float** %20
%143 = icmp eq float* %142, null
br i1 %143, label %144, label %148
144: ; preds = %136
%145 = call i32 @sputs(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.18, i64 0, i64 0))
%146 = load float*, float** %19
%147 = call i32 @free(float* %146)
store i32 1, i32* %3
br label %764
148: ; preds = %136
%149 = load i8*, i8** %7
%150 = call i32 @sputsp(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.19, i64 0, i64 0), i8* %149)
%151 = load i8*, i8** %7
%152 = call i32* @fopen(i8* %151, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
store i32* %152, i32** %31
%153 = icmp eq i32* %152, null
br i1 %153, label %154, label %156
154: ; preds = %148
%155 = call i32 @perror(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.21, i64 0, i64 0))
store i32 1, i32* %3
br label %764
156: ; preds = %148
store i32 0, i32* %17
br label %157
157: ; preds = %169, %156
%158 = load i32, i32* %17
%159 = load i32, i32* %13
%160 = icmp slt i32 %158, %159
br i1 %160, label %161, label %172
161: ; preds = %157
%162 = load i32*, i32** %31
%163 = call i32 @fread(float* %21, i32 4, i32 1, i32* %162)
%164 = load float, float* %21
%165 = load float*, float** %20
%166 = load i32, i32* %17
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float, float* %165, i64 %167
store float %164, float* %168
br label %169
169: ; preds = %161
%170 = load i32, i32* %17
%171 = add nsw i32 %170, 1
store i32 %171, i32* %17
br label %157
172: ; preds = %157
%173 = load i32, i32* %13
store i32 %173, i32* %17
br label %174
174: ; preds = %183, %172
%175 = load i32, i32* %17
%176 = load i32, i32* %15
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %186
178: ; preds = %174
%179 = load float*, float** %20
%180 = load i32, i32* %17
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
store float 0.000000e+00, float* %182
br label %183
183: ; preds = %178
%184 = load i32, i32* %17
%185 = add nsw i32 %184, 1
store i32 %185, i32* %17
br label %174
186: ; preds = %174
%187 = load i32*, i32** %31
%188 = call i32 @fclose(i32* %187)
%189 = call i32 @sputs(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.22, i64 0, i64 0))
%190 = load i32, i32* %15
%191 = load float*, float** %20
%192 = call i32 @rdft(i32 %190, i32 1, float* %191)
%193 = load i8*, i8** %9
%194 = icmp ne i8* %193, null
br i1 %194, label %195, label %612
195: ; preds = %186
%196 = load i8*, i8** %9
%197 = call i32 @sputsp(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.23, i64 0, i64 0), i8* %196)
%198 = load i8*, i8** %9
%199 = call i32* @fopen(i8* %198, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
store i32* %199, i32** %31
%200 = icmp eq i32* %199, null
br i1 %200, label %201, label %203
201: ; preds = %195
%202 = call i32 @perror(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.24, i64 0, i64 0))
store i32 1, i32* %3
br label %764
203: ; preds = %195
store i32 0, i32* %17
br label %204
204: ; preds = %213, %203
%205 = load i32, i32* %17
%206 = load i32, i32* %15
%207 = icmp slt i32 %205, %206
br i1 %207, label %208, label %216
208: ; preds = %204
%209 = load float*, float** %19
%210 = load i32, i32* %17
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %209, i64 %211
store float 0.000000e+00, float* %212
br label %213
213: ; preds = %208
%214 = load i32, i32* %17
%215 = add nsw i32 %214, 1
store i32 %215, i32* %17
br label %204
216: ; preds = %204
%217 = load i32, i32* %15
%218 = load i32, i32* %13
%219 = sub nsw i32 %217, %218
store i32 %219, i32* %17
store i32 0, i32* %18
br label %220
220: ; preds = %234, %216
%221 = load i32, i32* %18
%222 = load i32, i32* %14
%223 = icmp slt i32 %221, %222
br i1 %223, label %224, label %239
224: ; preds = %220
%225 = load i32*, i32** %31
%226 = call i32 @fread(float* %21, i32 4, i32 1, i32* %225)
%227 = load float, float* %21
%228 = load float*, float** %19
%229 = load i32, i32* %17
%230 = load i32, i32* %15
%231 = srem i32 %229, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %228, i64 %232
store float %227, float* %233
br label %234
234: ; preds = %224
%235 = load i32, i32* %17
%236 = add nsw i32 %235, 1
store i32 %236, i32* %17
%237 = load i32, i32* %18
%238 = add nsw i32 %237, 1
store i32 %238, i32* %18
br label %220
239: ; preds = %220
%240 = load i32*, i32** %31
%241 = call i32 @fclose(i32* %240)
%242 = call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.25, i64 0, i64 0))
%243 = load i32, i32* %15
%244 = load float*, float** %19
%245 = call i32 @rdft(i32 %243, i32 1, float* %244)
%246 = load float*, float** %19
%247 = load float*, float** %20
%248 = load i32, i32* %15
%249 = call i32 @hcconvolve(float* %246, float* %247, i32 %248)
%250 = load float*, float** %19
%251 = getelementptr inbounds float, float* %250, i64 0
%252 = load float, float* %251
%253 = load float*, float** %19
%254 = getelementptr inbounds float, float* %253, i64 0
%255 = load float, float* %254
%256 = fmul float %252, %255
store float %256, float* %22
store i32 2, i32* %17
store i32 3, i32* %18
br label %257
257: ; preds = %286, %239
%258 = load i32, i32* %17
%259 = load i32, i32* %15
%260 = icmp slt i32 %258, %259
br i1 %260, label %261, label %291
261: ; preds = %257
%262 = load float*, float** %19
%263 = load i32, i32* %17
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds float, float* %262, i64 %264
%266 = load float, float* %265
%267 = load float*, float** %19
%268 = load i32, i32* %17
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds float, float* %267, i64 %269
%271 = load float, float* %270
%272 = load float*, float** %19
%273 = load i32, i32* %18
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds float, float* %272, i64 %274
%276 = load float, float* %275
%277 = load float*, float** %19
%278 = load i32, i32* %18
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %277, i64 %279
%281 = load float, float* %280
%282 = fmul float %276, %281
%283 = call float @llvm.fmuladd.f32(float %266, float %271, float %282)
%284 = load float, float* %22
%285 = fadd float %284, %283
store float %285, float* %22
br label %286
286: ; preds = %261
%287 = load i32, i32* %17
%288 = add nsw i32 %287, 2
store i32 %288, i32* %17
%289 = load i32, i32* %18
%290 = add nsw i32 %289, 2
store i32 %290, i32* %18
br label %257
291: ; preds = %257
%292 = load float, float* %22
%293 = fpext float %292 to double
%294 = fmul double 2.000000e+00, %293
%295 = load i32, i32* %15
%296 = sitofp i32 %295 to double
%297 = fdiv double %294, %296
%298 = call i64 @sqrt(double %297)
%299 = sitofp i64 %298 to float
store float %299, float* %22
%300 = load float, float* %10
%301 = load float, float* %22
%302 = fmul float %300, %301
store float %302, float* %23
%303 = load float, float* %11
%304 = fcmp oge float %303, 1.000000e+00
br i1 %304, label %305, label %424
305: ; preds = %291
%306 = load float*, float** %19
%307 = getelementptr inbounds float, float* %306, i64 0
%308 = load float, float* %307
%309 = load float, float* %23
%310 = fcmp olt float %308, %309
br i1 %310, label %311, label %316
311: ; preds = %305
%312 = load float, float* %23
%313 = fdiv float 1.000000e+00, %312
%314 = load float*, float** %19
%315 = getelementptr inbounds float, float* %314, i64 0
store float %313, float* %315
br label %323
316: ; preds = %305
%317 = load float*, float** %19
%318 = getelementptr inbounds float, float* %317, i64 0
%319 = load float, float* %318
%320 = fdiv float 1.000000e+00, %319
%321 = load float*, float** %19
%322 = getelementptr inbounds float, float* %321, i64 0
store float %320, float* %322
br label %323
323: ; preds = %316, %311
%324 = load float*, float** %19
%325 = getelementptr inbounds float, float* %324, i64 1
%326 = load float, float* %325
%327 = load float, float* %23
%328 = fcmp olt float %326, %327
br i1 %328, label %329, label %334
329: ; preds = %323
%330 = load float, float* %23
%331 = fdiv float 1.000000e+00, %330
%332 = load float*, float** %19
%333 = getelementptr inbounds float, float* %332, i64 1
store float %331, float* %333
br label %341
334: ; preds = %323
%335 = load float*, float** %19
%336 = getelementptr inbounds float, float* %335, i64 1
%337 = load float, float* %336
%338 = fdiv float 1.000000e+00, %337
%339 = load float*, float** %19
%340 = getelementptr inbounds float, float* %339, i64 1
store float %338, float* %340
br label %341
341: ; preds = %334, %329
store i32 2, i32* %17
store i32 3, i32* %18
br label %342
342: ; preds = %418, %341
%343 = load i32, i32* %17
%344 = load i32, i32* %15
%345 = icmp slt i32 %343, %344
br i1 %345, label %346, label %423
346: ; preds = %342
%347 = load float*, float** %19
%348 = load i32, i32* %17
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds float, float* %347, i64 %349
%351 = load float, float* %350
%352 = load float*, float** %19
%353 = load i32, i32* %18
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds float, float* %352, i64 %354
%356 = load float, float* %355
%357 = call i64 @hypot(float %351, float %356)
%358 = sitofp i64 %357 to float
store float %358, float* %27
%359 = load float, float* %27
%360 = load float, float* %23
%361 = fcmp olt float %359, %360
br i1 %361, label %362, label %397
362: ; preds = %346
%363 = load float*, float** %19
%364 = load i32, i32* %18
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds float, float* %363, i64 %365
%367 = load float, float* %366
%368 = load float*, float** %19
%369 = load i32, i32* %17
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float, float* %368, i64 %370
%372 = load float, float* %371
%373 = call i64 @atan2(float %367, float %372)
%374 = sitofp i64 %373 to float
store float %374, float* %28
%375 = load float, float* %23
%376 = fdiv float 1.000000e+00, %375
store float %376, float* %27
%377 = load float, float* %27
%378 = load float, float* %28
%379 = fneg float %378
%380 = call i64 @cos(float %379)
%381 = sitofp i64 %380 to float
%382 = fmul float %377, %381
%383 = load float*, float** %19
%384 = load i32, i32* %17
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds float, float* %383, i64 %385
store float %382, float* %386
%387 = load float, float* %27
%388 = load float, float* %28
%389 = fneg float %388
%390 = call i64 @sin(float %389)
%391 = sitofp i64 %390 to float
%392 = fmul float %387, %391
%393 = load float*, float** %19
%394 = load i32, i32* %18
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds float, float* %393, i64 %395
store float %392, float* %396
br label %417
397: ; preds = %346
%398 = load float, float* %27
%399 = load float, float* %27
%400 = fmul float %398, %399
%401 = fdiv float 1.000000e+00, %400
store float %401, float* %27
%402 = load float, float* %27
%403 = load float*, float** %19
%404 = load i32, i32* %17
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %403, i64 %405
%407 = load float, float* %406
%408 = fmul float %407, %402
store float %408, float* %406
%409 = load float, float* %27
%410 = fneg float %409
%411 = load float*, float** %19
%412 = load i32, i32* %18
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds float, float* %411, i64 %413
%415 = load float, float* %414
%416 = fmul float %415, %410
store float %416, float* %414
br label %417
417: ; preds = %397, %362
br label %418
418: ; preds = %417
%419 = load i32, i32* %17
%420 = add nsw i32 %419, 2
store i32 %420, i32* %17
%421 = load i32, i32* %18
%422 = add nsw i32 %421, 2
store i32 %422, i32* %18
br label %342
423: ; preds = %342
br label %607
424: ; preds = %291
%425 = load float, float* %23
%426 = load float, float* %11
%427 = fdiv float %425, %426
store float %427, float* %24
%428 = load float, float* %24
%429 = load float, float* %23
%430 = fsub float %428, %429
store float %430, float* %26
%431 = load float*, float** %19
%432 = getelementptr inbounds float, float* %431, i64 0
%433 = load float, float* %432
%434 = load float, float* %24
%435 = fcmp olt float %433, %434
br i1 %435, label %436, label %456
436: ; preds = %424
%437 = load float, float* %24
%438 = load float*, float** %19
%439 = getelementptr inbounds float, float* %438, i64 0
%440 = load float, float* %439
%441 = fsub float %437, %440
%442 = load float, float* %26
%443 = fdiv float %441, %442
store float %443, float* %25
%444 = load float, float* %25
%445 = load float, float* %25
%446 = fadd float 1.000000e+00, %445
%447 = fdiv float %444, %446
store float %447, float* %25
%448 = load float, float* %24
%449 = load float, float* %26
%450 = load float, float* %25
%451 = fneg float %449
%452 = call float @llvm.fmuladd.f32(float %451, float %450, float %448)
%453 = fdiv float 1.000000e+00, %452
%454 = load float*, float** %19
%455 = getelementptr inbounds float, float* %454, i64 0
store float %453, float* %455
br label %463
456: ; preds = %424
%457 = load float*, float** %19
%458 = getelementptr inbounds float, float* %457, i64 0
%459 = load float, float* %458
%460 = fdiv float 1.000000e+00, %459
%461 = load float*, float** %19
%462 = getelementptr inbounds float, float* %461, i64 0
store float %460, float* %462
br label %463
463: ; preds = %456, %436
%464 = load float*, float** %19
%465 = getelementptr inbounds float, float* %464, i64 1
%466 = load float, float* %465
%467 = load float, float* %24
%468 = fcmp olt float %466, %467
br i1 %468, label %469, label %489
469: ; preds = %463
%470 = load float, float* %24
%471 = load float*, float** %19
%472 = getelementptr inbounds float, float* %471, i64 1
%473 = load float, float* %472
%474 = fsub float %470, %473
%475 = load float, float* %26
%476 = fdiv float %474, %475
store float %476, float* %25
%477 = load float, float* %25
%478 = load float, float* %25
%479 = fadd float 1.000000e+00, %478
%480 = fdiv float %477, %479
store float %480, float* %25
%481 = load float, float* %24
%482 = load float, float* %26
%483 = load float, float* %25
%484 = fneg float %482
%485 = call float @llvm.fmuladd.f32(float %484, float %483, float %481)
%486 = fdiv float 1.000000e+00, %485
%487 = load float*, float** %19
%488 = getelementptr inbounds float, float* %487, i64 1
store float %486, float* %488
br label %496
489: ; preds = %463
%490 = load float*, float** %19
%491 = getelementptr inbounds float, float* %490, i64 1
%492 = load float, float* %491
%493 = fdiv float 1.000000e+00, %492
%494 = load float*, float** %19
%495 = getelementptr inbounds float, float* %494, i64 1
store float %493, float* %495
br label %496
496: ; preds = %489, %469
store i32 2, i32* %17
store i32 3, i32* %18
br label %497
497: ; preds = %601, %496
%498 = load i32, i32* %17
%499 = load i32, i32* %15
%500 = icmp slt i32 %498, %499
br i1 %500, label %501, label %606
501: ; preds = %497
%502 = load float*, float** %19
%503 = load i32, i32* %17
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds float, float* %502, i64 %504
%506 = load float, float* %505
%507 = load float*, float** %19
%508 = load i32, i32* %18
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds float, float* %507, i64 %509
%511 = load float, float* %510
%512 = call i64 @hypot(float %506, float %511)
%513 = sitofp i64 %512 to float
store float %513, float* %27
%514 = load float, float* %27
%515 = fcmp ole float %514, 0.000000e+00
br i1 %515, label %516, label %527
516: ; preds = %501
%517 = load float, float* %23
%518 = fdiv float 1.000000e+00, %517
%519 = load float*, float** %19
%520 = load i32, i32* %17
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds float, float* %519, i64 %521
store float %518, float* %522
%523 = load float*, float** %19
%524 = load i32, i32* %18
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds float, float* %523, i64 %525
store float 0.000000e+00, float* %526
br label %600
527: ; preds = %501
%528 = load float, float* %27
%529 = load float, float* %24
%530 = fcmp olt float %528, %529
br i1 %530, label %531, label %579
531: ; preds = %527
%532 = load float, float* %24
%533 = load float, float* %27
%534 = fsub float %532, %533
%535 = load float, float* %26
%536 = fdiv float %534, %535
store float %536, float* %25
%537 = load float, float* %25
%538 = load float, float* %25
%539 = fadd float 1.000000e+00, %538
%540 = fdiv float %537, %539
store float %540, float* %25
%541 = load float, float* %24
%542 = load float, float* %26
%543 = load float, float* %25
%544 = fneg float %542
%545 = call float @llvm.fmuladd.f32(float %544, float %543, float %541)
%546 = fdiv float 1.000000e+00, %545
store float %546, float* %27
%547 = load float*, float** %19
%548 = load i32, i32* %18
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds float, float* %547, i64 %549
%551 = load float, float* %550
%552 = load float*, float** %19
%553 = load i32, i32* %17
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds float, float* %552, i64 %554
%556 = load float, float* %555
%557 = call i64 @atan2(float %551, float %556)
%558 = sitofp i64 %557 to float
store float %558, float* %28
%559 = load float, float* %27
%560 = load float, float* %28
%561 = fneg float %560
%562 = call i64 @cos(float %561)
%563 = sitofp i64 %562 to float
%564 = fmul float %559, %563
%565 = load float*, float** %19
%566 = load i32, i32* %17
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds float, float* %565, i64 %567
store float %564, float* %568
%569 = load float, float* %27
%570 = load float, float* %28
%571 = fneg float %570
%572 = call i64 @sin(float %571)
%573 = sitofp i64 %572 to float
%574 = fmul float %569, %573
%575 = load float*, float** %19
%576 = load i32, i32* %18
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds float, float* %575, i64 %577
store float %574, float* %578
br label %599
579: ; preds = %527
%580 = load float, float* %27
%581 = load float, float* %27
%582 = fmul float %580, %581
%583 = fdiv float 1.000000e+00, %582
store float %583, float* %27
%584 = load float, float* %27
%585 = load float*, float** %19
%586 = load i32, i32* %17
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds float, float* %585, i64 %587
%589 = load float, float* %588
%590 = fmul float %589, %584
store float %590, float* %588
%591 = load float, float* %27
%592 = fneg float %591
%593 = load float*, float** %19
%594 = load i32, i32* %18
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds float, float* %593, i64 %595
%597 = load float, float* %596
%598 = fmul float %597, %592
store float %598, float* %596
br label %599
599: ; preds = %579, %531
br label %600
600: ; preds = %599, %516
br label %601
601: ; preds = %600
%602 = load i32, i32* %17
%603 = add nsw i32 %602, 2
store i32 %603, i32* %17
%604 = load i32, i32* %18
%605 = add nsw i32 %604, 2
store i32 %605, i32* %18
br label %497
606: ; preds = %497
br label %607
607: ; preds = %606, %423
%608 = load float*, float** %20
%609 = load float*, float** %19
%610 = load i32, i32* %15
%611 = call i32 @hcconvolve(float* %608, float* %609, i32 %610)
br label %612
612: ; preds = %607, %186
%613 = load i8*, i8** %6
%614 = call i32 @sputsp(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.26, i64 0, i64 0), i8* %613)
%615 = load i8*, i8** %6
%616 = call i32* @fopen(i8* %615, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
store i32* %616, i32** %31
%617 = icmp eq i32* %616, null
br i1 %617, label %618, label %620
618: ; preds = %612
%619 = call i32 @perror(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.27, i64 0, i64 0))
store i32 1, i32* %3
br label %764
620: ; preds = %612
store i32 0, i32* %17
br label %621
621: ; preds = %633, %620
%622 = load i32, i32* %17
%623 = load i32, i32* %12
%624 = icmp slt i32 %622, %623
br i1 %624, label %625, label %636
625: ; preds = %621
%626 = load i32*, i32** %31
%627 = call i32 @fread(float* %21, i32 4, i32 1, i32* %626)
%628 = load float, float* %21
%629 = load float*, float** %19
%630 = load i32, i32* %17
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds float, float* %629, i64 %631
store float %628, float* %632
br label %633
633: ; preds = %625
%634 = load i32, i32* %17
%635 = add nsw i32 %634, 1
store i32 %635, i32* %17
br label %621
636: ; preds = %621
%637 = load i32*, i32** %31
%638 = call i32 @fclose(i32* %637)
%639 = load i32, i32* %12
store i32 %639, i32* %17
br label %640
640: ; preds = %649, %636
%641 = load i32, i32* %17
%642 = load i32, i32* %15
%643 = icmp slt i32 %641, %642
br i1 %643, label %644, label %652
644: ; preds = %640
%645 = load float*, float** %19
%646 = load i32, i32* %17
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds float, float* %645, i64 %647
store float 0.000000e+00, float* %648
br label %649
649: ; preds = %644
%650 = load i32, i32* %17
%651 = add nsw i32 %650, 1
store i32 %651, i32* %17
br label %640
652: ; preds = %640
%653 = call i32 @sputs(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.28, i64 0, i64 0))
%654 = load i32, i32* %15
%655 = load float*, float** %19
%656 = call i32 @rdft(i32 %654, i32 1, float* %655)
%657 = load float*, float** %19
%658 = load float*, float** %20
%659 = load i32, i32* %15
%660 = call i32 @hcconvolve(float* %657, float* %658, i32 %659)
%661 = load i32, i32* %15
%662 = load float*, float** %19
%663 = call i32 @rdft(i32 %661, i32 -1, float* %662)
store i32 0, i32* %17
br label %664
664: ; preds = %679, %652
%665 = load i32, i32* %17
%666 = load i32, i32* %15
%667 = icmp slt i32 %665, %666
br i1 %667, label %668, label %682
668: ; preds = %664
%669 = load i32, i32* %15
%670 = sitofp i32 %669 to double
%671 = fdiv double 2.000000e+00, %670
%672 = fptrunc double %671 to float
%673 = load float*, float** %19
%674 = load i32, i32* %17
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds float, float* %673, i64 %675
%677 = load float, float* %676
%678 = fmul float %677, %672
store float %678, float* %676
br label %679
679: ; preds = %668
%680 = load i32, i32* %17
%681 = add nsw i32 %680, 1
store i32 %681, i32* %17
br label %664
682: ; preds = %664
%683 = call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.29, i64 0, i64 0))
store i32 0, i32* %29
store float 0.000000e+00, float* %30
store i32 0, i32* %17
br label %684
684: ; preds = %708, %682
%685 = load i32, i32* %17
%686 = load i32, i32* %15
%687 = icmp slt i32 %685, %686
br i1 %687, label %688, label %711
688: ; preds = %684
%689 = load float*, float** %19
%690 = load i32, i32* %17
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds float, float* %689, i64 %691
%693 = load float, float* %692
%694 = call i64 @fabs(float %693)
%695 = sitofp i64 %694 to float
%696 = load float, float* %30
%697 = fcmp ogt float %695, %696
br i1 %697, label %698, label %707
698: ; preds = %688
%699 = load i32, i32* %17
store i32 %699, i32* %29
%700 = load float*, float** %19
%701 = load i32, i32* %17
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds float, float* %700, i64 %702
%704 = load float, float* %703
%705 = call i64 @fabs(float %704)
%706 = sitofp i64 %705 to float
store float %706, float* %30
br label %707
707: ; preds = %698, %688
br label %708
708: ; preds = %707
%709 = load i32, i32* %17
%710 = add nsw i32 %709, 1
store i32 %710, i32* %17
br label %684
711: ; preds = %684
%712 = load i32, i32* %29
%713 = sitofp i32 %712 to double
%714 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.30, i64 0, i64 0), double %713)
%715 = load float, float* %30
%716 = fcmp ogt float %715, 0.000000e+00
br i1 %716, label %717, label %726
717: ; preds = %711
%718 = load float, float* %30
%719 = fpext float %718 to double
%720 = load float, float* %30
%721 = fpext float %720 to double
%722 = call i32 @log10(double %721)
%723 = mul nsw i32 20, %722
%724 = sitofp i32 %723 to double
%725 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.31, i64 0, i64 0), double %719, double %724)
br label %730
726: ; preds = %711
%727 = load float, float* %30
%728 = fpext float %727 to double
%729 = call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.32, i64 0, i64 0), double %728)
br label %730
730: ; preds = %726, %717
%731 = load i32, i32* @stdout
%732 = call i32 @fflush(i32 %731)
%733 = load i8*, i8** %8
%734 = call i32 @sputsp(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.33, i64 0, i64 0), i8* %733)
%735 = load i8*, i8** %8
%736 = call i32* @fopen(i8* %735, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.34, i64 0, i64 0))
store i32* %736, i32** %31
%737 = icmp eq i32* %736, null
br i1 %737, label %738, label %740
738: ; preds = %730
%739 = call i32 @perror(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.35, i64 0, i64 0))
store i32 1, i32* %3
br label %764
740: ; preds = %730
store i32 0, i32* %17
br label %741
741: ; preds = %753, %740
%742 = load i32, i32* %17
%743 = load i32, i32* %16
%744 = icmp slt i32 %742, %743
br i1 %744, label %745, label %756
745: ; preds = %741
%746 = load float*, float** %19
%747 = load i32, i32* %17
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds float, float* %746, i64 %748
%750 = load float, float* %749
store float %750, float* %21
%751 = load i32*, i32** %31
%752 = call i32 @fwrite(float* %21, i32 4, i32 1, i32* %751)
br label %753
753: ; preds = %745
%754 = load i32, i32* %17
%755 = add nsw i32 %754, 1
store i32 %755, i32* %17
br label %741
756: ; preds = %741
%757 = load i32*, i32** %31
%758 = call i32 @fclose(i32* %757)
%759 = load float*, float** %19
%760 = call i32 @free(float* %759)
%761 = load float*, float** %20
%762 = call i32 @free(float* %761)
%763 = call i32 @sputs(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %3
br label %764
764: ; preds = %756, %738, %618, %201, %154, %144, %134, %46
%765 = load i32, i32* %3
ret i32 %765
}

LLVM IR (-O2):
@.str = [57 x i8] c"\0ALSConv 1.1.0: log sweep and inverse filter convolution.\00"
@.str.1 = [39 x i8] c"Copyright (C) 2002-2011 Denis Sbragion\00"
@.str.2 = [44 x i8] c"\0ACompiled with single precision arithmetic.\00"
@.str.3 = [61 x i8] c"\0AThis program may be freely redistributed under the terms of\00"
@.str.4 = [63 x i8] c"the GNU GPL and is provided to you as is, without any warranty\00"
@.str.5 = [57 x i8] c"of any kind. Please read the file \22COPYING\22 for details.\00"
@.str.6 = [74 x i8] c"\0AUsage: LSConv sweepfile inversefile outfile [refsweep mingain [dlstart]]\00"
@.str.7 = [14 x i8] c"\0AParameters:\0A\00"
@.str.8 = [29 x i8] c" sweepfile: sweep file name\00"
@.str.9 = [39 x i8] c" inversefile: inverse sweep file name\00"
@.str.10 = [40 x i8] c" outfile: output impulse response file\00"
@.str.11 = [46 x i8] c" refsweep: reference channel sweep file name\00"
@.str.12 = [52 x i8] c" mingain: min gain for reference channel inversion\00"
@.str.13 = [62 x i8] c" dlstart: dip limiting start for reference channel inversion\00"
@.str.14 = [75 x i8] c"\0AExample: lsconv sweep.pcm inverse.pcm impulse.pcm refchannel.pcm 0.1 0.8\0A\00"
@.str.15 = [23 x i8] c"\0ACommand line parsing.\00"
@.str.16 = [32 x i8] c"Convolution length computation.\00"
@.str.17 = [31 x i8] c"Convolution arrays allocation.\00"
@.str.18 = [27 x i8] c"Memory allocation failure.\00"
@.str.19 = [23 x i8] c"Reading inverse file: \00"
@.str.20 = [3 x i8] c"rb\00"
@.str.21 = [28 x i8] c"Unable to open inverse file\00"
@.str.22 = [22 x i8] c"Inverse filter FFT...\00"
@.str.23 = [25 x i8] c"Reading reference file: \00"
@.str.24 = [30 x i8] c"Unable to open reference file\00"
@.str.25 = [39 x i8] c"Reference inversion and convolution...\00"
@.str.26 = [21 x i8] c"Reading sweep file: \00"
@.str.27 = [26 x i8] c"Unable to open sweep file\00"
@.str.28 = [33 x i8] c"Sweep and inverse convolution...\00"
@.str.29 = [39 x i8] c"Finding impulse response peak value...\00"
@.str.30 = [19 x i8] c"Peak position: %d\0A\00"
@.str.31 = [24 x i8] c"Peak value: %f (%f dB)\0A\00"
@.str.32 = [26 x i8] c"Peak value: %f (-inf dB)\0A\00"
@stdout = global i32 0
@.str.33 = [22 x i8] c"Writing output file: \00"
@.str.34 = [3 x i8] c"wb\00"
@.str.35 = [27 x i8] c"Unable to open output file\00"
@.str.36 = [11 x i8] c"Completed.\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca float
%4 = bitcast float* %3 to i8*
%5 = tail call i32 @sputs(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
%6 = tail call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
%7 = tail call i32 @sputs(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%8 = tail call i32 @sputs(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.3, i64 0, i64 0))
%9 = tail call i32 @sputs(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.4, i64 0, i64 0))
%10 = tail call i32 @sputs(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.5, i64 0, i64 0))
%11 = icmp slt i32 %0, 4
br i1 %11, label %16, label %12
12: ; preds = %2
%13 = icmp ne i32 %0, 4
%14 = icmp ult i32 %0, 6
%15 = and i1 %13, %14
br i1 %15, label %16, label %26
16: ; preds = %12, %2
%17 = tail call i32 @sputs(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.6, i64 0, i64 0))
%18 = tail call i32 @sputs(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i64 0, i64 0))
%19 = tail call i32 @sputs(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.8, i64 0, i64 0))
%20 = tail call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.9, i64 0, i64 0))
%21 = tail call i32 @sputs(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.10, i64 0, i64 0))
%22 = tail call i32 @sputs(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.11, i64 0, i64 0))
%23 = tail call i32 @sputs(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.12, i64 0, i64 0))
%24 = tail call i32 @sputs(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.13, i64 0, i64 0))
%25 = tail call i32 @sputs(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.14, i64 0, i64 0))
br label %515
26: ; preds = %12
%27 = tail call i32 @sputs(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.15, i64 0, i64 0))
%28 = getelementptr inbounds i8*, i8** %1, i64 1
%29 = load i8*, i8** %28
%30 = getelementptr inbounds i8*, i8** %1, i64 2
%31 = load i8*, i8** %30
%32 = getelementptr inbounds i8*, i8** %1, i64 3
%33 = load i8*, i8** %32
br i1 %13, label %34, label %47
34: ; preds = %26
%35 = getelementptr inbounds i8*, i8** %1, i64 4
%36 = load i8*, i8** %35
%37 = getelementptr inbounds i8*, i8** %1, i64 5
%38 = load i8*, i8** %37
%39 = tail call i64 @atof(i8* %38)
%40 = sitofp i64 %39 to float
%41 = icmp ugt i32 %0, 6
br i1 %41, label %42, label %47
42: ; preds = %34
%43 = getelementptr inbounds i8*, i8** %1, i64 6
%44 = load i8*, i8** %43
%45 = tail call i64 @atof(i8* %44)
%46 = sitofp i64 %45 to float
br label %47
47: ; preds = %26, %34, %42
%48 = phi i8* [ %36, %42 ], [ %36, %34 ], [ null, %26 ]
%49 = phi float [ %40, %42 ], [ %40, %34 ], [ undef, %26 ]
%50 = phi float [ %46, %42 ], [ 2.000000e+00, %34 ], [ 2.000000e+00, %26 ]
%51 = tail call i32 @sputs(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.16, i64 0, i64 0))
%52 = tail call i32 @FSize(i8* %29)
%53 = ashr i32 %52, 2
%54 = tail call i32 @FSize(i8* %31)
%55 = ashr i32 %54, 2
%56 = icmp eq i8* %48, null
br i1 %56, label %60, label %57
57: ; preds = %47
%58 = tail call i32 @FSize(i8* %48)
%59 = ashr i32 %58, 2
br label %60
60: ; preds = %47, %57
%61 = phi i32 [ %59, %57 ], [ 1, %47 ]
%62 = add nsw i32 %53, -2
%63 = add nsw i32 %62, %55
%64 = add nsw i32 %63, %61
br label %65
65: ; preds = %65, %60
%66 = phi i32 [ 1, %60 ], [ %68, %65 ]
%67 = icmp slt i32 %66, %64
%68 = shl i32 %66, 1
br i1 %67, label %65, label %69
69: ; preds = %65
%70 = tail call i32 @sputs(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.17, i64 0, i64 0))
%71 = shl i32 %66, 2
%72 = tail call i64 @malloc(i32 %71)
%73 = inttoptr i64 %72 to float*
%74 = inttoptr i64 %72 to i8*
%75 = icmp eq i64 %72, 0
br i1 %75, label %76, label %78
76: ; preds = %69
%77 = tail call i32 @sputs(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.18, i64 0, i64 0))
br label %515
78: ; preds = %69
%79 = tail call i64 @malloc(i32 %71)
%80 = inttoptr i64 %79 to float*
%81 = icmp eq i64 %79, 0
br i1 %81, label %82, label %85
82: ; preds = %78
%83 = tail call i32 @sputs(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.18, i64 0, i64 0))
%84 = tail call i32 @free(float* %73)
br label %515
85: ; preds = %78
%86 = tail call i32 @sputsp(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.19, i64 0, i64 0), i8* %31)
%87 = tail call i32* @fopen(i8* %31, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
%88 = icmp eq i32* %87, null
br i1 %88, label %94, label %89
89: ; preds = %85
%90 = icmp sgt i32 %54, 3
br i1 %90, label %91, label %96
91: ; preds = %89
%92 = call i32 @llvm.smax.i32(i32 %55, i32 1)
%93 = zext i32 %92 to i64
br label %107
94: ; preds = %85
%95 = tail call i32 @perror(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.21, i64 0, i64 0))
br label %515
96: ; preds = %107, %89
%97 = icmp sgt i32 %66, %55
br i1 %97, label %98, label %114
98: ; preds = %96
%99 = sext i32 %55 to i64
%100 = getelementptr float, float* %80, i64 %99
%101 = bitcast float* %100 to i8*
%102 = xor i32 %55, -1
%103 = add i32 %66, %102
%104 = zext i32 %103 to i64
%105 = shl nuw nsw i64 %104, 2
%106 = add nuw nsw i64 %105, 4
br label %114
107: ; preds = %91, %107
%108 = phi i64 [ 0, %91 ], [ %112, %107 ]
%109 = call i32 @fread(float* %3, i32 4, i32 1, i32* %87)
%110 = load float, float* %3
%111 = getelementptr inbounds float, float* %80, i64 %108
store float %110, float* %111
%112 = add nuw nsw i64 %108, 1
%113 = icmp eq i64 %112, %93
br i1 %113, label %96, label %107
114: ; preds = %98, %96
%115 = tail call i32 @fclose(i32* %87)
%116 = tail call i32 @sputs(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.22, i64 0, i64 0))
%117 = tail call i32 @rdft(i32 %66, i32 1, float* %80)
br i1 %56, label %304, label %118
118: ; preds = %114
%119 = tail call i32 @sputsp(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.23, i64 0, i64 0), i8* %48)
%120 = tail call i32* @fopen(i8* %48, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
%121 = icmp eq i32* %120, null
br i1 %121, label %127, label %122
122: ; preds = %118
%123 = icmp sgt i32 %66, 0
br i1 %123, label %124, label %129
124: ; preds = %122
%125 = zext i32 %66 to i64
%126 = shl nuw nsw i64 %125, 2
br label %129
127: ; preds = %118
%128 = tail call i32 @perror(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.24, i64 0, i64 0))
br label %515
129: ; preds = %124, %122
%130 = icmp sgt i32 %61, 0
br i1 %130, label %131, label %144
131: ; preds = %129
%132 = sub nsw i32 %66, %55
br label %133
133: ; preds = %131, %133
%134 = phi i32 [ %142, %133 ], [ 0, %131 ]
%135 = phi i32 [ %141, %133 ], [ %132, %131 ]
%136 = call i32 @fread(float* %3, i32 4, i32 1, i32* %120)
%137 = load float, float* %3
%138 = srem i32 %135, %66
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds float, float* %73, i64 %139
store float %137, float* %140
%141 = add nsw i32 %135, 1
%142 = add nuw nsw i32 %134, 1
%143 = icmp eq i32 %142, %61
br i1 %143, label %144, label %133
144: ; preds = %133, %129
%145 = tail call i32 @fclose(i32* %120)
%146 = tail call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.25, i64 0, i64 0))
%147 = tail call i32 @rdft(i32 %66, i32 1, float* %73)
%148 = tail call i32 @hcconvolve(float* %73, float* %80, i32 %66)
%149 = load float, float* %73
%150 = fmul float %149, %149
%151 = icmp sgt i32 %66, 2
br i1 %151, label %152, label %168
152: ; preds = %144
%153 = zext i32 %66 to i64
br label %154
154: ; preds = %152, %154
%155 = phi i64 [ 2, %152 ], [ %165, %154 ]
%156 = phi i64 [ 3, %152 ], [ %166, %154 ]
%157 = phi float [ %150, %152 ], [ %164, %154 ]
%158 = getelementptr inbounds float, float* %73, i64 %155
%159 = load float, float* %158
%160 = getelementptr inbounds float, float* %73, i64 %156
%161 = load float, float* %160
%162 = fmul float %161, %161
%163 = tail call float @llvm.fmuladd.f32(float %159, float %159, float %162)
%164 = fadd float %157, %163
%165 = add nuw nsw i64 %155, 2
%166 = add nuw nsw i64 %156, 2
%167 = icmp ult i64 %165, %153
br i1 %167, label %154, label %168
168: ; preds = %154, %144
%169 = phi float [ %150, %144 ], [ %164, %154 ]
%170 = fpext float %169 to double
%171 = fmul double %170, 2.000000e+00
%172 = sitofp i32 %66 to double
%173 = fdiv double %171, %172
%174 = tail call i64 @sqrt(double %173)
%175 = sitofp i64 %174 to float
%176 = fmul float %49, %175
%177 = fcmp ult float %50, 1.000000e+00
br i1 %177, label %226, label %178
178: ; preds = %168
%179 = load float, float* %73
%180 = fcmp olt float %179, %176
%181 = select i1 %180, float %176, float %179
%182 = fdiv float 1.000000e+00, %181
store float %182, float* %73
%183 = getelementptr inbounds float, float* %73, i64 1
%184 = load float, float* %183
%185 = fcmp olt float %184, %176
%186 = select i1 %185, float %176, float %184
%187 = fdiv float 1.000000e+00, %186
store float %187, float* %183
br i1 %151, label %188, label %302
188: ; preds = %178
%189 = fdiv float 1.000000e+00, %176
%190 = zext i32 %66 to i64
br label %191
191: ; preds = %188, %221
%192 = phi i64 [ 2, %188 ], [ %223, %221 ]
%193 = phi i64 [ 3, %188 ], [ %224, %221 ]
%194 = getelementptr inbounds float, float* %73, i64 %192
%195 = load float, float* %194
%196 = getelementptr inbounds float, float* %73, i64 %193
%197 = load float, float* %196
%198 = tail call i64 @hypot(float %195, float %197)
%199 = sitofp i64 %198 to float
%200 = fcmp ogt float %176, %199
br i1 %200, label %201, label %213
201: ; preds = %191
%202 = load float, float* %196
%203 = load float, float* %194
%204 = tail call i64 @atan2(float %202, float %203)
%205 = sitofp i64 %204 to float
%206 = fneg float %205
%207 = tail call i64 @cos(float %206)
%208 = sitofp i64 %207 to float
%209 = fmul float %189, %208
store float %209, float* %194
%210 = tail call i64 @sin(float %206)
%211 = sitofp i64 %210 to float
%212 = fmul float %189, %211
br label %221
213: ; preds = %191
%214 = fmul float %199, %199
%215 = fdiv float 1.000000e+00, %214
%216 = load float, float* %194
%217 = fmul float %215, %216
store float %217, float* %194
%218 = fneg float %215
%219 = load float, float* %196
%220 = fmul float %219, %218
br label %221
221: ; preds = %201, %213
%222 = phi float [ %220, %213 ], [ %212, %201 ]
store float %222, float* %196
%223 = add nuw nsw i64 %192, 2
%224 = add nuw nsw i64 %193, 2
%225 = icmp ult i64 %223, %190
br i1 %225, label %191, label %302
226: ; preds = %168
%227 = fdiv float %176, %50
%228 = fsub float %227, %176
%229 = load float, float* %73
%230 = fcmp olt float %229, %227
br i1 %230, label %231, label %238
231: ; preds = %226
%232 = fsub float %227, %229
%233 = fdiv float %232, %228
%234 = fadd float %233, 1.000000e+00
%235 = fdiv float %233, %234
%236 = fneg float %228
%237 = tail call float @llvm.fmuladd.f32(float %236, float %235, float %227)
br label %238
238: ; preds = %226, %231
%239 = phi float [ %237, %231 ], [ %229, %226 ]
%240 = fdiv float 1.000000e+00, %239
store float %240, float* %73
%241 = getelementptr inbounds float, float* %73, i64 1
%242 = load float, float* %241
%243 = fcmp olt float %242, %227
br i1 %243, label %244, label %251
244: ; preds = %238
%245 = fsub float %227, %242
%246 = fdiv float %245, %228
%247 = fadd float %246, 1.000000e+00
%248 = fdiv float %246, %247
%249 = fneg float %228
%250 = tail call float @llvm.fmuladd.f32(float %249, float %248, float %227)
br label %251
251: ; preds = %238, %244
%252 = phi float [ %250, %244 ], [ %242, %238 ]
%253 = fdiv float 1.000000e+00, %252
store float %253, float* %241
br i1 %151, label %254, label %302
254: ; preds = %251
%255 = fneg float %228
%256 = fdiv float 1.000000e+00, %176
%257 = zext i32 %66 to i64
br label %258
258: ; preds = %254, %297
%259 = phi i64 [ 2, %254 ], [ %299, %297 ]
%260 = phi i64 [ 3, %254 ], [ %300, %297 ]
%261 = getelementptr inbounds float, float* %73, i64 %259
%262 = load float, float* %261
%263 = getelementptr inbounds float, float* %73, i64 %260
%264 = load float, float* %263
%265 = tail call i64 @hypot(float %262, float %264)
%266 = sitofp i64 %265 to float
%267 = icmp slt i64 %265, 1
br i1 %267, label %268, label %269
268: ; preds = %258
store float %256, float* %261
br label %297
269: ; preds = %258
%270 = fcmp ogt float %227, %266
br i1 %270, label %271, label %289
271: ; preds = %269
%272 = fsub float %227, %266
%273 = fdiv float %272, %228
%274 = fadd float %273, 1.000000e+00
%275 = fdiv float %273, %274
%276 = tail call float @llvm.fmuladd.f32(float %255, float %275, float %227)
%277 = fdiv float 1.000000e+00, %276
%278 = load float, float* %263
%279 = load float, float* %261
%280 = tail call i64 @atan2(float %278, float %279)
%281 = sitofp i64 %280 to float
%282 = fneg float %281
%283 = tail call i64 @cos(float %282)
%284 = sitofp i64 %283 to float
%285 = fmul float %277, %284
store float %285, float* %261
%286 = tail call i64 @sin(float %282)
%287 = sitofp i64 %286 to float
%288 = fmul float %277, %287
br label %297
289: ; preds = %269
%290 = fmul float %266, %266
%291 = fdiv float 1.000000e+00, %290
%292 = load float, float* %261
%293 = fmul float %291, %292
store float %293, float* %261
%294 = fneg float %291
%295 = load float, float* %263
%296 = fmul float %295, %294
br label %297
297: ; preds = %268, %289, %271
%298 = phi float [ 0.000000e+00, %268 ], [ %296, %289 ], [ %288, %271 ]
store float %298, float* %263
%299 = add nuw nsw i64 %259, 2
%300 = add nuw nsw i64 %260, 2
%301 = icmp ult i64 %299, %257
br i1 %301, label %258, label %302
302: ; preds = %221, %297, %178, %251
%303 = tail call i32 @hcconvolve(float* %80, float* %73, i32 %66)
br label %304
304: ; preds = %302, %114
%305 = tail call i32 @sputsp(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.26, i64 0, i64 0), i8* %29)
%306 = tail call i32* @fopen(i8* %29, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
%307 = icmp eq i32* %306, null
br i1 %307, label %313, label %308
308: ; preds = %304
%309 = icmp sgt i32 %52, 3
br i1 %309, label %310, label %322
310: ; preds = %308
%311 = call i32 @llvm.smax.i32(i32 %53, i32 1)
%312 = zext i32 %311 to i64
br label %315
313: ; preds = %304
%314 = tail call i32 @perror(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.27, i64 0, i64 0))
br label %515
315: ; preds = %310, %315
%316 = phi i64 [ 0, %310 ], [ %320, %315 ]
%317 = call i32 @fread(float* %3, i32 4, i32 1, i32* %306)
%318 = load float, float* %3
%319 = getelementptr inbounds float, float* %73, i64 %316
store float %318, float* %319
%320 = add nuw nsw i64 %316, 1
%321 = icmp eq i64 %320, %312
br i1 %321, label %322, label %315
322: ; preds = %315, %308
%323 = tail call i32 @fclose(i32* %306)
%324 = icmp slt i32 %53, %66
br i1 %324, label %325, label %334
325: ; preds = %322
%326 = sext i32 %53 to i64
%327 = getelementptr float, float* %73, i64 %326
%328 = bitcast float* %327 to i8*
%329 = xor i32 %53, -1
%330 = add i32 %66, %329
%331 = zext i32 %330 to i64
%332 = shl nuw nsw i64 %331, 2
%333 = add nuw nsw i64 %332, 4
br label %334
334: ; preds = %325, %322
%335 = tail call i32 @sputs(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.28, i64 0, i64 0))
%336 = tail call i32 @rdft(i32 %66, i32 1, float* %73)
%337 = tail call i32 @hcconvolve(float* %73, float* %80, i32 %66)
%338 = tail call i32 @rdft(i32 %66, i32 -1, float* %73)
%339 = icmp sgt i32 %66, 0
br i1 %339, label %342, label %340
340: ; preds = %334
%341 = tail call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.29, i64 0, i64 0))
br label %455
342: ; preds = %334
%343 = sitofp i32 %66 to double
%344 = fdiv double 2.000000e+00, %343
%345 = fptrunc double %344 to float
%346 = zext i32 %66 to i64
%347 = icmp ult i32 %66, 8
br i1 %347, label %404, label %348
348: ; preds = %342
%349 = and i64 %346, 4294967288
%350 = insertelement <4 x float> poison, float %345, i64 0
%351 = shufflevector <4 x float> %350, <4 x float> poison, <4 x i32> zeroinitializer
%352 = insertelement <4 x float> poison, float %345, i64 0
%353 = shufflevector <4 x float> %352, <4 x float> poison, <4 x i32> zeroinitializer
%354 = add nsw i64 %349, -8
%355 = lshr exact i64 %354, 3
%356 = add nuw nsw i64 %355, 1
%357 = and i64 %356, 1
%358 = icmp eq i64 %354, 0
br i1 %358, label %388, label %359
359: ; preds = %348
%360 = and i64 %356, 4611686018427387902
br label %361
361: ; preds = %361, %359
%362 = phi i64 [ 0, %359 ], [ %385, %361 ]
%363 = phi i64 [ 0, %359 ], [ %386, %361 ]
%364 = getelementptr inbounds float, float* %73, i64 %362
%365 = bitcast float* %364 to <4 x float>*
%366 = load <4 x float>, <4 x float>* %365
%367 = getelementptr inbounds float, float* %364, i64 4
%368 = bitcast float* %367 to <4 x float>*
%369 = load <4 x float>, <4 x float>* %368
%370 = fmul <4 x float> %366, %351
%371 = fmul <4 x float> %369, %353
%372 = bitcast float* %364 to <4 x float>*
store <4 x float> %370, <4 x float>* %372
%373 = bitcast float* %367 to <4 x float>*
store <4 x float> %371, <4 x float>* %373
%374 = or i64 %362, 8
%375 = getelementptr inbounds float, float* %73, i64 %374
%376 = bitcast float* %375 to <4 x float>*
%377 = load <4 x float>, <4 x float>* %376
%378 = getelementptr inbounds float, float* %375, i64 4
%379 = bitcast float* %378 to <4 x float>*
%380 = load <4 x float>, <4 x float>* %379
%381 = fmul <4 x float> %377, %351
%382 = fmul <4 x float> %380, %353
%383 = bitcast float* %375 to <4 x float>*
store <4 x float> %381, <4 x float>* %383
%384 = bitcast float* %378 to <4 x float>*
store <4 x float> %382, <4 x float>* %384
%385 = add nuw i64 %362, 16
%386 = add i64 %363, 2
%387 = icmp eq i64 %386, %360
br i1 %387, label %388, label %361
388: ; preds = %361, %348
%389 = phi i64 [ 0, %348 ], [ %385, %361 ]
%390 = icmp eq i64 %357, 0
br i1 %390, label %402, label %391
391: ; preds = %388
%392 = getelementptr inbounds float, float* %73, i64 %389
%393 = bitcast float* %392 to <4 x float>*
%394 = load <4 x float>, <4 x float>* %393
%395 = getelementptr inbounds float, float* %392, i64 4
%396 = bitcast float* %395 to <4 x float>*
%397 = load <4 x float>, <4 x float>* %396
%398 = fmul <4 x float> %394, %351
%399 = fmul <4 x float> %397, %353
%400 = bitcast float* %392 to <4 x float>*
store <4 x float> %398, <4 x float>* %400
%401 = bitcast float* %395 to <4 x float>*
store <4 x float> %399, <4 x float>* %401
br label %402
402: ; preds = %388, %391
%403 = icmp eq i64 %349, %346
br i1 %403, label %413, label %404
404: ; preds = %342, %402
%405 = phi i64 [ 0, %342 ], [ %349, %402 ]
br label %406
406: ; preds = %404, %406
%407 = phi i64 [ %411, %406 ], [ %405, %404 ]
%408 = getelementptr inbounds float, float* %73, i64 %407
%409 = load float, float* %408
%410 = fmul float %409, %345
store float %410, float* %408
%411 = add nuw nsw i64 %407, 1
%412 = icmp eq i64 %411, %346
br i1 %412, label %413, label %406
413: ; preds = %406, %402
%414 = tail call i32 @sputs(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.29, i64 0, i64 0))
br i1 %339, label %415, label %455
415: ; preds = %413
%416 = and i64 %346, 1
%417 = icmp eq i32 %66, 1
br i1 %417, label %457, label %418
418: ; preds = %415
%419 = and i64 %346, 4294967294
br label %420
420: ; preds = %449, %418
%421 = phi i64 [ 0, %418 ], [ %452, %449 ]
%422 = phi float [ 0.000000e+00, %418 ], [ %451, %449 ]
%423 = phi i32 [ 0, %418 ], [ %450, %449 ]
%424 = phi i64 [ 0, %418 ], [ %453, %449 ]
%425 = getelementptr inbounds float, float* %73, i64 %421
%426 = load float, float* %425
%427 = tail call i64 @fabs(float %426)
%428 = sitofp i64 %427 to float
%429 = fcmp olt float %422, %428
br i1 %429, label %430, label %435
430: ; preds = %420
%431 = load float, float* %425
%432 = tail call i64 @fabs(float %431)
%433 = sitofp i64 %432 to float
%434 = trunc i64 %421 to i32
br label %435
435: ; preds = %420, %430
%436 = phi i32 [ %434, %430 ], [ %423, %420 ]
%437 = phi float [ %433, %430 ], [ %422, %420 ]
%438 = or i64 %421, 1
%439 = getelementptr inbounds float, float* %73, i64 %438
%440 = load float, float* %439
%441 = tail call i64 @fabs(float %440)
%442 = sitofp i64 %441 to float
%443 = fcmp olt float %437, %442
br i1 %443, label %444, label %449
444: ; preds = %435
%445 = load float, float* %439
%446 = tail call i64 @fabs(float %445)
%447 = sitofp i64 %446 to float
%448 = trunc i64 %438 to i32
br label %449
449: ; preds = %444, %435
%450 = phi i32 [ %448, %444 ], [ %436, %435 ]
%451 = phi float [ %447, %444 ], [ %437, %435 ]
%452 = add nuw nsw i64 %421, 2
%453 = add i64 %424, 2
%454 = icmp eq i64 %453, %419
br i1 %454, label %457, label %420
455: ; preds = %413, %340
%456 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.30, i64 0, i64 0), double 0.000000e+00)
br label %487
457: ; preds = %449, %415
%458 = phi i32 [ undef, %415 ], [ %450, %449 ]
%459 = phi float [ undef, %415 ], [ %451, %449 ]
%460 = phi i64 [ 0, %415 ], [ %452, %449 ]
%461 = phi float [ 0.000000e+00, %415 ], [ %451, %449 ]
%462 = phi i32 [ 0, %415 ], [ %450, %449 ]
%463 = icmp eq i64 %416, 0
br i1 %463, label %475, label %464
464: ; preds = %457
%465 = getelementptr inbounds float, float* %73, i64 %460
%466 = load float, float* %465
%467 = tail call i64 @fabs(float %466)
%468 = sitofp i64 %467 to float
%469 = fcmp olt float %461, %468
br i1 %469, label %470, label %475
470: ; preds = %464
%471 = load float, float* %465
%472 = tail call i64 @fabs(float %471)
%473 = sitofp i64 %472 to float
%474 = trunc i64 %460 to i32
br label %475
475: ; preds = %464, %470, %457
%476 = phi i32 [ %458, %457 ], [ %474, %470 ], [ %462, %464 ]
%477 = phi float [ %459, %457 ], [ %473, %470 ], [ %461, %464 ]
%478 = sitofp i32 %476 to double
%479 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.30, i64 0, i64 0), double %478)
%480 = fcmp ogt float %477, 0.000000e+00
br i1 %480, label %481, label %487
481: ; preds = %475
%482 = fpext float %477 to double
%483 = tail call i32 @log10(double %482)
%484 = mul nsw i32 %483, 20
%485 = sitofp i32 %484 to double
%486 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.31, i64 0, i64 0), double %482, double %485)
br label %491
487: ; preds = %455, %475
%488 = phi float [ 0.000000e+00, %455 ], [ %477, %475 ]
%489 = fpext float %488 to double
%490 = tail call i32 (i8*, double, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.32, i64 0, i64 0), double %489)
br label %491
491: ; preds = %487, %481
%492 = load i32, i32* @stdout
%493 = tail call i32 @fflush(i32 %492)
%494 = tail call i32 @sputsp(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.33, i64 0, i64 0), i8* %33)
%495 = tail call i32* @fopen(i8* %33, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.34, i64 0, i64 0))
%496 = icmp eq i32* %495, null
br i1 %496, label %501, label %497
497: ; preds = %491
%498 = icmp sgt i32 %64, 0
br i1 %498, label %499, label %510
499: ; preds = %497
%500 = zext i32 %64 to i64
br label %503
501: ; preds = %491
%502 = tail call i32 @perror(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.35, i64 0, i64 0))
br label %515
503: ; preds = %499, %503
%504 = phi i64 [ 0, %499 ], [ %508, %503 ]
%505 = getelementptr inbounds float, float* %73, i64 %504
%506 = load float, float* %505
store float %506, float* %3
%507 = call i32 @fwrite(float* %3, i32 4, i32 1, i32* %495)
%508 = add nuw nsw i64 %504, 1
%509 = icmp eq i64 %508, %500
br i1 %509, label %510, label %503
510: ; preds = %503, %497
%511 = tail call i32 @fclose(i32* %495)
%512 = tail call i32 @free(float* %73)
%513 = tail call i32 @free(float* %80)
%514 = tail call i32 @sputs(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.36, i64 0, i64 0))
br label %515
515: ; preds = %510, %501, %313, %127, %94, %82, %76, %16
%516 = phi i32 [ 0, %16 ], [ 1, %76 ], [ 1, %82 ], [ 1, %94 ], [ 1, %127 ], [ 1, %313 ], [ 1, %501 ], [ 0, %510 ]
ret i32 %516
}