#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 */
scalar_t__ malloc(int);
int med(int *, int, int, int);
int part(int a[], int l, int u) {
  if (l == u)
    return (l);
  int m = med(a, l, l, u);
  int n = u - l, i;
  int *bm, *am, bmn = 0, amn = 0;
  bm = (int *)malloc(n * sizeof(int));
  am = (int *)malloc(n * sizeof(int));
  for (i = 0; i < n; i++) {
    if (a[l + i] < m) {
      bm[bmn] = a[l + i];
      bmn++;
    } else if (a[l + i] > m) {
      am[amn] = a[l + i];
      amn++;
    }
  }
  for (i = 0; i < bmn; i++)
    a[l + i] = bm[i];
  a[l + i] = m;
  m = l + i;
  for (i = 0; i < amn; i++)
    a[l + i + bmn + 1] = am[i];
  return (m);
}


x86 assembly (clang, -O0):
<part>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    1149 <part+0x29>
mov    -0x14(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    12e5 <part+0x1c5>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
call   1040 <med@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1245 <part+0x125>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jge    11f0 <part+0xd0>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1232 <part+0x112>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jle    122d <part+0x10d>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1232 <part+0x112>
jmp    1237 <part+0x117>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a2 <part+0x82>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1281 <part+0x161>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    124c <part+0x12c>
mov    -0x1c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12df <part+0x1bf>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12a4 <part+0x184>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<part>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%ecx
mov    %edx,%ebx
sub    %esi,%ebx
jne    113b <part+0x1b>
mov    %ecx,%r14d
jmp    132f <part+0x20f>
mov    %esi,%r14d
mov    %rdi,%r12
mov    %esi,%edx
call   1040 <med@plt>
mov    %eax,%r15d
lea    0x0(,%rbx,4),%r13d
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,%rbp
mov    %r13d,%edi
call   1030 <malloc@plt>
movslq %r14d,%r8
test   %ebx,%ebx
jle    126d <part+0x14d>
mov    %ebx,%edx
lea    (%r12,%r8,4),%rbx
xor    %edi,%edi
xor    %r11d,%r11d
xor    %r13d,%r13d
jmp    11a5 <part+0x85>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r13d,%r13
mov    %ecx,0x0(%rbp,%r13,4)
add    $0x1,%r13d
add    $0x1,%rdi
cmp    %rdi,%rdx
je     11bc <part+0x9c>
mov    (%rbx,%rdi,4),%ecx
cmp    %r15d,%ecx
jl     1190 <part+0x70>
jle    119c <part+0x7c>
movslq %r11d,%r11
mov    %ecx,(%rax,%r11,4)
add    $0x1,%r11d
jmp    119c <part+0x7c>
test   %r13d,%r13d
jle    1276 <part+0x156>
mov    %r13d,%r10d
cmp    $0x8,%r13d
jb     11f3 <part+0xd3>
lea    0x0(,%r10,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%rbx
jae    1414 <part+0x2f4>
lea    (%r8,%r10,1),%rcx
lea    (%r12,%rcx,4),%rcx
cmp    %rcx,%rbp
jae    1414 <part+0x2f4>
xor    %edi,%edi
mov    %rdi,%rcx
not    %rcx
add    %r10,%rcx
mov    %r10,%rdx
and    $0x3,%rdx
je     1221 <part+0x101>
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rdi,4),%esi
mov    %esi,(%rbx,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    1210 <part+0xf0>
mov    %r13d,%r9d
cmp    $0x3,%rcx
jb     1279 <part+0x159>
lea    (%r12,%r8,4),%rcx
add    $0xc,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%rbp,%rdi,4),%edx
mov    %edx,-0xc(%rcx,%rdi,4)
mov    0x4(%rbp,%rdi,4),%edx
mov    %edx,-0x8(%rcx,%rdi,4)
mov    0x8(%rbp,%rdi,4),%edx
mov    %edx,-0x4(%rcx,%rdi,4)
mov    0xc(%rbp,%rdi,4),%edx
mov    %edx,(%rcx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%r10
jne    1240 <part+0x120>
mov    %r13d,%r9d
jmp    1279 <part+0x159>
mov    %r15d,(%r12,%r8,4)
jmp    132f <part+0x20f>
xor    %r9d,%r9d
add    %r14d,%r9d
movslq %r9d,%rcx
mov    %r15d,(%r12,%rcx,4)
test   %r11d,%r11d
jle    132c <part+0x20c>
mov    %r11d,%r10d
cmp    $0x8,%r11d
jae    1341 <part+0x221>
xor    %esi,%esi
mov    %rsi,%rdx
not    %rdx
add    %r10,%rdx
mov    %r10,%rcx
and    $0x3,%rcx
je     12d7 <part+0x1b7>
lea    (%r14,%r13,1),%ebp
add    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax,%rsi,4),%ebx
lea    (%rsi,%rbp,1),%edi
movslq %edi,%rdi
mov    %ebx,(%r12,%rdi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    12c0 <part+0x1a0>
cmp    $0x3,%rdx
jb     132c <part+0x20c>
add    %r13d,%r14d
mov    (%rax,%rsi,4),%ecx
lea    (%r14,%rsi,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    %ecx,(%r12,%rdx,4)
mov    0x4(%rax,%rsi,4),%ecx
lea    0x2(%r14,%rsi,1),%edx
movslq %edx,%rdx
mov    %ecx,(%r12,%rdx,4)
mov    0x8(%rax,%rsi,4),%ecx
lea    0x3(%r14,%rsi,1),%edx
movslq %edx,%rdx
mov    %ecx,(%r12,%rdx,4)
mov    0xc(%rax,%rsi,4),%ecx
lea    (%r14,%rsi,1),%edx
add    $0x4,%edx
movslq %edx,%rdx
mov    %ecx,(%r12,%rdx,4)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    12e0 <part+0x1c0>
mov    %r9d,%r14d
mov    %r14d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r10),%rcx
lea    (%r14,%r13,1),%edx
lea    (%r14,%r13,1),%ebp
add    $0x1,%ebp
add    %ecx,%edx
add    $0x1,%edx
xor    %esi,%esi
cmp    %ebp,%edx
jl     129b <part+0x17b>
shr    $0x20,%rcx
jne    129b <part+0x17b>
lea    (%r14,%r13,1),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    (%rcx,%r10,1),%rdx
lea    (%r12,%rdx,4),%rdx
cmp    %rdx,%rax
jae    1391 <part+0x271>
lea    (%rax,%r10,4),%rdx
lea    (%r12,%rcx,4),%rcx
cmp    %rdx,%rcx
jb     1299 <part+0x179>
mov    %r10d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     14fc <part+0x3dc>
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
or     $0x2,%rbx
and    %r8,%rbx
lea    (%r14,%r13,1),%edx
add    $0x9,%edx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups (%rax,%rbp,4),%xmm0
movups 0x10(%rax,%rbp,4),%xmm1
lea    -0x8(%rdx),%ecx
movslq %ecx,%rcx
movups %xmm0,(%r12,%rcx,4)
movups %xmm1,0x10(%r12,%rcx,4)
movups 0x20(%rax,%rbp,4),%xmm0
movups 0x30(%rax,%rbp,4),%xmm1
movslq %edx,%rdx
movups %xmm0,(%r12,%rdx,4)
movups %xmm1,0x10(%r12,%rdx,4)
add    $0x10,%rbp
add    $0x10,%edx
add    $0xfffffffffffffffe,%rbx
jne    13d0 <part+0x2b0>
jmp    14fe <part+0x3de>
mov    %r10d,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r9d
and    $0x3,%r9d
cmp    $0x18,%rcx
jae    143a <part+0x31a>
xor    %esi,%esi
jmp    14a9 <part+0x389>
and    $0xfffffffffffffffc,%rdx
lea    (%r12,%r8,4),%rcx
add    $0x70,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rsi,4),%xmm0
movups 0x10(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x70(%rcx,%rsi,4)
movups %xmm1,-0x60(%rcx,%rsi,4)
movups 0x20(%rbp,%rsi,4),%xmm0
movups 0x30(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x50(%rcx,%rsi,4)
movups %xmm1,-0x40(%rcx,%rsi,4)
movups 0x40(%rbp,%rsi,4),%xmm0
movups 0x50(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x30(%rcx,%rsi,4)
movups %xmm1,-0x20(%rcx,%rsi,4)
movups 0x60(%rbp,%rsi,4),%xmm0
movups 0x70(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,4)
movups %xmm1,(%rcx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1450 <part+0x330>
test   %r9,%r9
je     14eb <part+0x3cb>
lea    (%rsi,%r8,1),%rcx
lea    (%r12,%rcx,4),%rcx
add    $0x10,%rcx
lea    0x10(,%rsi,4),%rdx
add    %rbp,%rdx
shl    $0x5,%r9
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rsi,1),%xmm0
movups (%rdx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,1)
movups %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r9
jne    14d0 <part+0x3b0>
mov    %r13d,%r9d
cmp    %r10,%rdi
je     1279 <part+0x159>
jmp    11f5 <part+0xd5>
xor    %ebp,%ebp
test   $0x1,%r8b
je     1524 <part+0x404>
lea    (%r14,%r13,1),%ecx
add    $0x1,%ecx
movups (%rax,%rbp,4),%xmm0
movups 0x10(%rax,%rbp,4),%xmm1
add    %ebp,%ecx
movslq %ecx,%rcx
movups %xmm0,(%r12,%rcx,4)
movups %xmm1,0x10(%r12,%rcx,4)
cmp    %r10,%rsi
jne    129b <part+0x17b>
jmp    132c <part+0x20c>

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

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