#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 */
scalar_t__ malloc(int);
double **createAugmentedMatrix(double *sparse_matrix, double *r, int N) {
  double **augmented_matrix = (double **)malloc(N * sizeof(double *));
  for (int i = 0; i < N; i++) {
    augmented_matrix[i] = (double *)malloc((N + 1) * sizeof(double));
  }
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
      augmented_matrix[i][j] = *(sparse_matrix + i * N + j);
    }
  }
  for (int i = 0; i < N; i++) {
    augmented_matrix[i][N] = *(r + i);
  }
  return augmented_matrix;
}


x86 assembly (clang, -O0):
<createAugmentedMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1179 <createAugmentedMatrix+0x69>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    113d <createAugmentedMatrix+0x2d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11f3 <createAugmentedMatrix+0xe3>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11e0 <createAugmentedMatrix+0xd0>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1193 <createAugmentedMatrix+0x83>
jmp    11e5 <createAugmentedMatrix+0xd5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1180 <createAugmentedMatrix+0x70>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1236 <createAugmentedMatrix+0x126>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fa <createAugmentedMatrix+0xea>
mov    -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<createAugmentedMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edx,%ebx
mov    %rsi,%r14
mov    %rdi,0x8(%rsp)
lea    0x0(,%rbx,8),%ebp
mov    %ebp,%edi
call   1030 <malloc@plt>
mov    %rax,%r15
test   %ebx,%ebx
jle    1428 <createAugmentedMatrix+0x318>
movslq %ebx,%r13
add    $0x8,%ebp
mov    %rbx,(%rsp)
mov    %ebx,%r12d
xor    %ebx,%ebx
mov    %ebp,%edi
call   1030 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1150 <createAugmentedMatrix+0x40>
mov    (%rsp),%rbp
test   %ebp,%ebp
jle    1428 <createAugmentedMatrix+0x318>
mov    %r14,0x10(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x30(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
lea    -0x1(%r12),%r10
mov    %eax,%edi
and    $0x3,%edi
and    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rsp)
mov    %r12d,%r14d
and    $0x3,%r14d
mov    0x8(%rsp),%rbx
lea    0x70(%rbx),%rdx
lea    0x0(,%r13,8),%rsi
mov    %rdi,0x20(%rsp)
shl    $0x5,%rdi
xor    %ecx,%ecx
mov    %rbx,%r8
jmp    11e8 <createAugmentedMatrix+0xd8>
nopl   0x0(%rax)
add    $0x1,%rcx
add    %rsi,%rdx
add    %rsi,%r8
cmp    %r12,%rcx
mov    0x8(%rsp),%rbx
je     1384 <createAugmentedMatrix+0x274>
mov    (%r15,%rcx,8),%r9
cmp    $0x4,%ebp
jae    1200 <createAugmentedMatrix+0xf0>
xor    %r11d,%r11d
jmp    1310 <createAugmentedMatrix+0x200>
nopl   0x0(%rax)
mov    %rcx,%rax
imul   %r13,%rax
lea    (%rax,%r12,1),%rbp
lea    (%rbx,%rbp,8),%rbp
cmp    %rbp,%r9
jae    1230 <createAugmentedMatrix+0x120>
lea    (%rbx,%rax,8),%rax
lea    (%r9,%r12,8),%rbp
cmp    %rbp,%rax
jae    1230 <createAugmentedMatrix+0x120>
xor    %r11d,%r11d
mov    (%rsp),%rbp
jmp    1310 <createAugmentedMatrix+0x200>
nopl   (%rax)
cmpq   $0xc,0x28(%rsp)
jae    123c <createAugmentedMatrix+0x12c>
xor    %eax,%eax
jmp    12b0 <createAugmentedMatrix+0x1a0>
mov    0x18(%rsp),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%rdx,%rax,8),%xmm0
movups -0x60(%rdx,%rax,8),%xmm1
movups %xmm0,(%r9,%rax,8)
movups %xmm1,0x10(%r9,%rax,8)
movups -0x50(%rdx,%rax,8),%xmm0
movups -0x40(%rdx,%rax,8),%xmm1
movups %xmm0,0x20(%r9,%rax,8)
movups %xmm1,0x30(%r9,%rax,8)
movups -0x30(%rdx,%rax,8),%xmm0
movups -0x20(%rdx,%rax,8),%xmm1
movups %xmm0,0x40(%r9,%rax,8)
movups %xmm1,0x50(%r9,%rax,8)
movups -0x10(%rdx,%rax,8),%xmm0
movups (%rdx,%rax,8),%xmm1
movups %xmm0,0x60(%r9,%rax,8)
movups %xmm1,0x70(%r9,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rbp
jne    1250 <createAugmentedMatrix+0x140>
cmpq   $0x0,0x20(%rsp)
je     12ec <createAugmentedMatrix+0x1dc>
lea    (%r9,%rax,8),%rbp
add    $0x10,%rbp
lea    (%r8,%rax,8),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rbx,1),%xmm0
movups 0x10(%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdi
jne    12d0 <createAugmentedMatrix+0x1c0>
mov    0x30(%rsp),%rax
mov    %rax,%r11
cmp    %r12,%rax
mov    (%rsp),%rbp
je     11d0 <createAugmentedMatrix+0xc0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r10,%rax
sub    %r11,%rax
test   %r14,%r14
je     1336 <createAugmentedMatrix+0x226>
mov    %r14,%rbx
xchg   %ax,%ax
movsd  (%r8,%r11,8),%xmm0
movsd  %xmm0,(%r9,%r11,8)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbx
jne    1320 <createAugmentedMatrix+0x210>
cmp    $0x3,%rax
jb     11d0 <createAugmentedMatrix+0xc0>
movsd  (%r8,%r11,8),%xmm0
movsd  %xmm0,(%r9,%r11,8)
movsd  0x8(%r8,%r11,8),%xmm0
movsd  %xmm0,0x8(%r9,%r11,8)
movsd  0x10(%r8,%r11,8),%xmm0
movsd  %xmm0,0x10(%r9,%r11,8)
movsd  0x18(%r8,%r11,8),%xmm0
movsd  %xmm0,0x18(%r9,%r11,8)
add    $0x4,%r11
cmp    %r11,%r12
jne    1340 <createAugmentedMatrix+0x230>
jmp    11d0 <createAugmentedMatrix+0xc0>
test   %ebp,%ebp
mov    0x10(%rsp),%rsi
jle    1428 <createAugmentedMatrix+0x318>
mov    %r12d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r10
jae    13a1 <createAugmentedMatrix+0x291>
xor    %eax,%eax
jmp    13fb <createAugmentedMatrix+0x2eb>
and    $0xfffffffc,%r12d
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
mov    (%r15,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r13,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mov    0x8(%r15,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r13,8)
movsd  0x10(%rsi,%rax,8),%xmm0
mov    0x10(%r15,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r13,8)
movsd  0x18(%rsi,%rax,8),%xmm0
mov    0x18(%r15,%rax,8),%rdx
movsd  %xmm0,(%rdx,%r13,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    13b0 <createAugmentedMatrix+0x2a0>
test   %rcx,%rcx
je     1428 <createAugmentedMatrix+0x318>
lea    (%r15,%rax,8),%rdx
lea    (%rsi,%rax,8),%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm0
mov    (%rdx,%rsi,8),%rdi
movsd  %xmm0,(%rdi,%r13,8)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1410 <createAugmentedMatrix+0x300>
mov    %r15,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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