#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 /*<<< orphan*/ _normalize_all(double *, int);
double _sum_row(double *, int, int);
double _update_step(double, double, double, double, double, double, int);
double genbet(double, double);
scalar_t__ is_positive(double);
void _update(double *C, double *sumC, double *X, int n, int n_step) {
  int iter, i, j;
  double tmp1, tmp2;
  for (iter = 0; iter < n_step; iter++) {
    for (i = 0; i < n; i++) {
      for (j = 0; j <= i; j++) {
        if (C[i * n + j] + C[j * n + i] > 0) {
          if (i == j) {
            if (is_positive(C[i * n + i]) &&
                is_positive(sumC[i] - C[i * n + i])) {
              tmp1 = genbet(C[i * n + i], sumC[i] - C[i * n + i]);
              tmp2 = tmp1 / (1 - tmp1) * (_sum_row(X, n, i) - X[i * n + i]);
              if (is_positive(tmp2)) {
                X[i * n + i] = tmp2;
              }
            }
          } else {
            tmp1 = _sum_row(X, n, i) - X[i * n + j];
            tmp2 = _sum_row(X, n, j) - X[j * n + i];
            X[i * n + j] =
                _update_step(X[i * n + j], tmp1, tmp2,
                             C[i * n + j] + C[j * n + i], sumC[i], sumC[j], 1);
            X[j * n + i] = X[i * n + j];
          }
        }
      }
    }
    _normalize_all(X, n);
  }
}


x86 assembly (clang, -O0):
<_update>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1458 <_update+0x308>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    143e <_update+0x2ee>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     142b <_update+0x2db>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1418 <_update+0x2c8>
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    130d <_update+0x1bd>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <is_positive@plt>
cmp    $0x0,%rax
je     1308 <_update+0x1b8>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1060 <is_positive@plt>
cmp    $0x0,%rax
je     1308 <_update+0x1b8>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
call   1030 <genbet@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  0xd70(%rip),%xmm1
subsd  -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <_sum_row@plt>
movaps %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1060 <is_positive@plt>
cmp    $0x0,%rax
je     1303 <_update+0x1b3>
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1308 <_update+0x1b8>
jmp    1413 <_update+0x2c3>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <_sum_row@plt>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x2c(%rbp),%edx
call   1040 <_sum_row@plt>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    $0x1,%edi
call   1050 <_update_step@plt>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1418 <_update+0x2c8>
jmp    141d <_update+0x2cd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1198 <_update+0x48>
jmp    1430 <_update+0x2e0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1185 <_update+0x35>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1070 <_normalize_all@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1172 <_update+0x22>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_update>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rdx,0x8(%rsp)
mov    %rsi,0x28(%rsp)
mov    %r8d,0x34(%rsp)
test   %r8d,%r8d
jle    13dd <_update+0x28d>
mov    %ecx,%ebx
mov    %rdi,%r13
movslq %ecx,%rcx
mov    %ecx,%eax
mov    %rax,0x68(%rsp)
mov    %rcx,0x50(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x60(%rsp)
xor    %eax,%eax
mov    %ebx,0x4(%rsp)
mov    %rdi,0x70(%rsp)
jmp    11d2 <_update+0x82>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%rdi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
call   1070 <_normalize_all@plt>
mov    0x58(%rsp),%rax
add    $0x1,%eax
cmp    0x34(%rsp),%eax
je     13dd <_update+0x28d>
mov    %rax,0x58(%rsp)
test   %ebx,%ebx
jle    11b0 <_update+0x60>
mov    0x8(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    %r13,%r12
xor    %r15d,%r15d
jmp    1207 <_update+0xb7>
nopl   (%rax)
mov    0x60(%rsp),%rax
add    %rax,%r12
add    %rax,0x38(%rsp)
mov    %rbp,%r15
cmp    0x68(%rsp),%rbp
je     11b0 <_update+0x60>
mov    %r15,%rax
imul   0x50(%rsp),%rax
add    %r15,%rax
mov    %rax,0x20(%rsp)
lea    0x1(%r15),%rbp
mov    %r15,%rbx
xor    %r14d,%r14d
mov    %r15,0x18(%rsp)
mov    %rbp,0x40(%rsp)
mov    %r12,0x48(%rsp)
jmp    12f2 <_update+0x1a2>
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rsp),%r15
mov    %r15,%rdi
mov    0x4(%rsp),%r13d
mov    %r13d,%esi
mov    0x18(%rsp),%rdx
call   1040 <_sum_row@plt>
mov    0x38(%rsp),%r12
subsd  (%r12,%r14,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r15,%rdi
mov    %r13d,%esi
mov    0x70(%rsp),%r13
mov    %r14d,%edx
call   1040 <_sum_row@plt>
movapd %xmm0,%xmm2
subsd  (%r15,%rbx,8),%xmm2
movsd  (%r12,%r14,8),%xmm0
mov    0x48(%rsp),%rax
movsd  (%rax,%r14,8),%xmm3
addsd  0x0(%r13,%rbx,8),%xmm3
mov    0x28(%rsp),%rax
mov    0x18(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  (%rax,%r14,8),%xmm5
movsd  0x10(%rsp),%xmm1
mov    $0x1,%edi
call   1050 <_update_step@plt>
movsd  %xmm0,(%r12,%r14,8)
mov    0x48(%rsp),%r12
movsd  %xmm0,(%r15,%rbx,8)
mov    0x40(%rsp),%rbp
mov    0x18(%rsp),%r15
add    $0x1,%r14
add    0x50(%rsp),%rbx
cmp    %r14,%rbp
je     11f0 <_update+0xa0>
movsd  (%r12,%r14,8),%xmm0
addsd  0x0(%r13,%rbx,8),%xmm0
ucomisd 0xd01(%rip),%xmm0
jbe    12e0 <_update+0x190>
cmp    %r14,%r15
jne    1240 <_update+0xf0>
mov    0x20(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
call   1060 <is_positive@plt>
test   %rax,%rax
je     12e0 <_update+0x190>
mov    0x28(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
mov    0x20(%rsp),%rax
subsd  0x0(%r13,%rax,8),%xmm0
call   1060 <is_positive@plt>
test   %rax,%rax
je     12e0 <_update+0x190>
mov    0x20(%rsp),%rbp
movsd  0x0(%r13,%rbp,8),%xmm0
mov    0x28(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
subsd  %xmm0,%xmm1
call   1030 <genbet@plt>
movapd %xmm0,%xmm1
movsd  0xc8b(%rip),%xmm0
subsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
mov    0x8(%rsp),%r15
mov    %r15,%rdi
mov    0x4(%rsp),%esi
mov    0x18(%rsp),%rdx
call   1040 <_sum_row@plt>
subsd  (%r15,%rbp,8),%xmm0
mov    0x40(%rsp),%rbp
mov    0x18(%rsp),%r15
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1060 <is_positive@plt>
test   %rax,%rax
je     12e0 <_update+0x190>
mov    0x8(%rsp),%rax
mov    0x20(%rsp),%rcx
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12e0 <_update+0x190>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @_update(double* nocapture %0, double* nocapture %1, double* %2, i32 %3, i32 %4) {
%6 = icmp sgt i32 %4, 0
br i1 %6, label %7, label %89
7: ; preds = %5
%8 = icmp sgt i32 %3, 0
%9 = sext i32 %3 to i64
%10 = zext i32 %3 to i64
br label %11
11: ; preds = %7, %85
%12 = phi i32 [ 0, %7 ], [ %87, %85 ]
br i1 %8, label %13, label %85
13: ; preds = %11, %81
%14 = phi i64 [ %82, %81 ], [ 0, %11 ]
%15 = phi i64 [ %83, %81 ], [ 1, %11 ]
%16 = mul nsw i64 %14, %9
%17 = getelementptr inbounds double, double* %1, i64 %14
%18 = add nsw i64 %16, %14
%19 = getelementptr inbounds double, double* %0, i64 %18
%20 = getelementptr inbounds double, double* %2, i64 %18
%21 = trunc i64 %14 to i32
%22 = trunc i64 %14 to i32
br label %23
23: ; preds = %13, %78
%24 = phi i64 [ 0, %13 ], [ %79, %78 ]
%25 = add nsw i64 %24, %16
%26 = getelementptr inbounds double, double* %0, i64 %25
%27 = load double, double* %26
%28 = mul nsw i64 %24, %9
%29 = add nsw i64 %28, %14
%30 = getelementptr inbounds double, double* %0, i64 %29
%31 = load double, double* %30
%32 = fadd double %27, %31
%33 = fcmp ogt double %32, 0.000000e+00
br i1 %33, label %34, label %78
34: ; preds = %23
%35 = icmp eq i64 %14, %24
br i1 %35, label %36, label %60
36: ; preds = %34
%37 = load double, double* %19
%38 = tail call i64 @is_positive(double %37)
%39 = icmp eq i64 %38, 0
br i1 %39, label %78, label %40
40: ; preds = %36
%41 = load double, double* %17
%42 = load double, double* %19
%43 = fsub double %41, %42
%44 = tail call i64 @is_positive(double %43)
%45 = icmp eq i64 %44, 0
br i1 %45, label %78, label %46
46: ; preds = %40
%47 = load double, double* %19
%48 = load double, double* %17
%49 = fsub double %48, %47
%50 = tail call double @genbet(double %47, double %49)
%51 = fsub double 1.000000e+00, %50
%52 = fdiv double %50, %51
%53 = tail call double @_sum_row(double* %2, i32 %3, i32 %22)
%54 = load double, double* %20
%55 = fsub double %53, %54
%56 = fmul double %52, %55
%57 = tail call i64 @is_positive(double %56)
%58 = icmp eq i64 %57, 0
br i1 %58, label %78, label %59
59: ; preds = %46
store double %56, double* %20
br label %78
60: ; preds = %34
%61 = tail call double @_sum_row(double* %2, i32 %3, i32 %21)
%62 = getelementptr inbounds double, double* %2, i64 %25
%63 = load double, double* %62
%64 = fsub double %61, %63
%65 = trunc i64 %24 to i32
%66 = tail call double @_sum_row(double* %2, i32 %3, i32 %65)
%67 = getelementptr inbounds double, double* %2, i64 %29
%68 = load double, double* %67
%69 = fsub double %66, %68
%70 = load double, double* %62
%71 = load double, double* %26
%72 = load double, double* %30
%73 = fadd double %71, %72
%74 = load double, double* %17
%75 = getelementptr inbounds double, double* %1, i64 %24
%76 = load double, double* %75
%77 = tail call double @_update_step(double %70, double %64, double %69, double %73, double %74, double %76, i32 1)
store double %77, double* %62
store double %77, double* %67
br label %78
78: ; preds = %23, %36, %40, %59, %46, %60
%79 = add nuw nsw i64 %24, 1
%80 = icmp eq i64 %79, %15
br i1 %80, label %81, label %23
81: ; preds = %78
%82 = add nuw nsw i64 %14, 1
%83 = add nuw nsw i64 %15, 1
%84 = icmp eq i64 %82, %10
br i1 %84, label %85, label %13
85: ; preds = %81, %11
%86 = tail call i32 @_normalize_all(double* %2, i32 %3)
%87 = add nuw nsw i32 %12, 1
%88 = icmp eq i32 %87, %4
br i1 %88, label %89, label %11
89: ; preds = %85, %5
ret void
}