#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*/ free(int *);
int *malloc(int);
int /*<<< orphan*/ memcpy(int *, int *, int);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
unsigned long long merge_sort(int *a, int s, int e) {
  unsigned long long ret = 0;
  if (s < e) {
    int middle = (s + e) / 2;
    ret += merge_sort(a, s, middle);
    ret += merge_sort(a, middle + 1, e);
    int *t = malloc(sizeof(int) * (e - s + 1));
    memset(t, 0, sizeof(int) * (e - s + 1));
    int i = s, j = middle + 1;
    for (size_t k = s; k <= e; k++) {
      if (i <= middle && j <= e) {
        if (a[i] <= a[j]) {
          t[k - s] = a[i];
          if (k > i) {
            ret += k - i;
          }
          i++;
        } else {
          t[k - s] = a[j];
          if (k > j) {
            ret += k - j;
          }
          j++;
        }
      } else {
        if (i <= middle) {
          t[k - s] = a[i];
          if (k > i) {
            ret += k - i;
          }
          i++;
        } else {
          t[k - s] = a[j];
          if (k > j) {
            ret += k - j;
          }
          j++;
        }
      }
    }
    memcpy(&a[s], t, sizeof(int) * (e - s + 1));
    free(t);
  }
  return ret;
}


x86 assembly (clang, -O0):
<merge_sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13da <merge_sort+0x28a>
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x1c(%rbp),%edx
call   1070 <merge_sort@plt>
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
mov    -0x10(%rbp),%edx
call   1070 <merge_sort@plt>
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
movslq -0xc(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
ja     13a8 <merge_sort+0x258>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     12e8 <merge_sort+0x198>
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     12e8 <merge_sort+0x198>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1299 <merge_sort+0x149>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rsi
sub    %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmp    %rcx,%rax
jbe    128b <merge_sort+0x13b>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
sub    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12e3 <merge_sort+0x193>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rsi
sub    %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmp    %rcx,%rax
jbe    12da <merge_sort+0x18a>
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
sub    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1392 <merge_sort+0x242>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1343 <merge_sort+0x1f3>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rsi
sub    %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmp    %rcx,%rax
jbe    1335 <merge_sort+0x1e5>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
sub    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    138d <merge_sort+0x23d>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0xc(%rbp),%rsi
sub    %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmp    %rcx,%rax
jbe    1384 <merge_sort+0x234>
mov    -0x38(%rbp),%rax
movslq -0x30(%rbp),%rcx
sub    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1392 <merge_sort+0x242>
jmp    1397 <merge_sort+0x247>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1205 <merge_sort+0xb5>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x28(%rbp),%rsi
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge_sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%ebp
sub    %esi,%ebp
jle    11fd <merge_sort+0xad>
mov    %edx,%ecx
mov    %esi,%r12d
mov    %rdi,%r15
lea    (%rcx,%r12,1),%eax
mov    %eax,%r13d
shr    $0x1f,%r13d
add    %eax,%r13d
sar    %r13d
mov    %r13d,%edx
mov    %rcx,0x8(%rsp)
call   1070 <merge_sort@plt>
mov    %rax,(%rsp)
lea    0x1(%r13),%r14d
mov    %r15,%rdi
mov    %r14d,%esi
mov    0x8(%rsp),%rdx
call   1070 <merge_sort@plt>
mov    %rax,%rbx
add    (%rsp),%rbx
lea    0x4(,%rbp,4),%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,(%rsp)
mov    %ebp,%edx
mov    %rax,%rbp
call   1040 <memset@plt>
mov    0x8(%rsp),%r11
movslq %r12d,%rax
cmp    %r12d,%r11d
mov    %rax,0x10(%rsp)
jae    1211 <merge_sort+0xc1>
mov    0x10(%rsp),%rax
lea    (%r15,%rax,4),%rdi
mov    %rbp,%rsi
mov    (%rsp),%edx
call   1050 <memcpy@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
jmp    11ff <merge_sort+0xaf>
xor    %ebx,%ebx
mov    %rbx,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movslq %r11d,%r10
xor    %r9d,%r9d
mov    %rbp,%rsi
jmp    1247 <merge_sort+0xf7>
nopl   0x0(%rax)
movslq %r14d,%rcx
mov    (%r15,%rcx,4),%edx
mov    %edx,(%rsi)
mov    %rax,%rdi
sub    %rcx,%rdi
cmovb  %r9,%rdi
add    $0x1,%r14d
add    %rdi,%rbx
add    $0x1,%rax
add    $0x4,%rsi
cmp    %r10,%rax
ja     11df <merge_sort+0x8f>
cmp    %r13d,%r12d
jg     1280 <merge_sort+0x130>
cmp    %r11d,%r14d
jg     1280 <merge_sort+0x130>
mov    %rbp,%r8
movslq %r12d,%rdi
mov    (%r15,%rdi,4),%ecx
movslq %r14d,%rdx
mov    (%r15,%rdx,4),%ebp
cmp    %ebp,%ecx
jle    12b0 <merge_sort+0x160>
mov    %ebp,(%rsi)
mov    %rax,%rcx
sub    %rdx,%rcx
mov    $0x0,%edi
cmovae %rcx,%rdi
add    $0x1,%r14d
mov    %r8,%rbp
jmp    1237 <merge_sort+0xe7>
cmp    %r13d,%r12d
jg     1220 <merge_sort+0xd0>
movslq %r12d,%rcx
mov    (%r15,%rcx,4),%edx
mov    %edx,(%rsi)
mov    %rax,%rdx
sub    %rcx,%rdx
mov    $0x0,%edi
cmovae %rdx,%rdi
add    $0x1,%r12d
jmp    1237 <merge_sort+0xe7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,(%rsi)
mov    %rax,%rcx
sub    %rdi,%rcx
mov    $0x0,%edi
cmovae %rcx,%rdi
add    $0x1,%r12d
mov    %r8,%rbp
jmp    1237 <merge_sort+0xe7>

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

LLVM IR (-O2):
define i64 @merge_sort(i32* %0, i32 %1, i32 %2) {
%4 = icmp sgt i32 %2, %1
br i1 %4, label %5, label %73
5: ; preds = %3
%6 = add nsw i32 %2, %1
%7 = sdiv i32 %6, 2
%8 = tail call i64 @merge_sort(i32* %0, i32 %1, i32 %7)
%9 = add nsw i32 %7, 1
%10 = tail call i64 @merge_sort(i32* %0, i32 %9, i32 %2)
%11 = add i64 %10, %8
%12 = sub nsw i32 %2, %1
%13 = shl i32 %12, 2
%14 = add i32 %13, 4
%15 = tail call i32* @malloc(i32 %14)
%16 = tail call i32 @memset(i32* %15, i32 0, i32 %14)
%17 = sext i32 %1 to i64
%18 = sext i32 %2 to i64
%19 = icmp ult i32 %2, %1
br i1 %19, label %20, label %25
20: ; preds = %66, %5
%21 = phi i64 [ %11, %5 ], [ %70, %66 ]
%22 = getelementptr inbounds i32, i32* %0, i64 %17
%23 = tail call i32 @memcpy(i32* %22, i32* %15, i32 %14)
%24 = tail call i32 @free(i32* %15)
br label %73
25: ; preds = %5, %66
%26 = phi i64 [ %71, %66 ], [ %17, %5 ]
%27 = phi i32 [ %69, %66 ], [ %9, %5 ]
%28 = phi i32 [ %68, %66 ], [ %1, %5 ]
%29 = phi i64 [ %70, %66 ], [ %11, %5 ]
%30 = icmp sgt i32 %28, %7
%31 = icmp sgt i32 %27, %2
%32 = select i1 %30, i1 true, i1 %31
br i1 %32, label %49, label %33
33: ; preds = %25
%34 = sext i32 %28 to i64
%35 = getelementptr inbounds i32, i32* %0, i64 %34
%36 = load i32, i32* %35
%37 = sext i32 %27 to i64
%38 = getelementptr inbounds i32, i32* %0, i64 %37
%39 = load i32, i32* %38
%40 = icmp sgt i32 %36, %39
%41 = sub i64 %26, %17
%42 = getelementptr inbounds i32, i32* %15, i64 %41
br i1 %40, label %46, label %43
43: ; preds = %33
store i32 %36, i32* %42
%44 = tail call i64 @llvm.usub.sat.i64(i64 %26, i64 %34)
%45 = add nsw i32 %28, 1
br label %66
46: ; preds = %33
store i32 %39, i32* %42
%47 = tail call i64 @llvm.usub.sat.i64(i64 %26, i64 %37)
%48 = add nsw i32 %27, 1
br label %66
49: ; preds = %25
br i1 %30, label %58, label %50
50: ; preds = %49
%51 = sext i32 %28 to i64
%52 = getelementptr inbounds i32, i32* %0, i64 %51
%53 = load i32, i32* %52
%54 = sub i64 %26, %17
%55 = getelementptr inbounds i32, i32* %15, i64 %54
store i32 %53, i32* %55
%56 = tail call i64 @llvm.usub.sat.i64(i64 %26, i64 %51)
%57 = add nsw i32 %28, 1
br label %66
58: ; preds = %49
%59 = sext i32 %27 to i64
%60 = getelementptr inbounds i32, i32* %0, i64 %59
%61 = load i32, i32* %60
%62 = sub i64 %26, %17
%63 = getelementptr inbounds i32, i32* %15, i64 %62
store i32 %61, i32* %63
%64 = tail call i64 @llvm.usub.sat.i64(i64 %26, i64 %59)
%65 = add nsw i32 %27, 1
br label %66
66: ; preds = %46, %43, %58, %50
%67 = phi i64 [ %44, %43 ], [ %47, %46 ], [ %56, %50 ], [ %64, %58 ]
%68 = phi i32 [ %45, %43 ], [ %28, %46 ], [ %57, %50 ], [ %28, %58 ]
%69 = phi i32 [ %27, %43 ], [ %48, %46 ], [ %27, %50 ], [ %65, %58 ]
%70 = add i64 %67, %29
%71 = add i64 %26, 1
%72 = icmp ugt i64 %71, %18
br i1 %72, label %20, label %25
73: ; preds = %20, %3
%74 = phi i64 [ %21, %20 ], [ 0, %3 ]
ret i64 %74
}