#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 sin(double);
void four1(double *data, int n) {
  int i, j, m, mmax;
  i = 0;
  j = 0;
  while (i < n) {
    if (i < j) {
      {
        double temp = data[i];
        data[i] = data[j];
        data[j] = temp;
      };
      {
        double temp = data[i + 1];
        data[i + 1] = data[j + 1];
        data[j + 1] = temp;
      };
    }
    m = n / 2;
    while (m >= 2 && j >= m) {
      j = j - m;
      m = m / 2;
    }
    i += 2;
    j += m;
  }
  mmax = 2;
  while (mmax < n) {
    double theta = 6.28318530717959 / mmax;
    double x = sin(0.5 * theta);
    double wpr = -2.0 * x * x;
    double wpi = sin(theta);
    double wr = 1.0;
    double wi = 0.0;
    double temp, tempr, tempi;
    m = 0;
    while (m < mmax) {
      i = m;
      while (i < n) {
        j = i + mmax;
        tempr = wr * data[j] - wi * data[j + 1];
        tempi = wi * data[j] + wr * data[j + 1];
        data[j] = data[i] - tempr;
        data[j + 1] = data[i + 1] - tempi;
        data[i] = data[i] + tempr;
        data[i + 1] = data[i + 1] + tempi;
        i = j + mmax;
      }
      temp = wr;
      wr = temp * wpr - wi * wpi + wr;
      wi = wi * wpr + temp * wpi + wi;
      m += 2;
    }
    mmax *= 2;
  }
}


x86 assembly (clang, -O0):
<four1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1244 <four1+0x134>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d8 <four1+0xc8>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
xor    %eax,%eax
cmpl   $0x2,-0x18(%rbp)
mov    %al,-0x79(%rbp)
jl     1201 <four1+0xf1>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
setge  %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    1211 <four1+0x101>
jmp    122d <four1+0x11d>
mov    -0x14(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
jmp    11e6 <four1+0xd6>
mov    -0x10(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1130 <four1+0x20>
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1497 <four1+0x387>
cvtsi2sdl -0x1c(%rbp),%xmm1
movsd  0xdb4(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd9b(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  0xd7c(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  0xd4e(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1489 <four1+0x379>
mov    -0x18(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    140e <four1+0x2fe>
mov    -0x10(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x14(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    12d8 <four1+0x1c8>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
jmp    12c6 <four1+0x1b6>
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    124b <four1+0x13b>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<four1>:
push   %rbp
push   %r14
push   %rbx
sub    $0x30,%rsp
test   %esi,%esi
jle    1310 <four1+0x200>
mov    %esi,%r14d
mov    %rdi,%rbx
mov    %esi,%eax
xor    %ecx,%ecx
xor    %edx,%edx
jmp    113d <four1+0x2d>
xchg   %ax,%ax
add    $0x2,%rcx
add    %edi,%esi
mov    %esi,%edx
cmp    %rax,%rcx
jae    1198 <four1+0x88>
movslq %edx,%rsi
cmp    %rsi,%rcx
jge    117b <four1+0x6b>
lea    0x0(,%rcx,8),%rdi
movsd  (%rbx,%rcx,8),%xmm0
movsd  (%rbx,%rsi,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  %xmm0,(%rbx,%rsi,8)
or     $0x8,%rdi
movsd  (%rbx,%rdi,1),%xmm0
movsd  0x8(%rbx,%rsi,8),%xmm1
movsd  %xmm1,(%rbx,%rdi,1)
movsd  %xmm0,0x8(%rbx,%rsi,8)
mov    %r14d,%edi
xchg   %ax,%ax
mov    %edx,%esi
mov    %edi,%edx
shr    $0x1f,%edi
add    %edx,%edi
sar    %edi
cmp    $0x4,%edx
jl     1130 <four1+0x20>
mov    %esi,%edx
sub    %edi,%edx
jge    1180 <four1+0x70>
jmp    1130 <four1+0x20>
cmp    $0x3,%r14d
jl     1310 <four1+0x200>
mov    $0x2,%ebp
xorpd  %xmm0,%xmm0
movhpd 0xe65(%rip),%xmm0
movapd %xmm0,0x10(%rsp)
jmp    11cb <four1+0xbb>
nopl   0x0(%rax,%rax,1)
add    %ebp,%ebp
cmp    %r14d,%ebp
jge    1310 <four1+0x200>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
movsd  0xe26(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movapd %xmm1,%xmm0
mulsd  0xe18(%rip),%xmm0
call   1030 <sin@plt>
movapd %xmm0,%xmm1
mulsd  0xe0f(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x20(%rsp)
movsd  0x8(%rsp),%xmm0
call   1030 <sin@plt>
movapd 0x20(%rsp),%xmm9
movapd 0xdfa(%rip),%xmm8
unpcklpd %xmm9,%xmm9
unpcklpd %xmm0,%xmm0
lea    0x1(%rbp),%eax
xor    %r8d,%r8d
movapd 0x10(%rsp),%xmm1
jmp    126b <four1+0x15b>
nopl   (%rax)
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
mulpd  %xmm0,%xmm3
movapd %xmm1,%xmm2
mulpd  %xmm9,%xmm2
addpd  %xmm3,%xmm2
addpd  %xmm2,%xmm1
add    $0x2,%r8d
cmp    %ebp,%r8d
jae    11c0 <four1+0xb0>
movapd %xmm1,%xmm2
xorpd  %xmm8,%xmm2
cmp    %r14d,%r8d
jge    1240 <four1+0x130>
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
mov    %r8d,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdx,%rbp,1),%esi
lea    (%rax,%rdx,1),%edi
movslq %edx,%rdx
movslq %esi,%rsi
movsd  (%rbx,%rsi,8),%xmm4
movslq %edi,%rdi
movsd  (%rbx,%rdi,8),%xmm5
movapd %xmm5,%xmm6
mulsd  %xmm2,%xmm6
movapd %xmm3,%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm6,%xmm7
mulsd  %xmm3,%xmm5
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rbx,%rdx,8),%xmm5
subsd  %xmm7,%xmm5
movsd  %xmm5,(%rbx,%rsi,8)
lea    0x1(%rdx),%ecx
movslq %ecx,%rcx
movsd  (%rbx,%rcx,8),%xmm5
movapd %xmm5,%xmm6
subsd  %xmm4,%xmm6
movsd  %xmm6,(%rbx,%rdi,8)
addsd  (%rbx,%rdx,8),%xmm7
movsd  %xmm7,(%rbx,%rdx,8)
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rbx,%rcx,8)
add    %ebp,%esi
mov    %esi,%edx
cmp    %r14d,%esi
jl     1290 <four1+0x180>
jmp    1240 <four1+0x130>
add    $0x30,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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