void sort(int s, int e, int *a, int *t) {
  if (e - s <= 1) {
    return;
  }
  int m = (s + e) / 2;
  sort(s, m, a, t);
  sort(m, e, a, t);
  int i;
  int p1 = s;
  int p2 = m;
  for (i = 0; i < e - s; i++) {
    if (p2 >= e || (p1 < m && a[p1] < a[p2])) {
      t[i] = a[p1++];
    } else {
      t[i] = a[p1++];
    }
  }
  for (i = 0; i < e - s; i++) {
    a[s + i] = t[i];
  }
}


x86 assembly (clang, -O0):
<sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
cmp    $0x1,%eax
jg     113a <sort+0x2a>
jmp    1262 <sort+0x152>
mov    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
call   1030 <sort@plt>
mov    -0x1c(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
call   1030 <sort@plt>
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jge    1221 <sort+0x111>
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11c9 <sort+0xb9>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ee <sort+0xde>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11ee <sort+0xde>
mov    -0x10(%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    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    120e <sort+0xfe>
mov    -0x10(%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    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1213 <sort+0x103>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1184 <sort+0x74>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jge    1262 <sort+0x152>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1228 <sort+0x118>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r13d
sub    %edi,%r13d
cmp    $0x2,%r13d
jl     1474 <sort+0x364>
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %esi,%r12d
mov    %edi,%r15d
lea    (%r12,%r15,1),%eax
mov    %eax,%ebp
shr    $0x1f,%ebp
add    %eax,%ebp
sar    %ebp
mov    %ebp,%esi
call   1030 <sort@plt>
mov    %ebp,%edi
mov    %r12d,%esi
mov    %r14,%rdx
mov    %rbx,%rcx
call   1030 <sort@plt>
movslq %r15d,%r8
mov    %r13d,%eax
cmp    $0x8,%r13d
jb     1189 <sort+0x79>
lea    (%r8,%rax,1),%rcx
lea    (%r14,%rcx,4),%rcx
cmp    %rbx,%rcx
jbe    120c <sort+0xfc>
lea    (%rbx,%rax,4),%rcx
lea    (%r14,%r8,4),%rdx
cmp    %rcx,%rdx
jae    120c <sort+0xfc>
xor    %edx,%edx
mov    %r8,%rsi
mov    %rdx,%rdi
not    %rdi
add    %rax,%rdi
mov    %rax,%rcx
and    $0x3,%rcx
je     11b5 <sort+0xa5>
mov    (%r14,%rsi,4),%ebp
mov    %ebp,(%rbx,%rdx,4)
add    $0x1,%rsi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    11a0 <sort+0x90>
cmp    $0x3,%rdi
jb     12e4 <sort+0x1d4>
lea    (%r14,%rsi,4),%rcx
add    $0xc,%rcx
mov    %rax,%rsi
sub    %rdx,%rsi
lea    (%rbx,%rdx,4),%rdx
add    $0xc,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    -0xc(%rcx,%rdi,4),%ebp
mov    %ebp,-0xc(%rdx,%rdi,4)
mov    -0x8(%rcx,%rdi,4),%ebp
mov    %ebp,-0x8(%rdx,%rdi,4)
mov    -0x4(%rcx,%rdi,4),%ebp
mov    %ebp,-0x4(%rdx,%rdi,4)
mov    (%rcx,%rdi,4),%ebp
mov    %ebp,(%rdx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    11e0 <sort+0xd0>
jmp    12e4 <sort+0x1d4>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rcx
jae    122f <sort+0x11f>
xor    %ebp,%ebp
jmp    1298 <sort+0x188>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%r8,4),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
nopl   (%rax)
movups -0x70(%rcx,%rbp,4),%xmm0
movups -0x60(%rcx,%rbp,4),%xmm1
movups %xmm0,(%rbx,%rbp,4)
movups %xmm1,0x10(%rbx,%rbp,4)
movups -0x50(%rcx,%rbp,4),%xmm0
movups -0x40(%rcx,%rbp,4),%xmm1
movups %xmm0,0x20(%rbx,%rbp,4)
movups %xmm1,0x30(%rbx,%rbp,4)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,0x40(%rbx,%rbp,4)
movups %xmm1,0x50(%rbx,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,0x60(%rbx,%rbp,4)
movups %xmm1,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1240 <sort+0x130>
test   %rsi,%rsi
je     12db <sort+0x1cb>
lea    (%rbx,%rbp,4),%rcx
add    $0x10,%rcx
add    %r8,%rbp
lea    (%r14,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    12c0 <sort+0x1b0>
cmp    %rax,%rdx
jne    13af <sort+0x29f>
test   %r13d,%r13d
jle    1474 <sort+0x364>
movslq %r15d,%r9
cmp    $0x8,%r13d
jb     1313 <sort+0x203>
lea    (%r14,%r8,4),%rcx
lea    (%rbx,%rax,4),%rdx
cmp    %rdx,%rcx
jae    138c <sort+0x27c>
add    %rax,%r8
lea    (%r14,%r8,4),%rcx
cmp    %rbx,%rcx
jbe    138c <sort+0x27c>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1340 <sort+0x230>
lea    (%r14,%r9,4),%rdi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%ebp
mov    %ebp,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1330 <sort+0x220>
cmp    $0x3,%rdx
jb     1474 <sort+0x364>
lea    (%r14,%r9,4),%rdx
add    $0xc,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rcx,4),%esi
mov    %esi,-0xc(%rdx,%rcx,4)
mov    0x4(%rbx,%rcx,4),%esi
mov    %esi,-0x8(%rdx,%rcx,4)
mov    0x8(%rbx,%rcx,4),%esi
mov    %esi,-0x4(%rdx,%rcx,4)
mov    0xc(%rbx,%rcx,4),%esi
mov    %esi,(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1360 <sort+0x250>
jmp    1474 <sort+0x364>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rdx
jae    13b8 <sort+0x2a8>
xor    %ebp,%ebp
jmp    1428 <sort+0x318>
lea    (%rdx,%r8,1),%rsi
jmp    118e <sort+0x7e>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%r9,4),%rdx
add    $0x70,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rbp,4),%xmm0
movups 0x10(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,4)
movups %xmm1,-0x60(%rdx,%rbp,4)
movups 0x20(%rbx,%rbp,4),%xmm0
movups 0x30(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,4)
movups %xmm1,-0x40(%rdx,%rbp,4)
movups 0x40(%rbx,%rbp,4),%xmm0
movups 0x50(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,4)
movups %xmm1,-0x20(%rdx,%rbp,4)
movups 0x60(%rbx,%rbp,4),%xmm0
movups 0x70(%rbx,%rbp,4),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,4)
movups %xmm1,(%rdx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    13d0 <sort+0x2c0>
test   %rsi,%rsi
je     146b <sort+0x35b>
lea    (%r9,%rbp,1),%rdx
lea    (%r14,%rdx,4),%rdx
add    $0x10,%rdx
lea    (%rbx,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1450 <sort+0x340>
cmp    %rax,%rcx
jne    1315 <sort+0x205>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @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
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32* %2, i32** %7
store i32* %3, i32** %8
%13 = load i32, i32* %6
%14 = load i32, i32* %5
%15 = sub nsw i32 %13, %14
%16 = icmp sle i32 %15, 1
br i1 %16, label %17, label %18
17: ; preds = %4
br label %107
18: ; preds = %4
%19 = load i32, i32* %5
%20 = load i32, i32* %6
%21 = add nsw i32 %19, %20
%22 = sdiv i32 %21, 2
store i32 %22, i32* %9
%23 = load i32, i32* %5
%24 = load i32, i32* %9
%25 = load i32*, i32** %7
%26 = load i32*, i32** %8
%27 = load i32, i32* %9
%28 = load i32, i32* %6
%29 = load i32*, i32** %7
%30 = load i32*, i32** %8
%31 = load i32, i32* %5
store i32 %31, i32* %11
%32 = load i32, i32* %9
store i32 %32, i32* %12
store i32 0, i32* %10
br label %33
33: ; preds = %82, %18
%34 = load i32, i32* %10
%35 = load i32, i32* %6
%36 = load i32, i32* %5
%37 = sub nsw i32 %35, %36
%38 = icmp slt i32 %34, %37
br i1 %38, label %39, label %85
39: ; preds = %33
%40 = load i32, i32* %12
%41 = load i32, i32* %6
%42 = icmp sge i32 %40, %41
br i1 %42, label %59, label %43
43: ; preds = %39
%44 = load i32, i32* %11
%45 = load i32, i32* %9
%46 = icmp slt i32 %44, %45
br i1 %46, label %47, label %70
47: ; preds = %43
%48 = load i32*, i32** %7
%49 = load i32, i32* %11
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %48, i64 %50
%52 = load i32, i32* %51
%53 = load i32*, i32** %7
%54 = load i32, i32* %12
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %53, i64 %55
%57 = load i32, i32* %56
%58 = icmp slt i32 %52, %57
br i1 %58, label %59, label %70
59: ; preds = %47, %39
%60 = load i32*, i32** %7
%61 = load i32, i32* %11
%62 = add nsw i32 %61, 1
store i32 %62, i32* %11
%63 = sext i32 %61 to i64
%64 = getelementptr inbounds i32, i32* %60, i64 %63
%65 = load i32, i32* %64
%66 = load i32*, i32** %8
%67 = load i32, i32* %10
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
store i32 %65, i32* %69
br label %81
70: ; preds = %47, %43
%71 = load i32*, i32** %7
%72 = load i32, i32* %11
%73 = add nsw i32 %72, 1
store i32 %73, i32* %11
%74 = sext i32 %72 to i64
%75 = getelementptr inbounds i32, i32* %71, i64 %74
%76 = load i32, i32* %75
%77 = load i32*, i32** %8
%78 = load i32, i32* %10
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
store i32 %76, i32* %80
br label %81
81: ; preds = %70, %59
br label %82
82: ; preds = %81
%83 = load i32, i32* %10
%84 = add nsw i32 %83, 1
store i32 %84, i32* %10
br label %33
85: ; preds = %33
store i32 0, i32* %10
br label %86
86: ; preds = %104, %85
%87 = load i32, i32* %10
%88 = load i32, i32* %6
%89 = load i32, i32* %5
%90 = sub nsw i32 %88, %89
%91 = icmp slt i32 %87, %90
br i1 %91, label %92, label %107
92: ; preds = %86
%93 = load i32*, i32** %8
%94 = load i32, i32* %10
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
%98 = load i32*, i32** %7
%99 = load i32, i32* %5
%100 = load i32, i32* %10
%101 = add nsw i32 %99, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %98, i64 %102
store i32 %97, i32* %103
br label %104
104: ; preds = %92
%105 = load i32, i32* %10
%106 = add nsw i32 %105, 1
store i32 %106, i32* %10
br label %86
107: ; preds = %17, %86
ret void
}

LLVM IR (-O2):
define void @sort(i32 %0, i32 %1, i32* %2, i32* %3) {
%5 = sub i32 %1, %0
%6 = icmp slt i32 %5, 2
br i1 %6, label %292, label %7
7: ; preds = %4
%8 = add nsw i32 %1, %0
%9 = sdiv i32 %8, 2
tail call void @sort(i32 %0, i32 %9, i32* %2, i32* %3)
tail call void @sort(i32 %9, i32 %1, i32* %2, i32* %3)
%10 = sext i32 %0 to i64
%11 = zext i32 %5 to i64
%12 = icmp ult i32 %5, 8
br i1 %12, label %106, label %13
13: ; preds = %7
%14 = getelementptr i32, i32* %3, i64 %11
%15 = getelementptr i32, i32* %2, i64 %10
%16 = add nsw i64 %10, %11
%17 = getelementptr i32, i32* %2, i64 %16
%18 = icmp ugt i32* %17, %3
%19 = icmp ult i32* %15, %14
%20 = and i1 %18, %19
br i1 %20, label %106, label %21
21: ; preds = %13
%22 = and i64 %11, 4294967288
%23 = add nsw i64 %22, %10
%24 = add nsw i64 %22, -8
%25 = lshr exact i64 %24, 3
%26 = add nuw nsw i64 %25, 1
%27 = and i64 %26, 3
%28 = icmp ult i64 %24, 24
br i1 %28, label %84, label %29
29: ; preds = %21
%30 = and i64 %26, 4611686018427387900
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 0, %29 ], [ %81, %31 ]
%33 = phi i64 [ 0, %29 ], [ %82, %31 ]
%34 = add i64 %32, %10
%35 = getelementptr inbounds i32, i32* %2, i64 %34
%36 = bitcast i32* %35 to <4 x i32>*
%37 = load <4 x i32>, <4 x i32>* %36
%38 = getelementptr inbounds i32, i32* %35, i64 4
%39 = bitcast i32* %38 to <4 x i32>*
%40 = load <4 x i32>, <4 x i32>* %39
%41 = getelementptr inbounds i32, i32* %3, i64 %32
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> %37, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %44
%45 = or i64 %32, 8
%46 = add i64 %45, %10
%47 = getelementptr inbounds i32, i32* %2, i64 %46
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = getelementptr inbounds i32, i32* %47, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %3, i64 %45
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %49, <4 x i32>* %54
%55 = getelementptr inbounds i32, i32* %53, i64 4
%56 = bitcast i32* %55 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %56
%57 = or i64 %32, 16
%58 = add i64 %57, %10
%59 = getelementptr inbounds i32, i32* %2, i64 %58
%60 = bitcast i32* %59 to <4 x i32>*
%61 = load <4 x i32>, <4 x i32>* %60
%62 = getelementptr inbounds i32, i32* %59, i64 4
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = getelementptr inbounds i32, i32* %3, i64 %57
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %61, <4 x i32>* %66
%67 = getelementptr inbounds i32, i32* %65, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %68
%69 = or i64 %32, 24
%70 = add i64 %69, %10
%71 = getelementptr inbounds i32, i32* %2, 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* %3, i64 %69
%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 %32, 32
%82 = add i64 %33, 4
%83 = icmp eq i64 %82, %30
br i1 %83, label %84, label %31
84: ; preds = %31, %21
%85 = phi i64 [ 0, %21 ], [ %81, %31 ]
%86 = icmp eq i64 %27, 0
br i1 %86, label %104, label %87
87: ; preds = %84, %87
%88 = phi i64 [ %101, %87 ], [ %85, %84 ]
%89 = phi i64 [ %102, %87 ], [ 0, %84 ]
%90 = add i64 %88, %10
%91 = getelementptr inbounds i32, i32* %2, 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* %3, i64 %88
%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
%101 = add nuw i64 %88, 8
%102 = add i64 %89, 1
%103 = icmp eq i64 %102, %27
br i1 %103, label %104, label %87
104: ; preds = %87, %84
%105 = icmp eq i64 %22, %11
br i1 %105, label %128, label %106
106: ; preds = %13, %7, %104
%107 = phi i64 [ %10, %13 ], [ %10, %7 ], [ %23, %104 ]
%108 = phi i64 [ 0, %13 ], [ 0, %7 ], [ %22, %104 ]
%109 = xor i64 %108, -1
%110 = add nsw i64 %109, %11
%111 = and i64 %11, 3
%112 = icmp eq i64 %111, 0
br i1 %112, label %124, label %113
113: ; preds = %106, %113
%114 = phi i64 [ %120, %113 ], [ %107, %106 ]
%115 = phi i64 [ %121, %113 ], [ %108, %106 ]
%116 = phi i64 [ %122, %113 ], [ 0, %106 ]
%117 = getelementptr inbounds i32, i32* %2, i64 %114
%118 = load i32, i32* %117
%119 = getelementptr inbounds i32, i32* %3, i64 %115
store i32 %118, i32* %119
%120 = add nsw i64 %114, 1
%121 = add nuw nsw i64 %115, 1
%122 = add i64 %116, 1
%123 = icmp eq i64 %122, %111
br i1 %123, label %124, label %113
124: ; preds = %113, %106
%125 = phi i64 [ %107, %106 ], [ %120, %113 ]
%126 = phi i64 [ %108, %106 ], [ %121, %113 ]
%127 = icmp ult i64 %110, 3
br i1 %127, label %128, label %245
128: ; preds = %124, %245, %104
%129 = icmp sgt i32 %5, 0
br i1 %129, label %130, label %292
130: ; preds = %128
%131 = sext i32 %0 to i64
%132 = zext i32 %5 to i64
%133 = icmp ult i32 %5, 8
br i1 %133, label %226, label %134
134: ; preds = %130
%135 = getelementptr i32, i32* %2, i64 %10
%136 = add nsw i64 %10, %11
%137 = getelementptr i32, i32* %2, i64 %136
%138 = getelementptr i32, i32* %3, i64 %11
%139 = icmp ult i32* %135, %138
%140 = icmp ugt i32* %137, %3
%141 = and i1 %139, %140
br i1 %141, label %226, label %142
142: ; preds = %134
%143 = and i64 %11, 4294967288
%144 = add nsw i64 %143, -8
%145 = lshr exact i64 %144, 3
%146 = add nuw nsw i64 %145, 1
%147 = and i64 %146, 3
%148 = icmp ult i64 %144, 24
br i1 %148, label %204, label %149
149: ; preds = %142
%150 = and i64 %146, 4611686018427387900
br label %151
151: ; preds = %151, %149
%152 = phi i64 [ 0, %149 ], [ %201, %151 ]
%153 = phi i64 [ 0, %149 ], [ %202, %151 ]
%154 = getelementptr inbounds i32, i32* %3, i64 %152
%155 = bitcast i32* %154 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = getelementptr inbounds i32, i32* %154, i64 4
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = add nsw i64 %152, %131
%161 = getelementptr inbounds i32, i32* %2, i64 %160
%162 = bitcast i32* %161 to <4 x i32>*
store <4 x i32> %156, <4 x i32>* %162
%163 = getelementptr inbounds i32, i32* %161, i64 4
%164 = bitcast i32* %163 to <4 x i32>*
store <4 x i32> %159, <4 x i32>* %164
%165 = or i64 %152, 8
%166 = getelementptr inbounds i32, i32* %3, i64 %165
%167 = bitcast i32* %166 to <4 x i32>*
%168 = load <4 x i32>, <4 x i32>* %167
%169 = getelementptr inbounds i32, i32* %166, i64 4
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = add nsw i64 %165, %131
%173 = getelementptr inbounds i32, i32* %2, i64 %172
%174 = bitcast i32* %173 to <4 x i32>*
store <4 x i32> %168, <4 x i32>* %174
%175 = getelementptr inbounds i32, i32* %173, i64 4
%176 = bitcast i32* %175 to <4 x i32>*
store <4 x i32> %171, <4 x i32>* %176
%177 = or i64 %152, 16
%178 = getelementptr inbounds i32, i32* %3, i64 %177
%179 = bitcast i32* %178 to <4 x i32>*
%180 = load <4 x i32>, <4 x i32>* %179
%181 = getelementptr inbounds i32, i32* %178, i64 4
%182 = bitcast i32* %181 to <4 x i32>*
%183 = load <4 x i32>, <4 x i32>* %182
%184 = add nsw i64 %177, %131
%185 = getelementptr inbounds i32, i32* %2, i64 %184
%186 = bitcast i32* %185 to <4 x i32>*
store <4 x i32> %180, <4 x i32>* %186
%187 = getelementptr inbounds i32, i32* %185, i64 4
%188 = bitcast i32* %187 to <4 x i32>*
store <4 x i32> %183, <4 x i32>* %188
%189 = or i64 %152, 24
%190 = getelementptr inbounds i32, i32* %3, i64 %189
%191 = bitcast i32* %190 to <4 x i32>*
%192 = load <4 x i32>, <4 x i32>* %191
%193 = getelementptr inbounds i32, i32* %190, i64 4
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = add nsw i64 %189, %131
%197 = getelementptr inbounds i32, i32* %2, i64 %196
%198 = bitcast i32* %197 to <4 x i32>*
store <4 x i32> %192, <4 x i32>* %198
%199 = getelementptr inbounds i32, i32* %197, i64 4
%200 = bitcast i32* %199 to <4 x i32>*
store <4 x i32> %195, <4 x i32>* %200
%201 = add nuw i64 %152, 32
%202 = add i64 %153, 4
%203 = icmp eq i64 %202, %150
br i1 %203, label %204, label %151
204: ; preds = %151, %142
%205 = phi i64 [ 0, %142 ], [ %201, %151 ]
%206 = icmp eq i64 %147, 0
br i1 %206, label %224, label %207
207: ; preds = %204, %207
%208 = phi i64 [ %221, %207 ], [ %205, %204 ]
%209 = phi i64 [ %222, %207 ], [ 0, %204 ]
%210 = getelementptr inbounds i32, i32* %3, i64 %208
%211 = bitcast i32* %210 to <4 x i32>*
%212 = load <4 x i32>, <4 x i32>* %211
%213 = getelementptr inbounds i32, i32* %210, i64 4
%214 = bitcast i32* %213 to <4 x i32>*
%215 = load <4 x i32>, <4 x i32>* %214
%216 = add nsw i64 %208, %131
%217 = getelementptr inbounds i32, i32* %2, i64 %216
%218 = bitcast i32* %217 to <4 x i32>*
store <4 x i32> %212, <4 x i32>* %218
%219 = getelementptr inbounds i32, i32* %217, i64 4
%220 = bitcast i32* %219 to <4 x i32>*
store <4 x i32> %215, <4 x i32>* %220
%221 = add nuw i64 %208, 8
%222 = add i64 %209, 1
%223 = icmp eq i64 %222, %147
br i1 %223, label %224, label %207
224: ; preds = %207, %204
%225 = icmp eq i64 %143, %11
br i1 %225, label %292, label %226
226: ; preds = %134, %130, %224
%227 = phi i64 [ 0, %134 ], [ 0, %130 ], [ %143, %224 ]
%228 = xor i64 %227, -1
%229 = add nsw i64 %228, %11
%230 = and i64 %11, 3
%231 = icmp eq i64 %230, 0
br i1 %231, label %242, label %232
232: ; preds = %226, %232
%233 = phi i64 [ %239, %232 ], [ %227, %226 ]
%234 = phi i64 [ %240, %232 ], [ 0, %226 ]
%235 = getelementptr inbounds i32, i32* %3, i64 %233
%236 = load i32, i32* %235
%237 = add nsw i64 %233, %131
%238 = getelementptr inbounds i32, i32* %2, i64 %237
store i32 %236, i32* %238
%239 = add nuw nsw i64 %233, 1
%240 = add i64 %234, 1
%241 = icmp eq i64 %240, %230
br i1 %241, label %242, label %232
242: ; preds = %232, %226
%243 = phi i64 [ %227, %226 ], [ %239, %232 ]
%244 = icmp ult i64 %229, 3
br i1 %244, label %292, label %269
245: ; preds = %124, %245
%246 = phi i64 [ %266, %245 ], [ %125, %124 ]
%247 = phi i64 [ %267, %245 ], [ %126, %124 ]
%248 = getelementptr inbounds i32, i32* %2, i64 %246
%249 = load i32, i32* %248
%250 = getelementptr inbounds i32, i32* %3, i64 %247
store i32 %249, i32* %250
%251 = add nsw i64 %246, 1
%252 = add nuw nsw i64 %247, 1
%253 = getelementptr inbounds i32, i32* %2, i64 %251
%254 = load i32, i32* %253
%255 = getelementptr inbounds i32, i32* %3, i64 %252
store i32 %254, i32* %255
%256 = add nsw i64 %246, 2
%257 = add nuw nsw i64 %247, 2
%258 = getelementptr inbounds i32, i32* %2, i64 %256
%259 = load i32, i32* %258
%260 = getelementptr inbounds i32, i32* %3, i64 %257
store i32 %259, i32* %260
%261 = add nsw i64 %246, 3
%262 = add nuw nsw i64 %247, 3
%263 = getelementptr inbounds i32, i32* %2, i64 %261
%264 = load i32, i32* %263
%265 = getelementptr inbounds i32, i32* %3, i64 %262
store i32 %264, i32* %265
%266 = add nsw i64 %246, 4
%267 = add nuw nsw i64 %247, 4
%268 = icmp eq i64 %267, %11
br i1 %268, label %128, label %245
269: ; preds = %242, %269
%270 = phi i64 [ %290, %269 ], [ %243, %242 ]
%271 = getelementptr inbounds i32, i32* %3, i64 %270
%272 = load i32, i32* %271
%273 = add nsw i64 %270, %131
%274 = getelementptr inbounds i32, i32* %2, i64 %273
store i32 %272, i32* %274
%275 = add nuw nsw i64 %270, 1
%276 = getelementptr inbounds i32, i32* %3, i64 %275
%277 = load i32, i32* %276
%278 = add nsw i64 %275, %131
%279 = getelementptr inbounds i32, i32* %2, i64 %278
store i32 %277, i32* %279
%280 = add nuw nsw i64 %270, 2
%281 = getelementptr inbounds i32, i32* %3, i64 %280
%282 = load i32, i32* %281
%283 = add nsw i64 %280, %131
%284 = getelementptr inbounds i32, i32* %2, i64 %283
store i32 %282, i32* %284
%285 = add nuw nsw i64 %270, 3
%286 = getelementptr inbounds i32, i32* %3, i64 %285
%287 = load i32, i32* %286
%288 = add nsw i64 %285, %131
%289 = getelementptr inbounds i32, i32* %2, i64 %288
store i32 %287, i32* %289
%290 = add nuw nsw i64 %270, 4
%291 = icmp eq i64 %290, %132
br i1 %291, label %292, label %269
292: ; preds = %242, %269, %224, %128, %4
ret void
}