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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double M_PI;
float sin(float);
void four1(int isign, int nn, float *real, float *imag) {
  int n, mmax, m, j, istep, i;
  float wtemp, wr, wpr, wpi, wi, theta;
  float tempr, tempi;
  n = nn << 1;
  j = 1;
  for (i = 1; i < n; i += 2) {
    if (j > i) {
      int j2 = (j - 1) / 2;
      int i2 = (i - 1) / 2;
      tempr = real[j2];
      real[j2] = real[i2];
      real[i2] = tempr;
      tempr = imag[j2];
      imag[j2] = imag[i2];
      imag[i2] = tempr;
    }
    m = n >> 1;
    while (m >= 2 && j > m) {
      j -= m;
      m >>= 1;
    }
    j += m;
  }
  mmax = 2;
  while (n > mmax) {
    istep = 2 * mmax;
    theta = (2.0 * M_PI) / (isign * mmax);
    wtemp = sin(0.5 * theta);
    wpr = -2.0 * wtemp * wtemp;
    wpi = sin(theta);
    wr = 1.0;
    wi = 0.0;
    for (m = 1; m < mmax; m += 2) {
      for (i = m; i <= n; i += istep) {
        j = i + mmax;
        int j2 = (j - 1) / 2;
        int i2 = (i - 1) / 2;
        tempr = wr * real[j2] - wi * imag[j2];
        tempi = wr * imag[j2] + wi * real[j2];
        real[j2] = real[i2] - tempr;
        imag[j2] = imag[i2] - tempi;
        real[i2] += tempr;
        imag[i2] += tempi;
      }
      wr = (wtemp = wr) * wpr - wi * wpi + wr;
      wi = wi * wpr + wtemp * wpi + wi;
    }
    mmax = istep;
  }
}


x86 assembly (clang, -O0):
<four1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x1,-0x28(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1257 <four1+0x147>
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    11f3 <four1+0xe3>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
cmpl   $0x2,-0x24(%rbp)
mov    %al,-0x61(%rbp)
jl     1217 <four1+0x107>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
setg   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    1227 <four1+0x117>
jmp    1240 <four1+0x130>
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11fc <four1+0xec>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    113d <four1+0x2d>
movl   $0x2,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    14c0 <four1+0x3b0>
mov    -0x20(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movsd  0xd9d(%rip),%xmm0
mov    0x2d66(%rip),%rax
mulsd  (%rax),%xmm0
mov    -0x4(%rbp),%eax
imul   -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd61(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1030 <sin@plt>
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd36(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x48(%rbp),%xmm0
call   1030 <sin@plt>
movss  %xmm0,-0x40(%rbp)
movss  0xcfd(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    14b5 <four1+0x3a5>
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1449 <four1+0x339>
mov    -0x30(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x60(%rbp)
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1329 <four1+0x219>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1317 <four1+0x207>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    125e <four1+0x14e>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<four1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r13d
add    %esi,%r13d
cmp    $0x2,%r13d
jl     135f <four1+0x24f>
mov    %rcx,%r14
mov    %rdx,%rbx
mov    %edi,%r15d
mov    %r13d,%eax
mov    $0x1,%edx
mov    $0x1,%ecx
jmp    115d <four1+0x4d>
cs nopw 0x0(%rax,%rax,1)
add    %edi,%esi
add    $0x2,%rcx
mov    %esi,%edx
cmp    %rax,%rcx
jae    11c3 <four1+0xb3>
movslq %edx,%rsi
cmp    %rsi,%rcx
jge    11a9 <four1+0x99>
lea    -0x1(%rdx),%esi
shr    $0x1f,%esi
add    %edx,%esi
add    $0xffffffff,%esi
sar    %esi
lea    (%rcx,%rcx,1),%rdi
and    $0xfffffffffffffffc,%rdi
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  (%rbx,%rdi,1),%xmm1
movss  %xmm1,(%rbx,%rsi,4)
movss  %xmm0,(%rbx,%rdi,1)
movss  (%r14,%rsi,4),%xmm0
movss  (%r14,%rdi,1),%xmm1
movss  %xmm1,(%r14,%rsi,4)
movss  %xmm0,(%r14,%rdi,1)
mov    %r13d,%esi
nopl   0x0(%rax)
mov    %esi,%ebp
mov    %edx,%edi
sar    %esi
cmp    $0x4,%ebp
jl     1150 <four1+0x40>
mov    %edi,%edx
sub    %esi,%edx
jg     11b0 <four1+0xa0>
jmp    1150 <four1+0x40>
cmp    $0x3,%r13d
jl     135f <four1+0x24f>
mov    $0x2,%ebp
jmp    11e9 <four1+0xd9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %ebp,%r13d
jle    135f <four1+0x24f>
mov    %ebp,%r12d
lea    (%r12,%r12,1),%ebp
mov    0x2df1(%rip),%rax
movsd  (%rax),%xmm0
addsd  %xmm0,%xmm0
mov    %r12d,%eax
imul   %r15d,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
mulss  0xddd(%rip),%xmm0
call   1030 <sin@plt>
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
mulsd  0xdce(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movss  0x4(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0xdbd(%rip),%xmm9
cmp    $0x2,%r12d
jl     11e0 <four1+0xd0>
movsd  0x8(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm1
xorps  %xmm8,%xmm8
cvtsd2ss %xmm1,%xmm8
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm8,%xmm8
mov    $0x1,%eax
xor    %ecx,%ecx
movss  0xd7e(%rip),%xmm4
jmp    12b2 <four1+0x1a2>
nopl   0x0(%rax,%rax,1)
unpcklps %xmm4,%xmm3
mulps  %xmm0,%xmm3
movaps %xmm4,%xmm1
mulps  %xmm8,%xmm1
addps  %xmm3,%xmm1
addps  %xmm1,%xmm4
add    $0x2,%eax
add    $0x2,%ecx
cmp    %r12d,%eax
jge    11e0 <four1+0xd0>
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
movaps %xmm1,%xmm3
xorps  %xmm9,%xmm3
cmp    %r13d,%eax
jg     1290 <four1+0x180>
mov    %ecx,%edx
nopw   0x0(%rax,%rax,1)
lea    (%r12,%rdx,1),%esi
mov    %esi,%edi
shr    $0x1f,%edi
add    %esi,%edi
sar    %edi
mov    %edx,%esi
shr    $0x1f,%esi
add    %edx,%esi
sar    %esi
movslq %edi,%rdi
movss  (%rbx,%rdi,4),%xmm5
movss  (%r14,%rdi,4),%xmm6
movaps %xmm6,%xmm7
mulss  %xmm3,%xmm7
movaps %xmm4,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm7,%xmm2
mulss  %xmm1,%xmm5
movslq %esi,%rsi
movss  (%rbx,%rsi,4),%xmm7
mulss  %xmm4,%xmm6
subss  %xmm2,%xmm7
movss  %xmm7,(%rbx,%rdi,4)
movss  (%r14,%rsi,4),%xmm7
addss  %xmm5,%xmm6
subss  %xmm6,%xmm7
movss  %xmm7,(%r14,%rdi,4)
addss  (%rbx,%rsi,4),%xmm2
movss  %xmm2,(%rbx,%rsi,4)
addss  (%r14,%rsi,4),%xmm6
movss  %xmm6,(%r14,%rsi,4)
lea    (%rdx,%rbp,1),%esi
add    $0x1,%esi
add    %ebp,%edx
cmp    %r13d,%esi
jle    12d0 <four1+0x1c0>
jmp    1290 <four1+0x180>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@M_PI = global double 0.000000e+00
define void @four1(i32 %0, i32 %1, float* %2, float* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
store i32 %0, i32* %5
store i32 %1, i32* %6
store float* %2, float** %7
store float* %3, float** %8
%27 = load i32, i32* %6
%28 = shl i32 %27, 1
store i32 %28, i32* %9
store i32 1, i32* %12
store i32 1, i32* %14
br label %29
29: ; preds = %104, %4
%30 = load i32, i32* %14
%31 = load i32, i32* %9
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %107
33: ; preds = %29
%34 = load i32, i32* %12
%35 = load i32, i32* %14
%36 = icmp sgt i32 %34, %35
br i1 %36, label %37, label %82
37: ; preds = %33
%38 = load i32, i32* %12
%39 = sub nsw i32 %38, 1
%40 = sdiv i32 %39, 2
store i32 %40, i32* %23
%41 = load i32, i32* %14
%42 = sub nsw i32 %41, 1
%43 = sdiv i32 %42, 2
store i32 %43, i32* %24
%44 = load float*, float** %7
%45 = load i32, i32* %23
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
store float %48, float* %21
%49 = load float*, float** %7
%50 = load i32, i32* %24
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
%53 = load float, float* %52
%54 = load float*, float** %7
%55 = load i32, i32* %23
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %54, i64 %56
store float %53, float* %57
%58 = load float, float* %21
%59 = load float*, float** %7
%60 = load i32, i32* %24
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
store float %58, float* %62
%63 = load float*, float** %8
%64 = load i32, i32* %23
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float, float* %63, i64 %65
%67 = load float, float* %66
store float %67, float* %21
%68 = load float*, float** %8
%69 = load i32, i32* %24
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %68, i64 %70
%72 = load float, float* %71
%73 = load float*, float** %8
%74 = load i32, i32* %23
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %73, i64 %75
store float %72, float* %76
%77 = load float, float* %21
%78 = load float*, float** %8
%79 = load i32, i32* %24
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %78, i64 %80
store float %77, float* %81
br label %82
82: ; preds = %37, %33
%83 = load i32, i32* %9
%84 = ashr i32 %83, 1
store i32 %84, i32* %11
br label %85
85: ; preds = %94, %82
%86 = load i32, i32* %11
%87 = icmp sge i32 %86, 2
br i1 %87, label %88, label %92
88: ; preds = %85
%89 = load i32, i32* %12
%90 = load i32, i32* %11
%91 = icmp sgt i32 %89, %90
br label %92
92: ; preds = %88, %85
%93 = phi i1 [ false, %85 ], [ %91, %88 ]
br i1 %93, label %94, label %100
94: ; preds = %92
%95 = load i32, i32* %11
%96 = load i32, i32* %12
%97 = sub nsw i32 %96, %95
store i32 %97, i32* %12
%98 = load i32, i32* %11
%99 = ashr i32 %98, 1
store i32 %99, i32* %11
br label %85
100: ; preds = %92
%101 = load i32, i32* %11
%102 = load i32, i32* %12
%103 = add nsw i32 %102, %101
store i32 %103, i32* %12
br label %104
104: ; preds = %100
%105 = load i32, i32* %14
%106 = add nsw i32 %105, 2
store i32 %106, i32* %14
br label %29
107: ; preds = %29
store i32 2, i32* %10
br label %108
108: ; preds = %247, %107
%109 = load i32, i32* %9
%110 = load i32, i32* %10
%111 = icmp sgt i32 %109, %110
br i1 %111, label %112, label %249
112: ; preds = %108
%113 = load i32, i32* %10
%114 = mul nsw i32 2, %113
store i32 %114, i32* %13
%115 = load double, double* @M_PI
%116 = fmul double 2.000000e+00, %115
%117 = load i32, i32* %5
%118 = load i32, i32* %10
%119 = mul nsw i32 %117, %118
%120 = sitofp i32 %119 to double
%121 = fdiv double %116, %120
%122 = fptrunc double %121 to float
store float %122, float* %20
%123 = load float, float* %20
%124 = fpext float %123 to double
%125 = fmul double 5.000000e-01, %124
%126 = fptrunc double %125 to float
%127 = call float @sin(float %126)
store float %127, float* %15
%128 = load float, float* %15
%129 = fpext float %128 to double
%130 = fmul double -2.000000e+00, %129
%131 = load float, float* %15
%132 = fpext float %131 to double
%133 = fmul double %130, %132
%134 = fptrunc double %133 to float
store float %134, float* %17
%135 = load float, float* %20
%136 = call float @sin(float %135)
store float %136, float* %18
store float 1.000000e+00, float* %16
store float 0.000000e+00, float* %19
store i32 1, i32* %11
br label %137
137: ; preds = %244, %112
%138 = load i32, i32* %11
%139 = load i32, i32* %10
%140 = icmp slt i32 %138, %139
br i1 %140, label %141, label %247
141: ; preds = %137
%142 = load i32, i32* %11
store i32 %142, i32* %14
br label %143
143: ; preds = %222, %141
%144 = load i32, i32* %14
%145 = load i32, i32* %9
%146 = icmp sle i32 %144, %145
br i1 %146, label %147, label %226
147: ; preds = %143
%148 = load i32, i32* %14
%149 = load i32, i32* %10
%150 = add nsw i32 %148, %149
store i32 %150, i32* %12
%151 = load i32, i32* %12
%152 = sub nsw i32 %151, 1
%153 = sdiv i32 %152, 2
store i32 %153, i32* %25
%154 = load i32, i32* %14
%155 = sub nsw i32 %154, 1
%156 = sdiv i32 %155, 2
store i32 %156, i32* %26
%157 = load float, float* %16
%158 = load float*, float** %7
%159 = load i32, i32* %25
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %158, i64 %160
%162 = load float, float* %161
%163 = load float, float* %19
%164 = load float*, float** %8
%165 = load i32, i32* %25
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %164, i64 %166
%168 = load float, float* %167
%169 = fmul float %163, %168
%170 = fneg float %169
%171 = call float @llvm.fmuladd.f32(float %157, float %162, float %170)
store float %171, float* %21
%172 = load float, float* %16
%173 = load float*, float** %8
%174 = load i32, i32* %25
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %173, i64 %175
%177 = load float, float* %176
%178 = load float, float* %19
%179 = load float*, float** %7
%180 = load i32, i32* %25
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = load float, float* %182
%184 = fmul float %178, %183
%185 = call float @llvm.fmuladd.f32(float %172, float %177, float %184)
store float %185, float* %22
%186 = load float*, float** %7
%187 = load i32, i32* %26
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float, float* %186, i64 %188
%190 = load float, float* %189
%191 = load float, float* %21
%192 = fsub float %190, %191
%193 = load float*, float** %7
%194 = load i32, i32* %25
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %193, i64 %195
store float %192, float* %196
%197 = load float*, float** %8
%198 = load i32, i32* %26
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds float, float* %197, i64 %199
%201 = load float, float* %200
%202 = load float, float* %22
%203 = fsub float %201, %202
%204 = load float*, float** %8
%205 = load i32, i32* %25
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
store float %203, float* %207
%208 = load float, float* %21
%209 = load float*, float** %7
%210 = load i32, i32* %26
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %209, i64 %211
%213 = load float, float* %212
%214 = fadd float %213, %208
store float %214, float* %212
%215 = load float, float* %22
%216 = load float*, float** %8
%217 = load i32, i32* %26
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %216, i64 %218
%220 = load float, float* %219
%221 = fadd float %220, %215
store float %221, float* %219
br label %222
222: ; preds = %147
%223 = load i32, i32* %13
%224 = load i32, i32* %14
%225 = add nsw i32 %224, %223
store i32 %225, i32* %14
br label %143
226: ; preds = %143
%227 = load float, float* %16
store float %227, float* %15
%228 = load float, float* %17
%229 = load float, float* %19
%230 = load float, float* %18
%231 = fmul float %229, %230
%232 = fneg float %231
%233 = call float @llvm.fmuladd.f32(float %227, float %228, float %232)
%234 = load float, float* %16
%235 = fadd float %233, %234
store float %235, float* %16
%236 = load float, float* %19
%237 = load float, float* %17
%238 = load float, float* %15
%239 = load float, float* %18
%240 = fmul float %238, %239
%241 = call float @llvm.fmuladd.f32(float %236, float %237, float %240)
%242 = load float, float* %19
%243 = fadd float %241, %242
store float %243, float* %19
br label %244
244: ; preds = %226
%245 = load i32, i32* %11
%246 = add nsw i32 %245, 2
store i32 %246, i32* %11
br label %137
247: ; preds = %137
%248 = load i32, i32* %13
store i32 %248, i32* %10
br label %108
249: ; preds = %108
ret void
}

LLVM IR (-O2):
@M_PI = global double 0.000000e+00
define void @four1(i32 %0, i32 %1, float* nocapture %2, float* nocapture %3) {
%5 = shl i32 %1, 1
%6 = icmp sgt i32 %5, 1
br i1 %6, label %7, label %110
7: ; preds = %4
%8 = zext i32 %5 to i64
br label %11
9: ; preds = %38
%10 = icmp sgt i32 %5, 2
br i1 %10, label %44, label %110
11: ; preds = %7, %38
%12 = phi i64 [ 1, %7 ], [ %40, %38 ]
%13 = phi i32 [ 1, %7 ], [ %39, %38 ]
%14 = sext i32 %13 to i64
%15 = icmp slt i64 %12, %14
br i1 %15, label %16, label %29
16: ; preds = %11
%17 = add nsw i32 %13, -1
%18 = sdiv i32 %17, 2
%19 = lshr i64 %12, 1
%20 = sext i32 %18 to i64
%21 = getelementptr inbounds float, float* %2, i64 %20
%22 = load float, float* %21
%23 = getelementptr inbounds float, float* %2, i64 %19
%24 = load float, float* %23
store float %24, float* %21
store float %22, float* %23
%25 = getelementptr inbounds float, float* %3, i64 %20
%26 = load float, float* %25
%27 = getelementptr inbounds float, float* %3, i64 %19
%28 = load float, float* %27
store float %28, float* %25
store float %26, float* %27
br label %29
29: ; preds = %16, %11
br label %30
30: ; preds = %29, %30
%31 = phi i32 [ %37, %30 ], [ %13, %29 ]
%32 = phi i32 [ %33, %30 ], [ %5, %29 ]
%33 = ashr i32 %32, 1
%34 = icmp sgt i32 %32, 3
%35 = icmp sgt i32 %31, %33
%36 = select i1 %34, i1 %35, i1 false
%37 = sub nsw i32 %31, %33
br i1 %36, label %30, label %38
38: ; preds = %30
%39 = add nsw i32 %33, %31
%40 = add nuw nsw i64 %12, 2
%41 = icmp ult i64 %40, %8
br i1 %41, label %11, label %9
42: ; preds = %102, %44
%43 = icmp sgt i32 %5, %46
br i1 %43, label %44, label %110
44: ; preds = %9, %42
%45 = phi i32 [ %46, %42 ], [ 2, %9 ]
%46 = shl nsw i32 %45, 1
%47 = load double, double* @M_PI
%48 = fmul double %47, 2.000000e+00
%49 = mul nsw i32 %45, %0
%50 = sitofp i32 %49 to double
%51 = fdiv double %48, %50
%52 = fptrunc double %51 to float
%53 = fmul float %52, 5.000000e-01
%54 = tail call float @sin(float %53)
%55 = fpext float %54 to double
%56 = fmul double %55, -2.000000e+00
%57 = fmul double %56, %55
%58 = fptrunc double %57 to float
%59 = tail call float @sin(float %52)
%60 = icmp sgt i32 %45, 1
br i1 %60, label %61, label %42
61: ; preds = %44
%62 = insertelement <2 x float> poison, float %59, i64 0
%63 = shufflevector <2 x float> %62, <2 x float> poison, <2 x i32> zeroinitializer
%64 = insertelement <2 x float> poison, float %58, i64 0
%65 = shufflevector <2 x float> %64, <2 x float> poison, <2 x i32> zeroinitializer
br label %66
66: ; preds = %61, %102
%67 = phi i32 [ %108, %102 ], [ 1, %61 ]
%68 = phi <2 x float> [ %107, %102 ], [ <float 1.000000e+00, float 0.000000e+00>, %61 ]
%69 = icmp sgt i32 %67, %5
%70 = extractelement <2 x float> %68, i64 1
%71 = fneg float %70
br i1 %69, label %102, label %72
72: ; preds = %66
%73 = extractelement <2 x float> %68, i64 0
br label %74
74: ; preds = %72, %74
%75 = phi i32 [ %100, %74 ], [ %67, %72 ]
%76 = add nsw i32 %75, -1
%77 = add i32 %76, %45
%78 = sdiv i32 %77, 2
%79 = sdiv i32 %76, 2
%80 = sext i32 %78 to i64
%81 = getelementptr inbounds float, float* %2, i64 %80
%82 = load float, float* %81
%83 = getelementptr inbounds float, float* %3, i64 %80
%84 = load float, float* %83
%85 = fmul float %84, %71
%86 = tail call float @llvm.fmuladd.f32(float %73, float %82, float %85)
%87 = fmul float %70, %82
%88 = tail call float @llvm.fmuladd.f32(float %73, float %84, float %87)
%89 = sext i32 %79 to i64
%90 = getelementptr inbounds float, float* %2, i64 %89
%91 = load float, float* %90
%92 = fsub float %91, %86
store float %92, float* %81
%93 = getelementptr inbounds float, float* %3, i64 %89
%94 = load float, float* %93
%95 = fsub float %94, %88
store float %95, float* %83
%96 = load float, float* %90
%97 = fadd float %86, %96
store float %97, float* %90
%98 = load float, float* %93
%99 = fadd float %88, %98
store float %99, float* %93
%100 = add nsw i32 %75, %46
%101 = icmp sgt i32 %100, %5
br i1 %101, label %102, label %74
102: ; preds = %74, %66
%103 = insertelement <2 x float> poison, float %71, i64 0
%104 = shufflevector <2 x float> %103, <2 x float> %68, <2 x i32> <i32 0, i32 2>
%105 = fmul <2 x float> %63, %104
%106 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %68, <2 x float> %65, <2 x float> %105)
%107 = fadd <2 x float> %68, %106
%108 = add nuw nsw i32 %67, 2
%109 = icmp slt i32 %108, %45
br i1 %109, label %66, label %42
110: ; preds = %42, %4, %9
ret void
}