#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 */
void quicksortDoublesAscending(double *arr, size_t len) {
  double piv;
  size_t beg[300];
  size_t end[300];
  size_t L, R;
  int i = 0;
  int swap;
  beg[0] = 0;
  end[0] = len;
  while (i >= 0) {
    L = beg[i];
    R = end[i] - 1;
    if (L < R) {
      piv = arr[L];
      while (L < R) {
        while (arr[R] >= piv && L < R) {
          --R;
          if (L < R) {
            arr[L++] = arr[R];
          }
        }
        while (arr[L] <= piv && L < R) {
          ++L;
          if (L < R) {
            arr[R--] = arr[L];
          }
        }
      }
      arr[L] = piv;
      beg[i + 1] = L + 1;
      end[i + 1] = end[i];
      end[i++] = L;
      if (end[i] - beg[i] > end[i - 1] - beg[i - 1]) {
        swap = beg[i];
        beg[i] = beg[i - 1];
        beg[i - 1] = swap;
        swap = end[i];
        end[i] = end[i - 1];
        end[i - 1] = swap;
      }
    } else {
      i--;
    }
  }
}


x86 assembly (clang, -O0):
<quicksortDoublesAscending>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1280,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x12f4(%rbp)
movq   $0x0,-0x980(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x12e0(%rbp)
cmpl   $0x0,-0x12f4(%rbp)
jl     148d <quicksortDoublesAscending+0x38d>
movslq -0x12f4(%rbp),%rax
mov    -0x980(%rbp,%rax,8),%rax
ff
mov    %rax,-0x12e8(%rbp)
movslq -0x12f4(%rbp),%rax
mov    -0x12e0(%rbp,%rax,8),%rax
ff
sub    $0x1,%rax
mov    %rax,-0x12f0(%rbp)
mov    -0x12e8(%rbp),%rax
cmp    -0x12f0(%rbp),%rax
jae    1479 <quicksortDoublesAscending+0x379>
mov    -0x8(%rbp),%rax
mov    -0x12e8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x12e8(%rbp),%rax
cmp    -0x12f0(%rbp),%rax
jae    130c <quicksortDoublesAscending+0x20c>
jmp    11b2 <quicksortDoublesAscending+0xb2>
mov    -0x8(%rbp),%rax
mov    -0x12f0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xor    %eax,%eax
ucomisd -0x18(%rbp),%xmm0
mov    %al,-0x12f9(%rbp)
jb     11ec <quicksortDoublesAscending+0xec>
mov    -0x12e8(%rbp),%rax
cmp    -0x12f0(%rbp),%rax
setb   %al
mov    %al,-0x12f9(%rbp)
mov    -0x12f9(%rbp),%al
test   $0x1,%al
jne    11ff <quicksortDoublesAscending+0xff>
jmp    1258 <quicksortDoublesAscending+0x158>
mov    -0x12f0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x12f0(%rbp)
mov    -0x12e8(%rbp),%rax
cmp    -0x12f0(%rbp),%rax
jae    1253 <quicksortDoublesAscending+0x153>
mov    -0x8(%rbp),%rax
mov    -0x12f0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x12e8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x12e8(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
jmp    11b2 <quicksortDoublesAscending+0xb2>
jmp    125d <quicksortDoublesAscending+0x15d>
mov    -0x8(%rbp),%rax
mov    -0x12e8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0x12fa(%rbp)
jb     129b <quicksortDoublesAscending+0x19b>
mov    -0x12e8(%rbp),%rax
cmp    -0x12f0(%rbp),%rax
setb   %al
mov    %al,-0x12fa(%rbp)
mov    -0x12fa(%rbp),%al
test   $0x1,%al
jne    12ae <quicksortDoublesAscending+0x1ae>
jmp    1307 <quicksortDoublesAscending+0x207>
mov    -0x12e8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x12e8(%rbp)
mov    -0x12e8(%rbp),%rax
cmp    -0x12f0(%rbp),%rax
jae    1302 <quicksortDoublesAscending+0x202>
mov    -0x8(%rbp),%rax
mov    -0x12e8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x12f0(%rbp),%rcx
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x12f0(%rbp)
movsd  %xmm0,(%rax,%rcx,8)
jmp    125d <quicksortDoublesAscending+0x15d>
jmp    1199 <quicksortDoublesAscending+0x99>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x12e8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x12e8(%rbp),%rcx
add    $0x1,%rcx
mov    -0x12f4(%rbp),%eax
add    $0x1,%eax
cltq
mov    %rcx,-0x980(%rbp,%rax,8)
ff
movslq -0x12f4(%rbp),%rax
mov    -0x12e0(%rbp,%rax,8),%rcx
ff
mov    -0x12f4(%rbp),%eax
add    $0x1,%eax
cltq
mov    %rcx,-0x12e0(%rbp,%rax,8)
ff
mov    -0x12e8(%rbp),%rcx
mov    -0x12f4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x12f4(%rbp)
cltq
mov    %rcx,-0x12e0(%rbp,%rax,8)
ff
movslq -0x12f4(%rbp),%rax
mov    -0x12e0(%rbp,%rax,8),%rax
ff
movslq -0x12f4(%rbp),%rcx
sub    -0x980(%rbp,%rcx,8),%rax
ff
mov    -0x12f4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    -0x12e0(%rbp,%rcx,8),%rcx
ff
mov    -0x12f4(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
sub    -0x980(%rbp,%rdx,8),%rcx
ff
cmp    %rcx,%rax
jbe    1474 <quicksortDoublesAscending+0x374>
movslq -0x12f4(%rbp),%rax
mov    -0x980(%rbp,%rax,8),%rax
ff
mov    %eax,-0x12f8(%rbp)
mov    -0x12f4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x980(%rbp,%rax,8),%rcx
ff
movslq -0x12f4(%rbp),%rax
mov    %rcx,-0x980(%rbp,%rax,8)
ff
movslq -0x12f8(%rbp),%rcx
mov    -0x12f4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rcx,-0x980(%rbp,%rax,8)
ff
movslq -0x12f4(%rbp),%rax
mov    -0x12e0(%rbp,%rax,8),%rax
ff
mov    %eax,-0x12f8(%rbp)
mov    -0x12f4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x12e0(%rbp,%rax,8),%rcx
ff
movslq -0x12f4(%rbp),%rax
mov    %rcx,-0x12e0(%rbp,%rax,8)
ff
movslq -0x12f8(%rbp),%rcx
mov    -0x12f4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rcx,-0x12e0(%rbp,%rax,8)
ff
jmp    1488 <quicksortDoublesAscending+0x388>
mov    -0x12f4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x12f4(%rbp)
jmp    1133 <quicksortDoublesAscending+0x33>
add    $0x1280,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quicksortDoublesAscending>:
push   %rbx
sub    $0x1240,%rsp
movq   $0x0,0x8e0(%rsp)
mov    %rsi,-0x80(%rsp)
xor    %r8d,%r8d
xor    %r11d,%r11d
nop
mov    %r11d,%r9d
lea    -0x1(%rsi),%rax
cmp    %rax,%r8
jae    11a0 <quicksortDoublesAscending+0xa0>
movsd  (%rdi,%r8,8),%xmm0
mov    %r8,%rdx
jmp    1140 <quicksortDoublesAscending+0x40>
cmp    %rax,%rdx
jae    11b0 <quicksortDoublesAscending+0xb0>
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jb     1187 <quicksortDoublesAscending+0x87>
cmp    %rax,%rdx
jae    1187 <quicksortDoublesAscending+0x87>
add    $0xffffffffffffffff,%rax
cmp    %rax,%rdx
jae    1140 <quicksortDoublesAscending+0x40>
movsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
add    $0x1,%rdx
jmp    1140 <quicksortDoublesAscending+0x40>
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    %rax,%rdx
jae    1187 <quicksortDoublesAscending+0x87>
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0xffffffffffffffff,%rax
ucomisd (%rdi,%rdx,8),%xmm0
jb     1137 <quicksortDoublesAscending+0x37>
cmp    %rax,%rdx
jb     1170 <quicksortDoublesAscending+0x70>
jmp    1137 <quicksortDoublesAscending+0x37>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffff,%r9d
mov    %r9d,%r11d
jmp    1207 <quicksortDoublesAscending+0x107>
nopl   0x0(%rax)
movsd  %xmm0,(%rdi,%rdx,8)
lea    0x1(%rdx),%r10
movslq %r9d,%rcx
lea    0x1(%r9),%r11d
mov    %r10,0x8e8(%rsp,%rcx,8)
mov    %rsi,-0x78(%rsp,%rcx,8)
mov    %rdx,-0x80(%rsp,%r9,8)
mov    %rsi,%rax
sub    %r10,%rax
mov    %rdx,%rbx
sub    %r8,%rbx
cmp    %rbx,%rax
jbe    1207 <quicksortDoublesAscending+0x107>
add    $0x1,%rcx
mov    %r8,0x8e0(%rsp,%rcx,8)
movslq %r10d,%rax
mov    %rax,0x8e0(%rsp,%r9,8)
mov    %rdx,-0x80(%rsp,%rcx,8)
movslq %esi,%rax
mov    %rax,-0x80(%rsp,%r9,8)
test   %r11d,%r11d
js     1221 <quicksortDoublesAscending+0x121>
mov    %r11d,%eax
mov    0x8e0(%rsp,%rax,8),%r8
mov    -0x80(%rsp,%rax,8),%rsi
jmp    1120 <quicksortDoublesAscending+0x20>
add    $0x1240,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define void @quicksortDoublesAscending(double* nocapture %0, i64 %1) {
%3 = alloca [300 x i64]
%4 = alloca [300 x i64]
%5 = bitcast [300 x i64]* %3 to i8*
%6 = bitcast [300 x i64]* %4 to i8*
%7 = getelementptr inbounds [300 x i64], [300 x i64]* %3, i64 0, i64 0
store i64 0, i64* %7
%8 = getelementptr inbounds [300 x i64], [300 x i64]* %4, i64 0, i64 0
store i64 %1, i64* %8
br label %9
9: ; preds = %95, %2
%10 = phi i64 [ %1, %2 ], [ %100, %95 ]
%11 = phi i64 [ 0, %2 ], [ %98, %95 ]
%12 = phi i32 [ 0, %2 ], [ %93, %95 ]
%13 = zext i32 %12 to i64
%14 = getelementptr inbounds [300 x i64], [300 x i64]* %3, i64 0, i64 %13
%15 = getelementptr inbounds [300 x i64], [300 x i64]* %4, i64 0, i64 %13
%16 = add i64 %10, -1
%17 = icmp ult i64 %11, %16
br i1 %17, label %18, label %90
18: ; preds = %9
%19 = getelementptr inbounds double, double* %0, i64 %11
%20 = load double, double* %19
br label %25
21: ; preds = %68, %33
%22 = phi i64 [ %34, %33 ], [ %69, %68 ]
%23 = phi i64 [ %35, %33 ], [ %61, %68 ]
%24 = icmp ult i64 %23, %22
br i1 %24, label %25, label %75
25: ; preds = %18, %21
%26 = phi i64 [ %11, %18 ], [ %23, %21 ]
%27 = phi i64 [ %16, %18 ], [ %22, %21 ]
%28 = getelementptr inbounds double, double* %0, i64 %27
%29 = load double, double* %28
%30 = fcmp oge double %29, %20
%31 = icmp ult i64 %26, %27
%32 = select i1 %30, i1 %31, i1 false
br i1 %32, label %41, label %33
33: ; preds = %51, %25
%34 = phi i64 [ %27, %25 ], [ %44, %51 ]
%35 = phi i64 [ %26, %25 ], [ %52, %51 ]
%36 = getelementptr inbounds double, double* %0, i64 %35
%37 = load double, double* %36
%38 = fcmp ole double %37, %20
%39 = icmp ult i64 %35, %34
%40 = select i1 %38, i1 %39, i1 false
br i1 %40, label %58, label %21
41: ; preds = %25, %51
%42 = phi i64 [ %52, %51 ], [ %26, %25 ]
%43 = phi i64 [ %44, %51 ], [ %27, %25 ]
%44 = add i64 %43, -1
%45 = icmp ult i64 %42, %44
br i1 %45, label %46, label %51
46: ; preds = %41
%47 = getelementptr inbounds double, double* %0, i64 %44
%48 = load double, double* %47
%49 = add nuw i64 %42, 1
%50 = getelementptr inbounds double, double* %0, i64 %42
store double %48, double* %50
br label %51
51: ; preds = %46, %41
%52 = phi i64 [ %49, %46 ], [ %42, %41 ]
%53 = getelementptr inbounds double, double* %0, i64 %44
%54 = load double, double* %53
%55 = fcmp oge double %54, %20
%56 = icmp ult i64 %52, %44
%57 = select i1 %55, i1 %56, i1 false
br i1 %57, label %41, label %33
58: ; preds = %33, %68
%59 = phi i64 [ %61, %68 ], [ %35, %33 ]
%60 = phi i64 [ %69, %68 ], [ %34, %33 ]
%61 = add nuw i64 %59, 1
%62 = icmp ult i64 %61, %60
br i1 %62, label %63, label %68
63: ; preds = %58
%64 = getelementptr inbounds double, double* %0, i64 %61
%65 = load double, double* %64
%66 = add i64 %60, -1
%67 = getelementptr inbounds double, double* %0, i64 %60
store double %65, double* %67
br label %68
68: ; preds = %63, %58
%69 = phi i64 [ %66, %63 ], [ %60, %58 ]
%70 = getelementptr inbounds double, double* %0, i64 %61
%71 = load double, double* %70
%72 = fcmp ole double %71, %20
%73 = icmp ult i64 %61, %69
%74 = select i1 %72, i1 %73, i1 false
br i1 %74, label %58, label %21
75: ; preds = %21
%76 = getelementptr inbounds double, double* %0, i64 %23
store double %20, double* %76
%77 = add i64 %23, 1
%78 = add nsw i32 %12, 1
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [300 x i64], [300 x i64]* %3, i64 0, i64 %79
store i64 %77, i64* %80
%81 = getelementptr inbounds [300 x i64], [300 x i64]* %4, i64 0, i64 %79
store i64 %10, i64* %81
store i64 %23, i64* %15
%82 = sub i64 %10, %77
%83 = sub i64 %23, %11
%84 = icmp ugt i64 %82, %83
br i1 %84, label %85, label %92
85: ; preds = %75
store i64 %11, i64* %80
%86 = shl i64 %77, 32
%87 = ashr exact i64 %86, 32
store i64 %87, i64* %14
store i64 %23, i64* %81
%88 = shl i64 %10, 32
%89 = ashr exact i64 %88, 32
store i64 %89, i64* %15
br label %92
90: ; preds = %9
%91 = add nsw i32 %12, -1
br label %92
92: ; preds = %75, %85, %90
%93 = phi i32 [ %78, %85 ], [ %78, %75 ], [ %91, %90 ]
%94 = icmp sgt i32 %93, -1
br i1 %94, label %95, label %101
95: ; preds = %92
%96 = zext i32 %93 to i64
%97 = getelementptr inbounds [300 x i64], [300 x i64]* %3, i64 0, i64 %96
%98 = load i64, i64* %97
%99 = getelementptr inbounds [300 x i64], [300 x i64]* %4, i64 0, i64 %96
%100 = load i64, i64* %99
br label %9
101: ; preds = %92
ret void
}