#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 *malloc(int);
int rand();
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
double *ifs_2d(int n_iter, int n_transforms, double init[], int probs[],
               double T[]) {
  int i, j;
  int test;
  int prob_used;
  double *points = malloc(2 * n_iter * sizeof(double));
  points[0] = init[0];
  points[1] = init[1];
  srand(time(NULL));
  for (i = 2; i < (2 * n_iter); i += 2) {
    test = rand() % 100;
    prob_used = 0;
    prob_used += probs[0];
    if (test < prob_used) {
      points[i] = T[0] * points[i - 2] + T[1] * points[i - 1] + T[4];
      points[i + 1] = T[2] * points[i - 2] + T[3] * points[i - 1] + T[5];
    }
    for (j = 1; j < n_transforms; j++) {
      prob_used += probs[j];
      if (test < prob_used) {
        points[i] = T[0 + j * 6] * points[i - 2] +
                    T[1 + j * 6] * points[i - 1] + T[4 + j * 6];
        points[i + 1] = T[2 + j * 6] * points[i - 2] +
                        T[3 + j * 6] * points[i - 1] + T[5 + j * 6];
        break;
      }
    }
  }
  return points;
}


x86 assembly (clang, -O0):
<ifs_2d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,0x8(%rax)
xor    %eax,%eax
mov    %eax,%edi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    13dc <ifs_2d+0x29c>
mov    $0x0,%al
call   1060 <rand@plt>
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %edx,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1298 <ifs_2d+0x158>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
addsd  0x20(%rax),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
addsd  0x28(%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13c9 <ifs_2d+0x289>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13b6 <ifs_2d+0x276>
mov    -0x20(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
imul   $0x6,-0x28(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13c9 <ifs_2d+0x289>
jmp    13bb <ifs_2d+0x27b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    129f <ifs_2d+0x15f>
jmp    13ce <ifs_2d+0x28e>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    11aa <ifs_2d+0x6a>
mov    -0x38(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ifs_2d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,%rbx
mov    %rcx,%rbp
mov    %rdx,%r13
mov    %esi,0xc(%rsp)
mov    %edi,%r12d
shl    $0x4,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
movupd 0x0(%r13),%xmm0
movupd %xmm0,(%rax)
xor    %edi,%edi
call   1040 <time@plt>
mov    %eax,%edi
call   1030 <srand@plt>
cmp    $0x2,%r12d
jl     12df <ifs_2d+0x19f>
add    %r12d,%r12d
movslq %r12d,%r12
mov    0xc(%rsp),%eax
lea    0x4(%rbp),%rcx
mov    %rcx,0x10(%rsp)
lea    (%rax,%rax,2),%rax
lea    (%rax,%rax,1),%r13
add    $0xfffffffffffffffa,%r13
mov    $0x2,%r14d
jmp    123b <ifs_2d+0xfb>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x6,%eax
sub    %edx,%eax
mov    $0x7,%ecx
sub    %edx,%ecx
mov    $0xa,%esi
sub    %edx,%esi
mov    $0x8,%edi
sub    %edx,%edi
mov    %rbp,%r8
mov    $0x9,%ebp
sub    %edx,%ebp
movsd  (%rbx,%rcx,8),%xmm0
movhpd (%rbx,%rbp,8),%xmm0
mov    %r8,%rbp
movsd  -0x10(%r15,%r14,8),%xmm1
movsd  -0x8(%r15,%r14,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm0,%xmm2
movsd  (%rbx,%rax,8),%xmm0
movhpd (%rbx,%rdi,8),%xmm0
unpcklpd %xmm1,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm2,%xmm1
movupd (%rbx,%rsi,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r15,%r14,8)
add    $0x2,%r14
cmp    %r12,%r14
jge    12df <ifs_2d+0x19f>
xor    %eax,%eax
call   1060 <rand@plt>
cltq
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rcx
add    %edx,%ecx
imul   $0x64,%ecx,%ecx
sub    %ecx,%eax
mov    0x0(%rbp),%ecx
cmp    %ecx,%eax
jge    12a8 <ifs_2d+0x168>
movsd  (%rbx),%xmm0
movsd  0x8(%rbx),%xmm1
movhpd 0x18(%rbx),%xmm1
movsd  -0x10(%r15,%r14,8),%xmm2
movsd  -0x8(%r15,%r14,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm1,%xmm3
movhpd 0x10(%rbx),%xmm0
unpcklpd %xmm2,%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm3,%xmm2
movupd 0x20(%rbx),%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,(%r15,%r14,8)
cmpl   $0x2,0xc(%rsp)
jl     122e <ifs_2d+0xee>
mov    0x10(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
add    (%rsi),%ecx
cmp    %ecx,%eax
jl     11c0 <ifs_2d+0x80>
add    $0xfffffffffffffffa,%rdx
add    $0x4,%rsi
mov    %r13,%rdi
add    %rdx,%rdi
jne    12c0 <ifs_2d+0x180>
jmp    122e <ifs_2d+0xee>
mov    %r15,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define noalias double* @ifs_2d(i32 %0, i32 %1, double* nocapture %2, i32* nocapture %3, double* nocapture %4) {
%6 = shl i32 %0, 4
%7 = tail call double* @malloc(i32 %6)
%8 = bitcast double* %2 to <2 x double>*
%9 = load <2 x double>, <2 x double>* %8
%10 = bitcast double* %7 to <2 x double>*
store <2 x double> %9, <2 x double>* %10
%11 = tail call i32 @time(i32* null)
%12 = tail call i32 @srand(i32 %11)
%13 = icmp sgt i32 %0, 1
br i1 %13, label %14, label %111
14: ; preds = %5
%15 = shl nuw nsw i32 %0, 1
%16 = getelementptr inbounds double, double* %4, i64 1
%17 = getelementptr inbounds double, double* %4, i64 4
%18 = getelementptr inbounds double, double* %4, i64 2
%19 = getelementptr inbounds double, double* %4, i64 3
%20 = icmp sgt i32 %1, 1
%21 = sext i32 %15 to i64
%22 = zext i32 %1 to i64
%23 = bitcast double* %17 to <2 x double>*
br label %24
24: ; preds = %14, %108
%25 = phi i64 [ 2, %14 ], [ %109, %108 ]
%26 = tail call i32 (...) @rand()
%27 = srem i32 %26, 100
%28 = load i32, i32* %3
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %55
30: ; preds = %24
%31 = load double, double* %4
%32 = add nsw i64 %25, -2
%33 = getelementptr inbounds double, double* %7, i64 %32
%34 = load double, double* %33
%35 = load double, double* %16
%36 = add nsw i64 %25, -1
%37 = getelementptr inbounds double, double* %7, i64 %36
%38 = load double, double* %37
%39 = getelementptr inbounds double, double* %7, i64 %25
%40 = load double, double* %18
%41 = load double, double* %19
%42 = insertelement <2 x double> poison, double %35, i64 0
%43 = insertelement <2 x double> %42, double %41, i64 1
%44 = insertelement <2 x double> poison, double %38, i64 0
%45 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
%46 = fmul <2 x double> %43, %45
%47 = insertelement <2 x double> poison, double %31, i64 0
%48 = insertelement <2 x double> %47, double %40, i64 1
%49 = insertelement <2 x double> poison, double %34, i64 0
%50 = shufflevector <2 x double> %49, <2 x double> poison, <2 x i32> zeroinitializer
%51 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %48, <2 x double> %50, <2 x double> %46)
%52 = load <2 x double>, <2 x double>* %23
%53 = fadd <2 x double> %52, %51
%54 = bitcast double* %39 to <2 x double>*
store <2 x double> %53, <2 x double>* %54
br label %55
55: ; preds = %30, %24
br i1 %20, label %56, label %108
56: ; preds = %55, %105
%57 = phi i64 [ %106, %105 ], [ 1, %55 ]
%58 = phi i32 [ %61, %105 ], [ %28, %55 ]
%59 = getelementptr inbounds i32, i32* %3, i64 %57
%60 = load i32, i32* %59
%61 = add nsw i32 %60, %58
%62 = icmp slt i32 %27, %61
br i1 %62, label %63, label %105
63: ; preds = %56
%64 = trunc i64 %57 to i32
%65 = mul nsw i32 %64, 6
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds double, double* %4, i64 %66
%68 = load double, double* %67
%69 = add nsw i64 %25, -2
%70 = getelementptr inbounds double, double* %7, i64 %69
%71 = load double, double* %70
%72 = or i32 %65, 1
%73 = zext i32 %72 to i64
%74 = getelementptr inbounds double, double* %4, i64 %73
%75 = load double, double* %74
%76 = add nsw i64 %25, -1
%77 = getelementptr inbounds double, double* %7, i64 %76
%78 = load double, double* %77
%79 = add nuw nsw i32 %65, 4
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds double, double* %4, i64 %80
%82 = getelementptr inbounds double, double* %7, i64 %25
%83 = add nuw nsw i32 %65, 2
%84 = zext i32 %83 to i64
%85 = getelementptr inbounds double, double* %4, i64 %84
%86 = load double, double* %85
%87 = add nuw nsw i32 %65, 3
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds double, double* %4, i64 %88
%90 = load double, double* %89
%91 = insertelement <2 x double> poison, double %75, i64 0
%92 = insertelement <2 x double> %91, double %90, i64 1
%93 = insertelement <2 x double> poison, double %78, i64 0
%94 = shufflevector <2 x double> %93, <2 x double> poison, <2 x i32> zeroinitializer
%95 = fmul <2 x double> %92, %94
%96 = insertelement <2 x double> poison, double %68, i64 0
%97 = insertelement <2 x double> %96, double %86, i64 1
%98 = insertelement <2 x double> poison, double %71, i64 0
%99 = shufflevector <2 x double> %98, <2 x double> poison, <2 x i32> zeroinitializer
%100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %97, <2 x double> %99, <2 x double> %95)
%101 = bitcast double* %81 to <2 x double>*
%102 = load <2 x double>, <2 x double>* %101
%103 = fadd <2 x double> %102, %100
%104 = bitcast double* %82 to <2 x double>*
store <2 x double> %103, <2 x double>* %104
br label %108
105: ; preds = %56
%106 = add nuw nsw i64 %57, 1
%107 = icmp eq i64 %106, %22
br i1 %107, label %108, label %56
108: ; preds = %105, %55, %63
%109 = add nuw nsw i64 %25, 2
%110 = icmp slt i64 %109, %21
br i1 %110, label %24, label %111
111: ; preds = %108, %5
ret double* %7
}