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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int sample(int *, int, int);
void multirsampleT(double *data, int dat_siz, int dps, int *pool, int size,
                   int max_sz, double *dst) {
  double *src, *p;
  int i, j, k, q;
  int ssh = dps * max_sz, bsz = dat_siz * dps;
  for (i = 0; i < size; i++) {
    q = sample(pool, max_sz, i);
    src = data + dps * q;
    p = dst + i * bsz;
    for (j = 0; j < dat_siz; j++) {
      for (k = 0; k < dps; k++)
        p[k * dat_siz] = src[k];
      p += 1;
      src += ssh;
    }
  }
}


x86 assembly (clang, -O0):
<multirsampleT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x10(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1233 <multirsampleT+0x123>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%esi
mov    -0x34(%rbp),%edx
call   1030 <sample@plt>
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x48(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1220 <multirsampleT+0x110>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11f1 <multirsampleT+0xe1>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11b7 <multirsampleT+0xa7>
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11a4 <multirsampleT+0x94>
jmp    1225 <multirsampleT+0x115>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114d <multirsampleT+0x3d>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<multirsampleT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9d,0x14(%rsp)
mov    %rcx,0x50(%rsp)
mov    %edx,0xc(%rsp)
mov    %esi,0x10(%rsp)
mov    %rdi,0x28(%rsp)
test   %r8d,%r8d
jle    14d0 <multirsampleT+0x3c0>
mov    0xc(%rsp),%edx
mov    %edx,%eax
mov    0x10(%rsp),%esi
imul   %esi,%eax
mov    0x14(%rsp),%ecx
imul   %edx,%ecx
movslq %ecx,%rcx
movslq %esi,%rsi
cltq
mov    %rax,0x40(%rsp)
mov    %r8d,%eax
mov    %rax,0x48(%rsp)
mov    %edx,%r14d
movslq %edx,%rax
mov    %r14d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x70(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x68(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rax,0x38(%rsp)
cmp    $0x4,%eax
setae  %al
cmp    $0x1,%esi
sete   %bl
and    %al,%bl
mov    %bl,0xb(%rsp)
mov    %edx,%r15d
and    $0x3,%r15d
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x58(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,0xa0(%rsp)
mov    %rsi,%rax
shl    $0x7,%rax
mov    %rax,0x80(%rsp)
mov    %rsi,%r12
shl    $0x5,%r12
mov    %r15,0x60(%rsp)
shl    $0x5,%r15
mov    %rcx,0x88(%rsp)
lea    0x0(,%rcx,8),%r10
mov    %rsi,0x30(%rsp)
lea    0x0(,%rsi,8),%r13
xor    %edx,%edx
mov    %r10,0x18(%rsp)
jmp    1224 <multirsampleT+0x114>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdx
add    $0x1,%rdx
cmp    0x48(%rsp),%rdx
je     14d0 <multirsampleT+0x3c0>
mov    0x50(%rsp),%rdi
mov    0x14(%rsp),%esi
mov    %rdx,0x20(%rsp)
call   1030 <sample@plt>
cmpl   $0x0,0x10(%rsp)
jle    1210 <multirsampleT+0x100>
mov    0x20(%rsp),%rcx
mov    %rcx,%rdx
imul   0x38(%rsp),%rdx
mov    %rdx,0x98(%rsp)
add    %r14,%rdx
mov    %rdx,0x78(%rsp)
imul   0x40(%rsp),%rcx
mov    0xe0(%rsp),%rdx
lea    (%rdx,%rcx,8),%r8
mov    0x18(%rsp),%r10
imul   0xc(%rsp),%eax
movslq %eax,%rcx
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rdi
add    %r14,%rcx
mov    %rcx,0x90(%rsp)
xor    %r9d,%r9d
jmp    12b6 <multirsampleT+0x1a6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x8,%r8
add    %r10,%rdi
add    $0x1,%r9
cmp    0x10(%rsp),%r9d
je     1210 <multirsampleT+0x100>
cmpl   $0x0,0xc(%rsp)
jle    12a0 <multirsampleT+0x190>
cmpb   $0x0,0xb(%rsp)
je     1330 <multirsampleT+0x220>
mov    0x98(%rsp),%rax
add    %r9,%rax
mov    %r9,%rcx
imul   0x88(%rsp),%rcx
add    0x90(%rsp),%rcx
mov    0xe0(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    0x28(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
cmp    %rcx,%rax
mov    0x80(%rsp),%rdx
jae    1337 <multirsampleT+0x227>
mov    0x78(%rsp),%rax
add    %r9,%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %rax,%rdi
jae    1337 <multirsampleT+0x227>
xor    %ecx,%ecx
mov    0x18(%rsp),%r10
jmp    1410 <multirsampleT+0x300>
xor    %ecx,%ecx
jmp    1410 <multirsampleT+0x300>
cmpq   $0xc,0x68(%rsp)
jae    1343 <multirsampleT+0x233>
xor    %ecx,%ecx
jmp    13b5 <multirsampleT+0x2a5>
mov    0x58(%rsp),%rax
mov    %r8,%rsi
xor    %ecx,%ecx
nopl   (%rax)
movups (%rdi,%rcx,8),%xmm0
movups 0x10(%rdi,%rcx,8),%xmm1
movups %xmm0,(%rsi)
movups %xmm1,0x10(%rsi)
movups 0x20(%rdi,%rcx,8),%xmm0
movups 0x30(%rdi,%rcx,8),%xmm1
lea    (%rsi,%r12,1),%rbp
movups %xmm0,(%rsi,%r12,1)
movups %xmm1,0x10(%rsi,%r12,1)
movups 0x40(%rdi,%rcx,8),%xmm0
movups 0x50(%rdi,%rcx,8),%xmm1
lea    0x0(%rbp,%r12,1),%rbx
movups %xmm0,(%r12,%rbp,1)
movups %xmm1,0x10(%r12,%rbp,1)
movups 0x60(%rdi,%rcx,8),%xmm0
movups 0x70(%rdi,%rcx,8),%xmm1
movups %xmm0,(%r12,%rbx,1)
movups %xmm1,0x10(%r12,%rbx,1)
add    $0x10,%rcx
add    %rdx,%rsi
add    $0xfffffffffffffffc,%rax
jne    1350 <multirsampleT+0x240>
cmpq   $0x0,0x60(%rsp)
je     13ec <multirsampleT+0x2dc>
mov    0x30(%rsp),%rax
imul   %rcx,%rax
lea    (%r8,%rax,8),%rax
lea    (%rdi,%rcx,8),%rcx
xor    %esi,%esi
movups (%rcx,%rsi,1),%xmm0
movups 0x10(%rcx,%rsi,1),%xmm1
movups %xmm0,(%rax)
movups %xmm1,0x10(%rax)
add    $0x20,%rsi
add    %r12,%rax
cmp    %rsi,%r15
jne    13d0 <multirsampleT+0x2c0>
mov    0x70(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
mov    0x18(%rsp),%r10
je     12a0 <multirsampleT+0x190>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rcx,%rax
not    %rax
add    %r14,%rax
mov    0xa0(%rsp),%rbp
test   %rbp,%rbp
je     1456 <multirsampleT+0x346>
mov    0x30(%rsp),%rsi
imul   %rcx,%rsi
lea    (%r8,%rsi,8),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rsi)
add    $0x1,%rcx
add    %r13,%rsi
add    $0xffffffffffffffff,%rbp
jne    1440 <multirsampleT+0x330>
cmp    $0x3,%rax
jb     12a0 <multirsampleT+0x190>
lea    0x3(%rcx),%rax
imul   %r13,%rax
lea    0x1(%rcx),%rsi
imul   %r13,%rsi
lea    0x2(%rcx),%rbp
imul   %r13,%rbp
mov    %r13,%rbx
imul   %rcx,%rbx
mov    %r8,%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rbx,1)
movsd  0x8(%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rsi,1)
movsd  0x10(%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rbp,1)
movsd  0x18(%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rax,1)
add    $0x4,%rcx
add    %r12,%r11
cmp    %rcx,%r14
jne    1490 <multirsampleT+0x380>
jmp    12a0 <multirsampleT+0x190>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @multirsampleT(double* %0, i32 %1, i32 %2, i32* %3, i32 %4, i32 %5, double* %6) {
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store double* %0, double** %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i32* %3, i32** %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store double* %6, double** %14
%23 = load i32, i32* %10
%24 = load i32, i32* %13
%25 = mul nsw i32 %23, %24
store i32 %25, i32* %21
%26 = load i32, i32* %9
%27 = load i32, i32* %10
%28 = mul nsw i32 %26, %27
store i32 %28, i32* %22
store i32 0, i32* %17
br label %29
29: ; preds = %85, %7
%30 = load i32, i32* %17
%31 = load i32, i32* %12
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %88
33: ; preds = %29
%34 = load i32*, i32** %11
%35 = load i32, i32* %13
%36 = load i32, i32* %17
%37 = call i32 @sample(i32* %34, i32 %35, i32 %36)
store i32 %37, i32* %20
%38 = load double*, double** %8
%39 = load i32, i32* %10
%40 = load i32, i32* %20
%41 = mul nsw i32 %39, %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds double, double* %38, i64 %42
store double* %43, double** %15
%44 = load double*, double** %14
%45 = load i32, i32* %17
%46 = load i32, i32* %22
%47 = mul nsw i32 %45, %46
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds double, double* %44, i64 %48
store double* %49, double** %16
store i32 0, i32* %18
br label %50
50: ; preds = %81, %33
%51 = load i32, i32* %18
%52 = load i32, i32* %9
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %84
54: ; preds = %50
store i32 0, i32* %19
br label %55
55: ; preds = %71, %54
%56 = load i32, i32* %19
%57 = load i32, i32* %10
%58 = icmp slt i32 %56, %57
br i1 %58, label %59, label %74
59: ; preds = %55
%60 = load double*, double** %15
%61 = load i32, i32* %19
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %60, i64 %62
%64 = load double, double* %63
%65 = load double*, double** %16
%66 = load i32, i32* %19
%67 = load i32, i32* %9
%68 = mul nsw i32 %66, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %65, i64 %69
store double %64, double* %70
br label %71
71: ; preds = %59
%72 = load i32, i32* %19
%73 = add nsw i32 %72, 1
store i32 %73, i32* %19
br label %55
74: ; preds = %55
%75 = load double*, double** %16
%76 = getelementptr inbounds double, double* %75, i64 1
store double* %76, double** %16
%77 = load i32, i32* %21
%78 = load double*, double** %15
%79 = sext i32 %77 to i64
%80 = getelementptr inbounds double, double* %78, i64 %79
store double* %80, double** %15
br label %81
81: ; preds = %74
%82 = load i32, i32* %18
%83 = add nsw i32 %82, 1
store i32 %83, i32* %18
br label %50
84: ; preds = %50
br label %85
85: ; preds = %84
%86 = load i32, i32* %17
%87 = add nsw i32 %86, 1
store i32 %87, i32* %17
br label %29
88: ; preds = %29
ret void
}

LLVM IR (-O2):
define void @multirsampleT(double* nocapture %0, i32 %1, i32 %2, i32* %3, i32 %4, i32 %5, double* nocapture writeonly %6) {
%8 = icmp sgt i32 %4, 0
br i1 %8, label %9, label %188
9: ; preds = %7
%10 = mul nsw i32 %2, %1
%11 = mul nsw i32 %5, %2
%12 = icmp sgt i32 %1, 0
%13 = icmp sgt i32 %2, 0
%14 = sext i32 %11 to i64
%15 = sext i32 %1 to i64
%16 = sext i32 %10 to i64
%17 = zext i32 %4 to i64
%18 = zext i32 %2 to i64
%19 = sext i32 %2 to i64
%20 = and i64 %18, 4294967292
%21 = add nsw i64 %20, -4
%22 = lshr exact i64 %21, 2
%23 = add nuw nsw i64 %22, 1
%24 = icmp ugt i32 %2, 3
%25 = icmp eq i32 %1, 1
%26 = and i1 %24, %25
%27 = and i64 %18, 4294967292
%28 = and i64 %23, 3
%29 = icmp ult i64 %21, 12
%30 = and i64 %23, 9223372036854775804
%31 = icmp eq i64 %28, 0
%32 = icmp eq i64 %27, %18
%33 = and i64 %18, 3
%34 = icmp eq i64 %33, 0
br label %35
35: ; preds = %9, %185
%36 = phi i64 [ 0, %9 ], [ %186, %185 ]
%37 = mul i64 %36, %19
%38 = add i64 %37, %18
%39 = trunc i64 %36 to i32
%40 = tail call i32 @sample(i32* %3, i32 %5, i32 %39)
br i1 %12, label %41, label %185
41: ; preds = %35
%42 = mul nsw i64 %36, %16
%43 = getelementptr inbounds double, double* %6, i64 %42
%44 = mul nsw i32 %40, %2
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %0, i64 %45
%47 = add nsw i64 %18, %45
br label %48
48: ; preds = %41, %179
%49 = phi i64 [ 0, %41 ], [ %184, %179 ]
%50 = phi double* [ %46, %41 ], [ %181, %179 ]
%51 = phi double* [ %43, %41 ], [ %180, %179 ]
%52 = phi i32 [ 0, %41 ], [ %182, %179 ]
%53 = add i64 %37, %49
%54 = getelementptr double, double* %6, i64 %53
%55 = add i64 %38, %49
%56 = getelementptr double, double* %6, i64 %55
%57 = mul i64 %49, %14
%58 = add i64 %47, %57
%59 = getelementptr double, double* %0, i64 %58
br i1 %13, label %60, label %179
60: ; preds = %48
br i1 %26, label %61, label %139
61: ; preds = %60
%62 = icmp ult double* %54, %59
%63 = icmp ult double* %50, %56
%64 = and i1 %62, %63
br i1 %64, label %139, label %65
65: ; preds = %61
br i1 %29, label %119, label %66
66: ; preds = %65, %66
%67 = phi i64 [ %116, %66 ], [ 0, %65 ]
%68 = phi i64 [ %117, %66 ], [ 0, %65 ]
%69 = getelementptr inbounds double, double* %50, i64 %67
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = getelementptr inbounds double, double* %69, i64 2
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = mul nsw i64 %67, %15
%76 = getelementptr inbounds double, double* %51, i64 %75
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %71, <2 x double>* %77
%78 = getelementptr inbounds double, double* %76, i64 2
%79 = bitcast double* %78 to <2 x double>*
store <2 x double> %74, <2 x double>* %79
%80 = or i64 %67, 4
%81 = getelementptr inbounds double, double* %50, i64 %80
%82 = bitcast double* %81 to <2 x double>*
%83 = load <2 x double>, <2 x double>* %82
%84 = getelementptr inbounds double, double* %81, i64 2
%85 = bitcast double* %84 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = mul nsw i64 %80, %15
%88 = getelementptr inbounds double, double* %51, i64 %87
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> %83, <2 x double>* %89
%90 = getelementptr inbounds double, double* %88, i64 2
%91 = bitcast double* %90 to <2 x double>*
store <2 x double> %86, <2 x double>* %91
%92 = or i64 %67, 8
%93 = getelementptr inbounds double, double* %50, i64 %92
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = getelementptr inbounds double, double* %93, i64 2
%97 = bitcast double* %96 to <2 x double>*
%98 = load <2 x double>, <2 x double>* %97
%99 = mul nsw i64 %92, %15
%100 = getelementptr inbounds double, double* %51, i64 %99
%101 = bitcast double* %100 to <2 x double>*
store <2 x double> %95, <2 x double>* %101
%102 = getelementptr inbounds double, double* %100, i64 2
%103 = bitcast double* %102 to <2 x double>*
store <2 x double> %98, <2 x double>* %103
%104 = or i64 %67, 12
%105 = getelementptr inbounds double, double* %50, i64 %104
%106 = bitcast double* %105 to <2 x double>*
%107 = load <2 x double>, <2 x double>* %106
%108 = getelementptr inbounds double, double* %105, i64 2
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = mul nsw i64 %104, %15
%112 = getelementptr inbounds double, double* %51, i64 %111
%113 = bitcast double* %112 to <2 x double>*
store <2 x double> %107, <2 x double>* %113
%114 = getelementptr inbounds double, double* %112, i64 2
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %110, <2 x double>* %115
%116 = add nuw i64 %67, 16
%117 = add nuw i64 %68, 4
%118 = icmp eq i64 %117, %30
br i1 %118, label %119, label %66
119: ; preds = %66, %65
%120 = phi i64 [ 0, %65 ], [ %116, %66 ]
br i1 %31, label %138, label %121
121: ; preds = %119, %121
%122 = phi i64 [ %135, %121 ], [ %120, %119 ]
%123 = phi i64 [ %136, %121 ], [ 0, %119 ]
%124 = getelementptr inbounds double, double* %50, i64 %122
%125 = bitcast double* %124 to <2 x double>*
%126 = load <2 x double>, <2 x double>* %125
%127 = getelementptr inbounds double, double* %124, i64 2
%128 = bitcast double* %127 to <2 x double>*
%129 = load <2 x double>, <2 x double>* %128
%130 = mul nsw i64 %122, %15
%131 = getelementptr inbounds double, double* %51, i64 %130
%132 = bitcast double* %131 to <2 x double>*
store <2 x double> %126, <2 x double>* %132
%133 = getelementptr inbounds double, double* %131, i64 2
%134 = bitcast double* %133 to <2 x double>*
store <2 x double> %129, <2 x double>* %134
%135 = add nuw i64 %122, 4
%136 = add i64 %123, 1
%137 = icmp eq i64 %136, %28
br i1 %137, label %138, label %121
138: ; preds = %121, %119
br i1 %32, label %179, label %139
139: ; preds = %61, %60, %138
%140 = phi i64 [ 0, %61 ], [ 0, %60 ], [ %27, %138 ]
%141 = xor i64 %140, -1
%142 = add nsw i64 %141, %18
br i1 %34, label %153, label %143
143: ; preds = %139, %143
%144 = phi i64 [ %150, %143 ], [ %140, %139 ]
%145 = phi i64 [ %151, %143 ], [ 0, %139 ]
%146 = getelementptr inbounds double, double* %50, i64 %144
%147 = load double, double* %146
%148 = mul nsw i64 %144, %15
%149 = getelementptr inbounds double, double* %51, i64 %148
store double %147, double* %149
%150 = add nuw nsw i64 %144, 1
%151 = add i64 %145, 1
%152 = icmp eq i64 %151, %33
br i1 %152, label %153, label %143
153: ; preds = %143, %139
%154 = phi i64 [ %140, %139 ], [ %150, %143 ]
%155 = icmp ult i64 %142, 3
br i1 %155, label %179, label %156
156: ; preds = %153, %156
%157 = phi i64 [ %177, %156 ], [ %154, %153 ]
%158 = getelementptr inbounds double, double* %50, i64 %157
%159 = load double, double* %158
%160 = mul nsw i64 %157, %15
%161 = getelementptr inbounds double, double* %51, i64 %160
store double %159, double* %161
%162 = add nuw nsw i64 %157, 1
%163 = getelementptr inbounds double, double* %50, i64 %162
%164 = load double, double* %163
%165 = mul nsw i64 %162, %15
%166 = getelementptr inbounds double, double* %51, i64 %165
store double %164, double* %166
%167 = add nuw nsw i64 %157, 2
%168 = getelementptr inbounds double, double* %50, i64 %167
%169 = load double, double* %168
%170 = mul nsw i64 %167, %15
%171 = getelementptr inbounds double, double* %51, i64 %170
store double %169, double* %171
%172 = add nuw nsw i64 %157, 3
%173 = getelementptr inbounds double, double* %50, i64 %172
%174 = load double, double* %173
%175 = mul nsw i64 %172, %15
%176 = getelementptr inbounds double, double* %51, i64 %175
store double %174, double* %176
%177 = add nuw nsw i64 %157, 4
%178 = icmp eq i64 %177, %18
br i1 %178, label %179, label %156
179: ; preds = %153, %156, %138, %48
%180 = getelementptr inbounds double, double* %51, i64 1
%181 = getelementptr inbounds double, double* %50, i64 %14
%182 = add nuw nsw i32 %52, 1
%183 = icmp eq i32 %182, %1
%184 = add i64 %49, 1
br i1 %183, label %185, label %48
185: ; preds = %179, %35
%186 = add nuw nsw i64 %36, 1
%187 = icmp eq i64 %186, %17
br i1 %187, label %188, label %35
188: ; preds = %185, %7
ret void
}