void merge_sort(int *listado, int inicio, int final, int SIZE) {
  if (inicio < final) {
    int medio = (inicio + final) / 2;
    merge_sort(listado, inicio, medio, SIZE);
    merge_sort(listado, medio + 1, final, SIZE);
    int iTemp1 = medio - inicio + 1, iTemp2 = final - medio, c1, c2, c3;
    int temp1[SIZE / 2], temp2[SIZE / 2];
    for (c1 = 0; c1 < iTemp1; c1++) {
      temp1[c1] = listado[inicio + c1];
    }
    for (c2 = 0; c2 < iTemp2; c2++) {
      temp2[c2] = listado[medio + c2 + 1];
    }
    temp1[c1] = SIZE * SIZE;
    temp2[c2] = SIZE * SIZE;
    c1 = c2 = 0;
    for (c3 = inicio; c3 <= final; c3++) {
      if (temp1[c1] <= temp2[c2]) {
        listado[c3] = temp1[c1++];
      } else {
        listado[c3] = temp2[c2++];
      }
    }
  }
}


x86 assembly (clang, -O0):
<merge_sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1318 <merge_sort+0x208>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    %ecx,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
sar    %eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%ecx
call   1030 <merge_sort@plt>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%esi
add    $0x1,%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
call   1030 <merge_sort@plt>
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
sar    %eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
sar    %eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    121a <merge_sort+0x10a>
mov    -0x58(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11e5 <merge_sort+0xd5>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1259 <merge_sort+0x149>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
add    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1221 <merge_sort+0x111>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x14(%rbp),%esi
imul   -0x14(%rbp),%esi
movslq -0x24(%rbp),%rdx
mov    %esi,(%rcx,%rdx,4)
mov    -0x14(%rbp),%edx
imul   -0x14(%rbp),%edx
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1311 <merge_sort+0x201>
mov    -0x50(%rbp),%rcx
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     12de <merge_sort+0x1ce>
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12fe <merge_sort+0x1ee>
mov    -0x50(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1303 <merge_sort+0x1f3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1291 <merge_sort+0x181>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge_sort>:
cmp    %esi,%edx
jle    145e <merge_sort+0x33e>
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %ecx,%r12d
mov    %edx,%r15d
mov    %rdi,%r14
lea    (%r15,%rsi,1),%eax
mov    %eax,%ebx
shr    $0x1f,%ebx
add    %eax,%ebx
sar    %ebx
mov    %ebx,%edx
mov    %rsi,-0x30(%rbp)
call   1040 <merge_sort@plt>
lea    0x1(%rbx),%esi
mov    %r14,%rdi
mov    %esi,-0x34(%rbp)
mov    %r15d,%edx
mov    %r12d,%ecx
call   1040 <merge_sort@plt>
mov    -0x30(%rbp),%rcx
mov    %rsp,-0x48(%rbp)
mov    %r15,-0x50(%rbp)
sub    %ebx,%r15d
mov    %r12d,%eax
shr    $0x1f,%eax
mov    %r12d,-0x5c(%rbp)
add    %r12d,%eax
sar    %eax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rdi
sub    %rax,%rdi
mov    %rdi,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %rbx,-0x58(%rbp)
sub    %ecx,%ebx
movslq %ecx,%r13
mov    %rdi,-0x40(%rbp)
js     1288 <merge_sort+0x168>
lea    (%r14,%r13,4),%rsi
mov    -0x34(%rbp),%edx
sub    %ecx,%edx
shl    $0x2,%rdx
call   1030 <memcpy@plt>
mov    %rbx,%r8
add    $0x1,%r8d
test   %r15d,%r15d
jle    1294 <merge_sort+0x174>
mov    %r15d,%r9d
cmp    $0x8,%r15d
jae    12e1 <merge_sort+0x1c1>
xor    %ecx,%ecx
mov    -0x40(%rbp),%r11
mov    -0x50(%rbp),%r10
mov    -0x30(%rbp),%rbx
mov    -0x48(%rbp),%r15
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     1237 <merge_sort+0x117>
movslq -0x58(%rbp),%rdi
add    $0x1,%rdi
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,(%r12,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1220 <merge_sort+0x100>
cmp    $0x3,%rdx
jb     12a7 <merge_sort+0x187>
mov    -0x58(%rbp),%edx
lea    (%rdx,%rcx,1),%eax
add    $0x1,%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,(%r12,%rcx,4)
lea    0x2(%rdx,%rcx,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,0x4(%r12,%rcx,4)
lea    0x3(%rdx,%rcx,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,0x8(%r12,%rcx,4)
lea    0x4(%rdx,%rcx,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,0xc(%r12,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1240 <merge_sort+0x120>
jmp    12a7 <merge_sort+0x187>
xor    %r8d,%r8d
test   %r15d,%r15d
jg     11df <merge_sort+0xbf>
xor    %r9d,%r9d
mov    -0x40(%rbp),%r11
mov    -0x50(%rbp),%r10
mov    -0x30(%rbp),%rbx
mov    -0x48(%rbp),%r15
mov    -0x5c(%rbp),%eax
imul   %eax,%eax
mov    %eax,(%r11,%r8,4)
mov    %eax,(%r12,%r9,4)
mov    %r10d,%r8d
sub    %ebx,%r8d
jl     144d <merge_sort+0x32d>
add    $0x1,%r8d
xor    %ecx,%ecx
cmp    %ebx,%r10d
jne    13c7 <merge_sort+0x2a7>
xor    %eax,%eax
test   $0x1,%r8b
jne    143c <merge_sort+0x31c>
jmp    144d <merge_sort+0x32d>
lea    -0x1(%r9),%rdx
mov    -0x58(%rbp),%rax
lea    (%rax,%rdx,1),%esi
add    $0x1,%esi
xor    %ecx,%ecx
cmp    %eax,%esi
jle    11ee <merge_sort+0xce>
shr    $0x20,%rdx
mov    -0x40(%rbp),%r11
mov    -0x50(%rbp),%r10
mov    -0x30(%rbp),%rbx
mov    -0x48(%rbp),%r15
jne    11fe <merge_sort+0xde>
mov    %r8,-0x68(%rbp)
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     145f <merge_sort+0x33f>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
mov    -0x58(%rbp),%rax
lea    0x9(%rax),%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x8(%rdx),%eax
cltq
movups (%r14,%rax,4),%xmm0
movups 0x10(%r14,%rax,4),%xmm1
movaps %xmm0,(%r12,%rsi,4)
movaps %xmm1,0x10(%r12,%rsi,4)
movslq %edx,%rdx
movups (%r14,%rdx,4),%xmm0
movups 0x10(%r14,%rdx,4),%xmm1
movaps %xmm0,0x20(%r12,%rsi,4)
movaps %xmm1,0x30(%r12,%rsi,4)
add    $0x10,%rsi
add    $0x10,%edx
add    $0xfffffffffffffffe,%rdi
jne    1350 <merge_sort+0x230>
test   $0x1,%r8b
je     13b5 <merge_sort+0x295>
mov    -0x34(%rbp),%eax
add    %esi,%eax
cltq
movups (%r14,%rax,4),%xmm0
movups 0x10(%r14,%rax,4),%xmm1
movaps %xmm0,(%r12,%rsi,4)
movaps %xmm1,0x10(%r12,%rsi,4)
cmp    %r9,%rcx
mov    -0x68(%rbp),%r8
jne    11fe <merge_sort+0xde>
jmp    12a7 <merge_sort+0x187>
mov    %r15,%r10
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%eax
mov    (%r11,%rax,4),%ebx
mov    %esi,%eax
mov    (%r12,%rax,4),%edx
xor    %edi,%edi
xor    %eax,%eax
cmp    %edx,%ebx
setle  %dil
setg   %al
cmovg  %edx,%ebx
add    %esi,%eax
add    %ecx,%edi
mov    %ebx,(%r14,%r13,4)
mov    (%r11,%rdi,4),%edx
mov    (%r12,%rax,4),%ebx
xor    %ecx,%ecx
xor    %esi,%esi
cmp    %ebx,%edx
setle  %cl
setg   %sil
cmovg  %ebx,%edx
add    %eax,%esi
add    %edi,%ecx
mov    %edx,0x4(%r14,%r13,4)
add    $0x2,%r13
add    $0xfffffffe,%r9d
jne    13e0 <merge_sort+0x2c0>
mov    %ecx,%ecx
mov    %esi,%eax
mov    %r10,%r15
test   $0x1,%r8b
je     144d <merge_sort+0x32d>
mov    (%r11,%rcx,4),%ecx
mov    (%r12,%rax,4),%eax
cmp    %eax,%ecx
cmovg  %eax,%ecx
mov    %ecx,(%r14,%r13,4)
mov    %r15,%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%r8b
jne    1398 <merge_sort+0x278>
jmp    13b5 <merge_sort+0x295>

LLVM IR (-O0):
define void @merge_sort(i32* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i64
%17 = alloca i64
store i32* %0, i32** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%18 = load i32, i32* %6
%19 = load i32, i32* %7
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %143
21: ; preds = %4
%22 = load i32, i32* %6
%23 = load i32, i32* %7
%24 = add nsw i32 %22, %23
%25 = sdiv i32 %24, 2
store i32 %25, i32* %9
%26 = load i32*, i32** %5
%27 = load i32, i32* %6
%28 = load i32, i32* %9
%29 = load i32, i32* %8
%30 = load i32*, i32** %5
%31 = load i32, i32* %9
%32 = add nsw i32 %31, 1
%33 = load i32, i32* %7
%34 = load i32, i32* %8
%35 = load i32, i32* %9
%36 = load i32, i32* %6
%37 = sub nsw i32 %35, %36
%38 = add nsw i32 %37, 1
store i32 %38, i32* %10
%39 = load i32, i32* %7
%40 = load i32, i32* %9
%41 = sub nsw i32 %39, %40
store i32 %41, i32* %11
%42 = load i32, i32* %8
%43 = sdiv i32 %42, 2
%44 = zext i32 %43 to i64
%45 = call i8* @llvm.stacksave()
store i8* %45, i8** %15
%46 = alloca i32, i64 %44
store i64 %44, i64* %16
%47 = load i32, i32* %8
%48 = sdiv i32 %47, 2
%49 = zext i32 %48 to i64
%50 = alloca i32, i64 %49
store i64 %49, i64* %17
store i32 0, i32* %12
br label %51
51: ; preds = %66, %21
%52 = load i32, i32* %12
%53 = load i32, i32* %10
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %69
55: ; preds = %51
%56 = load i32*, i32** %5
%57 = load i32, i32* %6
%58 = load i32, i32* %12
%59 = add nsw i32 %57, %58
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %56, i64 %60
%62 = load i32, i32* %61
%63 = load i32, i32* %12
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %46, i64 %64
store i32 %62, i32* %65
br label %66
66: ; preds = %55
%67 = load i32, i32* %12
%68 = add nsw i32 %67, 1
store i32 %68, i32* %12
br label %51
69: ; preds = %51
store i32 0, i32* %13
br label %70
70: ; preds = %86, %69
%71 = load i32, i32* %13
%72 = load i32, i32* %11
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %89
74: ; preds = %70
%75 = load i32*, i32** %5
%76 = load i32, i32* %9
%77 = load i32, i32* %13
%78 = add nsw i32 %76, %77
%79 = add nsw i32 %78, 1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %75, i64 %80
%82 = load i32, i32* %81
%83 = load i32, i32* %13
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %50, i64 %84
store i32 %82, i32* %85
br label %86
86: ; preds = %74
%87 = load i32, i32* %13
%88 = add nsw i32 %87, 1
store i32 %88, i32* %13
br label %70
89: ; preds = %70
%90 = load i32, i32* %8
%91 = load i32, i32* %8
%92 = mul nsw i32 %90, %91
%93 = load i32, i32* %12
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %46, i64 %94
store i32 %92, i32* %95
%96 = load i32, i32* %8
%97 = load i32, i32* %8
%98 = mul nsw i32 %96, %97
%99 = load i32, i32* %13
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %50, i64 %100
store i32 %98, i32* %101
store i32 0, i32* %13
store i32 0, i32* %12
%102 = load i32, i32* %6
store i32 %102, i32* %14
br label %103
103: ; preds = %138, %89
%104 = load i32, i32* %14
%105 = load i32, i32* %7
%106 = icmp sle i32 %104, %105
br i1 %106, label %107, label %141
107: ; preds = %103
%108 = load i32, i32* %12
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %46, i64 %109
%111 = load i32, i32* %110
%112 = load i32, i32* %13
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %50, i64 %113
%115 = load i32, i32* %114
%116 = icmp sle i32 %111, %115
br i1 %116, label %117, label %127
117: ; preds = %107
%118 = load i32, i32* %12
%119 = add nsw i32 %118, 1
store i32 %119, i32* %12
%120 = sext i32 %118 to i64
%121 = getelementptr inbounds i32, i32* %46, i64 %120
%122 = load i32, i32* %121
%123 = load i32*, i32** %5
%124 = load i32, i32* %14
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %123, i64 %125
store i32 %122, i32* %126
br label %137
127: ; preds = %107
%128 = load i32, i32* %13
%129 = add nsw i32 %128, 1
store i32 %129, i32* %13
%130 = sext i32 %128 to i64
%131 = getelementptr inbounds i32, i32* %50, i64 %130
%132 = load i32, i32* %131
%133 = load i32*, i32** %5
%134 = load i32, i32* %14
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %133, i64 %135
store i32 %132, i32* %136
br label %137
137: ; preds = %127, %117
br label %138
138: ; preds = %137
%139 = load i32, i32* %14
%140 = add nsw i32 %139, 1
store i32 %140, i32* %14
br label %103
141: ; preds = %103
%142 = load i8*, i8** %15
br label %143
143: ; preds = %141, %4
ret void
}

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