int range_constraint(int **m_old, int **m_new, int range_threshold,
                     int n_entries, int n_motifs) {
  int i, j;
  int running_n = 0;
  int max;
  int min;
  int range;
  for (i = 1; i <= n_entries; i++) {
    max = 0;
    min = 100000000;
    for (j = 1; j <= n_motifs; j++) {
      if (m_old[i][j] < min)
        min = m_old[i][j];
      if (m_old[i][j] > max)
        max = m_old[i][j];
    }
    range = max - min;
    if (range < range_threshold) {
      running_n++;
      for (j = 1; j <= n_motifs; j++)
        m_new[running_n][j] = m_old[i][j];
    }
  }
  return running_n;
}


x86 assembly (clang, -O0):
<range_constraint>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1245 <range_constraint+0x145>
movl   $0x0,-0x2c(%rbp)
movl   $0x5f5e100,-0x30(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11c8 <range_constraint+0xc8>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
jge    1183 <range_constraint+0x83>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x2c(%rbp),%eax
jle    11b5 <range_constraint+0xb5>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
jmp    11ba <range_constraint+0xba>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1145 <range_constraint+0x45>
mov    -0x2c(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1232 <range_constraint+0x132>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     122d <range_constraint+0x12d>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ed <range_constraint+0xed>
jmp    1232 <range_constraint+0x132>
jmp    1237 <range_constraint+0x137>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1124 <range_constraint+0x24>
mov    -0x28(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<range_constraint>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,-0x10(%rsp)
test   %ecx,%ecx
jle    1600 <range_constraint+0x500>
lea    0x1(%r8),%r10d
add    $0x1,%ecx
xor    %r14d,%r14d
cmp    $0xfa0a1f01,%edx
setge  %r14b
lea    -0x1(%r10),%r11
lea    -0x9(%r10),%rax
mov    %rax,-0x28(%rsp)
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %r11,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rsp)
add    $0x1,%rax
mov    %rax,-0x38(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
or     $0x2,%rax
and    %rsi,%rax
mov    %rax,-0x18(%rsp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,-0x40(%rsp)
mov    %rsi,%rax
mov    %rsi,-0x8(%rsp)
and    $0xfffffffffffffffc,%rsi
mov    %rsi,-0x20(%rsp)
xor    %eax,%eax
mov    $0x1,%r12d
movdqa 0xe66(%rip),%xmm8
jmp    11b0 <range_constraint+0xb0>
nopl   0x0(%rax)
add    %r14d,%eax
add    $0x1,%r12
cmp    %rcx,%r12
je     1602 <range_constraint+0x502>
test   %r8d,%r8d
jle    11a0 <range_constraint+0xa0>
mov    (%rdi,%r12,8),%r13
cmp    $0x8,%r11
jae    11e0 <range_constraint+0xe0>
xor    %r9d,%r9d
mov    $0x5f5e100,%ebx
mov    $0x1,%ebp
jmp    1440 <range_constraint+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x8,-0x28(%rsp)
jae    1201 <range_constraint+0x101>
pxor   %xmm3,%xmm3
xor    %esi,%esi
movdqa %xmm8,%xmm2
movdqa %xmm8,%xmm0
pxor   %xmm4,%xmm4
jmp    1309 <range_constraint+0x209>
pxor   %xmm3,%xmm3
mov    -0x18(%rsp),%rbx
xor    %esi,%esi
movdqa %xmm8,%xmm2
movdqa %xmm8,%xmm0
pxor   %xmm4,%xmm4
nopw   0x0(%rax,%rax,1)
movdqu 0x4(%r13,%rsi,4),%xmm6
movdqu 0x14(%r13,%rsi,4),%xmm11
movdqu 0x24(%r13,%rsi,4),%xmm10
movdqu 0x34(%r13,%rsi,4),%xmm9
movdqa %xmm2,%xmm7
pcmpgtd %xmm6,%xmm7
movdqa %xmm6,%xmm1
pand   %xmm7,%xmm1
pandn  %xmm2,%xmm7
por    %xmm1,%xmm7
movdqa %xmm0,%xmm1
pcmpgtd %xmm11,%xmm1
movdqa %xmm11,%xmm2
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
movdqa %xmm6,%xmm5
pcmpgtd %xmm3,%xmm5
pand   %xmm5,%xmm6
pandn  %xmm3,%xmm5
por    %xmm6,%xmm5
movdqa %xmm11,%xmm6
pcmpgtd %xmm4,%xmm6
pand   %xmm6,%xmm11
pandn  %xmm4,%xmm6
por    %xmm11,%xmm6
movdqa %xmm7,%xmm2
pcmpgtd %xmm10,%xmm2
movdqa %xmm10,%xmm0
pand   %xmm2,%xmm0
pandn  %xmm7,%xmm2
por    %xmm0,%xmm2
movdqa %xmm1,%xmm0
pcmpgtd %xmm9,%xmm0
movdqa %xmm9,%xmm3
pand   %xmm0,%xmm3
pandn  %xmm1,%xmm0
por    %xmm3,%xmm0
movdqa %xmm10,%xmm3
pcmpgtd %xmm5,%xmm3
pand   %xmm3,%xmm10
pandn  %xmm5,%xmm3
por    %xmm10,%xmm3
movdqa %xmm9,%xmm4
pcmpgtd %xmm6,%xmm4
pand   %xmm4,%xmm9
pandn  %xmm6,%xmm4
por    %xmm9,%xmm4
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1220 <range_constraint+0x120>
testb  $0x1,-0x8(%rsp)
je     1397 <range_constraint+0x297>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu 0x0(%r13,%rsi,1),%xmm5
movdqu 0x10(%r13,%rsi,1),%xmm9
movdqa %xmm2,%xmm6
pcmpgtd %xmm5,%xmm6
movdqa %xmm5,%xmm7
pand   %xmm6,%xmm7
pandn  %xmm2,%xmm6
por    %xmm7,%xmm6
movdqa %xmm0,%xmm7
pcmpgtd %xmm9,%xmm7
movdqa %xmm9,%xmm2
pand   %xmm7,%xmm2
pandn  %xmm0,%xmm7
por    %xmm2,%xmm7
movdqa %xmm5,%xmm1
pcmpgtd %xmm3,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm3,%xmm1
por    %xmm5,%xmm1
movdqa %xmm9,%xmm5
pcmpgtd %xmm4,%xmm5
pand   %xmm5,%xmm9
pandn  %xmm4,%xmm5
por    %xmm9,%xmm5
movdqa %xmm6,%xmm2
movdqa %xmm7,%xmm0
movdqa %xmm1,%xmm3
movdqa %xmm5,%xmm4
movdqa %xmm3,%xmm1
pcmpgtd %xmm4,%xmm1
pand   %xmm1,%xmm3
pandn  %xmm4,%xmm1
por    %xmm3,%xmm1
pshufd $0xee,%xmm1,%xmm3
movdqa %xmm1,%xmm4
pcmpgtd %xmm3,%xmm4
pand   %xmm4,%xmm1
pandn  %xmm3,%xmm4
por    %xmm1,%xmm4
pshufd $0x55,%xmm4,%xmm1
movdqa %xmm4,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm1,%xmm3
por    %xmm4,%xmm3
movd   %xmm3,%r9d
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
movd   %xmm1,%ebx
mov    -0x38(%rsp),%rbp
cmp    -0x30(%rsp),%r11
je     145a <range_constraint+0x35a>
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbp,4),%esi
cmp    %ebx,%esi
cmovl  %esi,%ebx
cmp    %r9d,%esi
cmovg  %esi,%r9d
add    $0x1,%rbp
cmp    %rbp,%r10
jne    1440 <range_constraint+0x340>
sub    %ebx,%r9d
cmp    %edx,%r9d
jge    11a3 <range_constraint+0xa3>
add    $0x1,%eax
test   %r8d,%r8d
jle    11a3 <range_constraint+0xa3>
mov    (%rdi,%r12,8),%r15
movslq %eax,%rbp
mov    -0x10(%rsp),%rsi
mov    (%rsi,%rbp,8),%rbx
mov    $0x1,%ebp
cmp    $0x8,%r11
jb     158e <range_constraint+0x48e>
lea    0x4(%rbx),%r9
lea    (%r15,%r10,4),%rsi
cmp    %rsi,%r9
jae    14af <range_constraint+0x3af>
lea    (%rbx,%r10,4),%r9
lea    0x4(%r15),%rsi
cmp    %r9,%rsi
jb     158e <range_constraint+0x48e>
cmpq   $0x18,-0x28(%rsp)
jae    14bb <range_constraint+0x3bb>
xor    %ebp,%ebp
jmp    1536 <range_constraint+0x436>
mov    -0x20(%rsp),%r13
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x4(%r15,%rbp,4),%xmm0
movups 0x14(%r15,%rbp,4),%xmm1
movups %xmm0,0x4(%rbx,%rbp,4)
movups %xmm1,0x14(%rbx,%rbp,4)
movups 0x24(%r15,%rbp,4),%xmm0
movups 0x34(%r15,%rbp,4),%xmm1
movups %xmm0,0x24(%rbx,%rbp,4)
movups %xmm1,0x34(%rbx,%rbp,4)
movups 0x44(%r15,%rbp,4),%xmm0
movups 0x54(%r15,%rbp,4),%xmm1
movups %xmm0,0x44(%rbx,%rbp,4)
movups %xmm1,0x54(%rbx,%rbp,4)
movdqu 0x64(%r15,%rbp,4),%xmm0
movdqu 0x74(%r15,%rbp,4),%xmm1
movdqu %xmm0,0x64(%rbx,%rbp,4)
movdqu %xmm1,0x74(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%r13
jne    14d0 <range_constraint+0x3d0>
cmpq   $0x0,-0x40(%rsp)
je     157e <range_constraint+0x47e>
mov    -0x40(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rbp,4),%rsi
or     $0x4,%rsi
movdqu (%r15,%rsi,1),%xmm0
movdqu 0x10(%r15,%rsi,1),%xmm1
movdqu %xmm0,(%rbx,%rsi,1)
movdqu %xmm1,0x10(%rbx,%rsi,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%r9
jne    1550 <range_constraint+0x450>
mov    -0x38(%rsp),%rbp
cmp    -0x30(%rsp),%r11
je     11a3 <range_constraint+0xa3>
mov    %r10d,%r9d
sub    %ebp,%r9d
mov    %rbp,%r13
not    %r13
add    %r10,%r13
and    $0x3,%r9
je     15c1 <range_constraint+0x4c1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rbp,4),%esi
mov    %esi,(%rbx,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%r9
jne    15b0 <range_constraint+0x4b0>
cmp    $0x3,%r13
jb     11a3 <range_constraint+0xa3>
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbp,4),%esi
mov    %esi,(%rbx,%rbp,4)
mov    0x4(%r15,%rbp,4),%esi
mov    %esi,0x4(%rbx,%rbp,4)
mov    0x8(%r15,%rbp,4),%esi
mov    %esi,0x8(%rbx,%rbp,4)
mov    0xc(%r15,%rbp,4),%esi
mov    %esi,0xc(%rbx,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%r10
jne    15d0 <range_constraint+0x4d0>
jmp    11a3 <range_constraint+0xa3>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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