#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 _positive_solver_rec(double **, double *, double *, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int, char *);
int /*<<< orphan*/ stderr;
int full_posdef_positive_solver_fast(double **A, double *x, double *b, int n) {
  int status = 0;
  for (int i = 0; i < n; i++) {
    A[i] += i;
  }
  status = _positive_solver_rec(A, x, b, n);
  {
    if ((status) < 0) {
      {
        {
          fprintf(stderr, "Line %3d of File %s \n", 193,
                  "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                  "outputs/2022-01-22/02-19-57/repos/NerdWalletOSS/Q/refs/"
                  "heads/master/OPERATORS/AX_EQUALS_B/src/positive_solver.c");
        };
        status = (status);
        goto BYE;
      }
    }
  };
BYE:
  for (int i = 0; i < n; i++) {
    A[i] -= i;
  }
  return status;
}


x86 assembly (clang, -O0):
<full_posdef_positive_solver_fast>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    117c <full_posdef_positive_solver_fast+0x5c>
mov    -0x24(%rbp),%esi
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq %esi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1145 <full_posdef_positive_solver_fast+0x25>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
call   1040 <_positive_solver_rec@plt>
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jge    11c9 <full_posdef_positive_solver_fast+0xa9>
mov    0x2e3c(%rip),%rax
mov    (%rax),%edi
lea    0xe53(%rip),%rsi
mov    $0xc1,%edx
lea    0xe5d(%rip),%rcx
call   1030 <fprintf@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    11ce <full_posdef_positive_solver_fast+0xae>
jmp    11ce <full_posdef_positive_solver_fast+0xae>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1211 <full_posdef_positive_solver_fast+0xf1>
mov    -0x28(%rbp),%esi
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq %esi,%rdi
xor    %esi,%esi
sub    %rdi,%rsi
shl    $0x3,%rsi
add    %rsi,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11d5 <full_posdef_positive_solver_fast+0xb5>
mov    -0x20(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<full_posdef_positive_solver_fast>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %ecx,%r15d
mov    %rdi,%rbx
mov    %ecx,%ebp
test   %ecx,%ecx
jle    125e <full_posdef_positive_solver_fast+0x13e>
cmp    $0x4,%r15d
jae    1144 <full_posdef_positive_solver_fast+0x24>
xor    %eax,%eax
jmp    1239 <full_posdef_positive_solver_fast+0x119>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     13ef <full_posdef_positive_solver_fast+0x2cf>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xe90(%rip),%xmm0
xor    %ecx,%ecx
movdqa 0xe95(%rip),%xmm8
movdqa 0xe9c(%rip),%xmm9
movdqa 0xea4(%rip),%xmm3
movdqa 0xeac(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm5
psllq  $0x3,%xmm5
movdqu (%rbx,%rcx,8),%xmm6
movdqu 0x10(%rbx,%rcx,8),%xmm7
movdqu 0x20(%rbx,%rcx,8),%xmm1
movdqu 0x30(%rbx,%rcx,8),%xmm2
paddq  %xmm5,%xmm6
paddq  %xmm5,%xmm7
paddq  %xmm8,%xmm7
movdqu %xmm6,(%rbx,%rcx,8)
movdqu %xmm7,0x10(%rbx,%rcx,8)
paddq  %xmm5,%xmm1
paddq  %xmm9,%xmm1
paddq  %xmm5,%xmm2
paddq  %xmm3,%xmm2
movdqu %xmm1,0x20(%rbx,%rcx,8)
movdqu %xmm2,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
paddq  %xmm4,%xmm0
add    $0xfffffffffffffffe,%rdi
jne    11a0 <full_posdef_positive_solver_fast+0x80>
test   $0x1,%r8b
je     1234 <full_posdef_positive_solver_fast+0x114>
movdqu (%rbx,%rcx,8),%xmm1
movdqu 0x10(%rbx,%rcx,8),%xmm2
psllq  $0x3,%xmm0
paddq  %xmm0,%xmm1
paddq  %xmm2,%xmm0
paddq  0xde7(%rip),%xmm0
movdqu %xmm1,(%rbx,%rcx,8)
movdqu %xmm0,0x10(%rbx,%rcx,8)
cmp    %rbp,%rax
je     125e <full_posdef_positive_solver_fast+0x13e>
mov    %rbp,%rcx
sub    %rax,%rcx
shl    $0x3,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %rax,(%rbx,%rax,1)
add    $0x8,%rax
add    $0xffffffffffffffff,%rcx
jne    1250 <full_posdef_positive_solver_fast+0x130>
mov    %rbx,%rdi
mov    %r15d,%ecx
call   1040 <_positive_solver_rec@plt>
mov    %eax,%r14d
test   %eax,%eax
jns    1291 <full_posdef_positive_solver_fast+0x171>
mov    0x2d69(%rip),%rax
mov    (%rax),%edi
lea    0xe00(%rip),%rsi
lea    0xe0f(%rip),%rcx
mov    $0xc1,%edx
call   1030 <fprintf@plt>
test   %r15d,%r15d
jle    13e1 <full_posdef_positive_solver_fast+0x2c1>
cmp    $0x4,%r15d
jae    12a7 <full_posdef_positive_solver_fast+0x187>
xor    %eax,%eax
jmp    13bc <full_posdef_positive_solver_fast+0x29c>
mov    %ebp,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1408 <full_posdef_positive_solver_fast+0x2e8>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0xd2d(%rip),%xmm0
xor    %ecx,%ecx
movdqa 0xd72(%rip),%xmm8
movdqa 0xd79(%rip),%xmm9
movdqa 0xd81(%rip),%xmm3
movdqa 0xd49(%rip),%xmm4
nopw   0x0(%rax,%rax,1)
movdqa %xmm8,%xmm5
psubq  %xmm0,%xmm5
movdqa %xmm0,%xmm6
psllq  $0x3,%xmm6
movdqu (%rbx,%rcx,8),%xmm7
psubq  %xmm6,%xmm7
movdqu 0x10(%rbx,%rcx,8),%xmm6
movdqu 0x20(%rbx,%rcx,8),%xmm1
movdqu 0x30(%rbx,%rcx,8),%xmm2
psllq  $0x3,%xmm5
paddq  %xmm6,%xmm5
movdqu %xmm7,(%rbx,%rcx,8)
movdqu %xmm5,0x10(%rbx,%rcx,8)
movdqa %xmm9,%xmm5
psubq  %xmm0,%xmm5
movdqa %xmm3,%xmm6
psubq  %xmm0,%xmm6
psllq  $0x3,%xmm5
paddq  %xmm1,%xmm5
psllq  $0x3,%xmm6
paddq  %xmm2,%xmm6
movdqu %xmm5,0x20(%rbx,%rcx,8)
movdqu %xmm6,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
paddq  %xmm4,%xmm0
add    $0xfffffffffffffffe,%rsi
jne    1300 <full_posdef_positive_solver_fast+0x1e0>
test   $0x1,%dl
je     13b7 <full_posdef_positive_solver_fast+0x297>
movdqu (%rbx,%rcx,8),%xmm1
movdqu 0x10(%rbx,%rcx,8),%xmm2
movdqa 0xcba(%rip),%xmm3
psubq  %xmm0,%xmm3
psllq  $0x3,%xmm0
psubq  %xmm0,%xmm1
psllq  $0x3,%xmm3
paddq  %xmm2,%xmm3
movdqu %xmm1,(%rbx,%rcx,8)
movdqu %xmm3,0x10(%rbx,%rcx,8)
cmp    %rbp,%rax
je     13e1 <full_posdef_positive_solver_fast+0x2c1>
lea    0x0(,%rax,8),%rcx
neg    %rcx
nopw   0x0(%rax,%rax,1)
add    %rcx,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xfffffffffffffff8,%rcx
cmp    %rax,%rbp
jne    13d0 <full_posdef_positive_solver_fast+0x2b0>
mov    %r14d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0xc09(%rip),%xmm0
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1209 <full_posdef_positive_solver_fast+0xe9>
jmp    1234 <full_posdef_positive_solver_fast+0x114>
movdqa 0xbf0(%rip),%xmm0
xor    %ecx,%ecx
test   $0x1,%dl
jne    1383 <full_posdef_positive_solver_fast+0x263>
jmp    13b7 <full_posdef_positive_solver_fast+0x297>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [22 x i8] c"Line %3d of File %s \0A\00"
@.str.1 = [168 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/NerdWalletOSS/Q/refs/heads/master/OPERATORS/AX_EQUALS_B/src/positive_solver.c\00"
define i32 @full_posdef_positive_solver_fast(double** %0, double* %1, double* %2, i32 %3) {
%5 = alloca double**
%6 = alloca double*
%7 = alloca double*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store double** %0, double*** %5
store double* %1, double** %6
store double* %2, double** %7
store i32 %3, i32* %8
store i32 0, i32* %9
store i32 0, i32* %10
br label %12
12: ; preds = %25, %4
%13 = load i32, i32* %10
%14 = load i32, i32* %8
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %28
16: ; preds = %12
%17 = load i32, i32* %10
%18 = load double**, double*** %5
%19 = load i32, i32* %10
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds double*, double** %18, i64 %20
%22 = load double*, double** %21
%23 = sext i32 %17 to i64
%24 = getelementptr inbounds double, double* %22, i64 %23
store double* %24, double** %21
br label %25
25: ; preds = %16
%26 = load i32, i32* %10
%27 = add nsw i32 %26, 1
store i32 %27, i32* %10
br label %12
28: ; preds = %12
%29 = load double**, double*** %5
%30 = load double*, double** %6
%31 = load double*, double** %7
%32 = load i32, i32* %8
%33 = call i32 @_positive_solver_rec(double** %29, double* %30, double* %31, i32 %32)
store i32 %33, i32* %9
%34 = load i32, i32* %9
%35 = icmp slt i32 %34, 0
br i1 %35, label %36, label %40
36: ; preds = %28
%37 = load i32, i32* @stderr
%38 = call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i32 193, i8* getelementptr inbounds ([168 x i8], [168 x i8]* @.str.1, i64 0, i64 0))
%39 = load i32, i32* %9
store i32 %39, i32* %9
br label %41
40: ; preds = %28
br label %41
41: ; preds = %40, %36
store i32 0, i32* %11
br label %42
42: ; preds = %56, %41
%43 = load i32, i32* %11
%44 = load i32, i32* %8
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %59
46: ; preds = %42
%47 = load i32, i32* %11
%48 = load double**, double*** %5
%49 = load i32, i32* %11
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double*, double** %48, i64 %50
%52 = load double*, double** %51
%53 = sext i32 %47 to i64
%54 = sub i64 0, %53
%55 = getelementptr inbounds double, double* %52, i64 %54
store double* %55, double** %51
br label %56
56: ; preds = %46
%57 = load i32, i32* %11
%58 = add nsw i32 %57, 1
store i32 %58, i32* %11
br label %42
59: ; preds = %42
%60 = load i32, i32* %9
ret i32 %60
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [22 x i8] c"Line %3d of File %s \0A\00"
@.str.1 = [168 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/NerdWalletOSS/Q/refs/heads/master/OPERATORS/AX_EQUALS_B/src/positive_solver.c\00"
define i32 @full_posdef_positive_solver_fast(double** %0, double* %1, double* %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %70
6: ; preds = %4
%7 = zext i32 %3 to i64
%8 = icmp ult i32 %3, 4
br i1 %8, label %68, label %9
9: ; preds = %6
%10 = and i64 %7, 4294967292
%11 = add nsw i64 %10, -4
%12 = lshr exact i64 %11, 2
%13 = add nuw nsw i64 %12, 1
%14 = and i64 %13, 1
%15 = icmp eq i64 %11, 0
br i1 %15, label %50, label %16
16: ; preds = %9
%17 = and i64 %13, 9223372036854775806
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %46, %18 ]
%20 = phi <2 x i64> [ <i64 0, i64 1>, %16 ], [ %47, %18 ]
%21 = phi i64 [ 0, %16 ], [ %48, %18 ]
%22 = add <2 x i64> %20, <i64 2, i64 2>
%23 = getelementptr inbounds double*, double** %0, i64 %19
%24 = bitcast double** %23 to <2 x double*>*
%25 = load <2 x double*>, <2 x double*>* %24
%26 = getelementptr inbounds double*, double** %23, i64 2
%27 = bitcast double** %26 to <2 x double*>*
%28 = load <2 x double*>, <2 x double*>* %27
%29 = getelementptr inbounds double, <2 x double*> %25, <2 x i64> %20
%30 = getelementptr inbounds double, <2 x double*> %28, <2 x i64> %22
%31 = bitcast double** %23 to <2 x double*>*
store <2 x double*> %29, <2 x double*>* %31
%32 = bitcast double** %26 to <2 x double*>*
store <2 x double*> %30, <2 x double*>* %32
%33 = or i64 %19, 4
%34 = add <2 x i64> %20, <i64 4, i64 4>
%35 = add <2 x i64> %20, <i64 6, i64 6>
%36 = getelementptr inbounds double*, double** %0, i64 %33
%37 = bitcast double** %36 to <2 x double*>*
%38 = load <2 x double*>, <2 x double*>* %37
%39 = getelementptr inbounds double*, double** %36, i64 2
%40 = bitcast double** %39 to <2 x double*>*
%41 = load <2 x double*>, <2 x double*>* %40
%42 = getelementptr inbounds double, <2 x double*> %38, <2 x i64> %34
%43 = getelementptr inbounds double, <2 x double*> %41, <2 x i64> %35
%44 = bitcast double** %36 to <2 x double*>*
store <2 x double*> %42, <2 x double*>* %44
%45 = bitcast double** %39 to <2 x double*>*
store <2 x double*> %43, <2 x double*>* %45
%46 = add nuw i64 %19, 8
%47 = add <2 x i64> %20, <i64 8, i64 8>
%48 = add i64 %21, 2
%49 = icmp eq i64 %48, %17
br i1 %49, label %50, label %18
50: ; preds = %18, %9
%51 = phi i64 [ 0, %9 ], [ %46, %18 ]
%52 = phi <2 x i64> [ <i64 0, i64 1>, %9 ], [ %47, %18 ]
%53 = icmp eq i64 %14, 0
br i1 %53, label %66, label %54
54: ; preds = %50
%55 = add <2 x i64> %52, <i64 2, i64 2>
%56 = getelementptr inbounds double*, double** %0, i64 %51
%57 = bitcast double** %56 to <2 x double*>*
%58 = load <2 x double*>, <2 x double*>* %57
%59 = getelementptr inbounds double*, double** %56, i64 2
%60 = bitcast double** %59 to <2 x double*>*
%61 = load <2 x double*>, <2 x double*>* %60
%62 = getelementptr inbounds double, <2 x double*> %58, <2 x i64> %52
%63 = getelementptr inbounds double, <2 x double*> %61, <2 x i64> %55
%64 = bitcast double** %56 to <2 x double*>*
store <2 x double*> %62, <2 x double*>* %64
%65 = bitcast double** %59 to <2 x double*>*
store <2 x double*> %63, <2 x double*>* %65
br label %66
66: ; preds = %50, %54
%67 = icmp eq i64 %10, %7
br i1 %67, label %70, label %68
68: ; preds = %6, %66
%69 = phi i64 [ 0, %6 ], [ %10, %66 ]
br label %73
70: ; preds = %73, %66, %4
%71 = tail call i32 @_positive_solver_rec(double** %0, double* %1, double* %2, i32 %3)
%72 = icmp slt i32 %71, 0
br i1 %72, label %80, label %83
73: ; preds = %68, %73
%74 = phi i64 [ %78, %73 ], [ %69, %68 ]
%75 = getelementptr inbounds double*, double** %0, i64 %74
%76 = load double*, double** %75
%77 = getelementptr inbounds double, double* %76, i64 %74
store double* %77, double** %75
%78 = add nuw nsw i64 %74, 1
%79 = icmp eq i64 %78, %7
br i1 %79, label %70, label %73
80: ; preds = %70
%81 = load i32, i32* @stderr
%82 = tail call i32 @fprintf(i32 %81, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0), i32 193, i8* getelementptr inbounds ([168 x i8], [168 x i8]* @.str.1, i64 0, i64 0))
br label %83
83: ; preds = %70, %80
br i1 %5, label %84, label %150
84: ; preds = %83
%85 = zext i32 %3 to i64
%86 = icmp ult i32 %3, 4
br i1 %86, label %148, label %87
87: ; preds = %84
%88 = and i64 %85, 4294967292
%89 = add nsw i64 %88, -4
%90 = lshr exact i64 %89, 2
%91 = add nuw nsw i64 %90, 1
%92 = and i64 %91, 1
%93 = icmp eq i64 %89, 0
br i1 %93, label %129, label %94
94: ; preds = %87
%95 = and i64 %91, 9223372036854775806
br label %96
96: ; preds = %96, %94
%97 = phi i64 [ 0, %94 ], [ %125, %96 ]
%98 = phi <2 x i64> [ <i64 0, i64 1>, %94 ], [ %126, %96 ]
%99 = phi i64 [ 0, %94 ], [ %127, %96 ]
%100 = getelementptr inbounds double*, double** %0, i64 %97
%101 = bitcast double** %100 to <2 x double*>*
%102 = load <2 x double*>, <2 x double*>* %101
%103 = getelementptr inbounds double*, double** %100, i64 2
%104 = bitcast double** %103 to <2 x double*>*
%105 = load <2 x double*>, <2 x double*>* %104
%106 = sub nsw <2 x i64> zeroinitializer, %98
%107 = sub <2 x i64> <i64 -2, i64 -2>, %98
%108 = getelementptr inbounds double, <2 x double*> %102, <2 x i64> %106
%109 = getelementptr inbounds double, <2 x double*> %105, <2 x i64> %107
%110 = bitcast double** %100 to <2 x double*>*
store <2 x double*> %108, <2 x double*>* %110
%111 = bitcast double** %103 to <2 x double*>*
store <2 x double*> %109, <2 x double*>* %111
%112 = or i64 %97, 4
%113 = getelementptr inbounds double*, double** %0, i64 %112
%114 = bitcast double** %113 to <2 x double*>*
%115 = load <2 x double*>, <2 x double*>* %114
%116 = getelementptr inbounds double*, double** %113, i64 2
%117 = bitcast double** %116 to <2 x double*>*
%118 = load <2 x double*>, <2 x double*>* %117
%119 = sub <2 x i64> <i64 -4, i64 -4>, %98
%120 = sub <2 x i64> <i64 -6, i64 -6>, %98
%121 = getelementptr inbounds double, <2 x double*> %115, <2 x i64> %119
%122 = getelementptr inbounds double, <2 x double*> %118, <2 x i64> %120
%123 = bitcast double** %113 to <2 x double*>*
store <2 x double*> %121, <2 x double*>* %123
%124 = bitcast double** %116 to <2 x double*>*
store <2 x double*> %122, <2 x double*>* %124
%125 = add nuw i64 %97, 8
%126 = add <2 x i64> %98, <i64 8, i64 8>
%127 = add i64 %99, 2
%128 = icmp eq i64 %127, %95
br i1 %128, label %129, label %96
129: ; preds = %96, %87
%130 = phi i64 [ 0, %87 ], [ %125, %96 ]
%131 = phi <2 x i64> [ <i64 0, i64 1>, %87 ], [ %126, %96 ]
%132 = icmp eq i64 %92, 0
br i1 %132, label %146, label %133
133: ; preds = %129
%134 = getelementptr inbounds double*, double** %0, i64 %130
%135 = bitcast double** %134 to <2 x double*>*
%136 = load <2 x double*>, <2 x double*>* %135
%137 = getelementptr inbounds double*, double** %134, i64 2
%138 = bitcast double** %137 to <2 x double*>*
%139 = load <2 x double*>, <2 x double*>* %138
%140 = sub nsw <2 x i64> zeroinitializer, %131
%141 = sub <2 x i64> <i64 -2, i64 -2>, %131
%142 = getelementptr inbounds double, <2 x double*> %136, <2 x i64> %140
%143 = getelementptr inbounds double, <2 x double*> %139, <2 x i64> %141
%144 = bitcast double** %134 to <2 x double*>*
store <2 x double*> %142, <2 x double*>* %144
%145 = bitcast double** %137 to <2 x double*>*
store <2 x double*> %143, <2 x double*>* %145
br label %146
146: ; preds = %129, %133
%147 = icmp eq i64 %88, %85
br i1 %147, label %150, label %148
148: ; preds = %84, %146
%149 = phi i64 [ 0, %84 ], [ %88, %146 ]
br label %151
150: ; preds = %151, %146, %83
ret i32 %71
151: ; preds = %148, %151
%152 = phi i64 [ %157, %151 ], [ %149, %148 ]
%153 = getelementptr inbounds double*, double** %0, i64 %152
%154 = load double*, double** %153
%155 = sub nsw i64 0, %152
%156 = getelementptr inbounds double, double* %154, i64 %155
store double* %156, double** %153
%157 = add nuw nsw i64 %152, 1
%158 = icmp eq i64 %157, %85
br i1 %158, label %150, label %151
}