#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 */
typedef int /*<<< orphan*/ values;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int find_outlier(int *, size_t);
int main() {
  {
    int values[] = {2, 6, 8, 10, 3};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 3;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {2, 6, 8, 200, 700, 1, 84, 10, 4};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 1;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {17, 6, 8, 10, 6, 12, 24, 36};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 17;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {2, 1, 7, 17, 19, 211, 7};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 2;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {1, 1, 1, 1, 1, 44, 7, 7, 7, 7, 7, 7, 7, 7};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 44;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 35,
                    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 7, 1000};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 1000;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {2, -6, 8, -10, -3};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = -3;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {2, 6, 8, 2, -66, 34, -35, 66, 700, 1002, -84, 10, 4};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = -35;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {-20, 1, 7, 17, 19, 211, 7};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = -20;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {1, 1, -1, 1, 1, -44, 7, 7, 7, 7, 7, 7, 7, 7};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = -44;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {1, 0, 0};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 1;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
  {
    int values[] = {3, 7, -99, 81, 90211, 0, 7};
    size_t count = sizeof(values) / sizeof(values[0]);
    int expected = 0;
    int received = find_outlier(values, count);
    assert(expected == received);
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x300,%rsp
mov    0xebe(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0xebb(%rip),%rax
mov    %rax,-0x18(%rbp)
mov    0xeb9(%rip),%eax
mov    %eax,-0x10(%rbp)
movq   $0x5,-0x28(%rbp)
movl   $0x3,-0x2c(%rbp)
lea    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    -0x60(%rbp),%rdi
lea    0xe89(%rip),%rsi
mov    $0x24,%edx
call   1040 <memcpy@plt>
movq   $0x9,-0x68(%rbp)
movl   $0x1,-0x6c(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x68(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x70(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x1046(%rip),%rax
mov    %rax,-0x90(%rbp)
mov    0x1040(%rip),%rax
mov    %rax,-0x88(%rbp)
mov    0x103a(%rip),%rax
mov    %rax,-0x80(%rbp)
mov    0x1037(%rip),%rax
mov    %rax,-0x78(%rbp)
movq   $0x8,-0x98(%rbp)
movl   $0x11,-0x9c(%rbp)
lea    -0x90(%rbp),%rdi
mov    -0x98(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0xa0(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xa0(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0xdfd(%rip),%rax
mov    %rax,-0xc0(%rbp)
mov    0xdf7(%rip),%rax
mov    %rax,-0xb8(%rbp)
mov    0xdf1(%rip),%rax
mov    %rax,-0xb0(%rbp)
mov    0xdec(%rip),%eax
mov    %eax,-0xa8(%rbp)
movq   $0x7,-0xc8(%rbp)
movl   $0x2,-0xcc(%rbp)
lea    -0xc0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0xd0(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0xd0(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    -0x110(%rbp),%rdi
lea    0xd99(%rip),%rsi
mov    $0x38,%edx
call   1040 <memcpy@plt>
movq   $0xe,-0x118(%rbp)
movl   $0x2c,-0x11c(%rbp)
lea    -0x110(%rbp),%rdi
mov    -0x118(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x120(%rbp)
mov    -0x11c(%rbp),%eax
cmp    -0x120(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    -0x1a0(%rbp),%rdi
lea    0xd7a(%rip),%rsi
mov    $0x78,%edx
call   1040 <memcpy@plt>
movq   $0x1e,-0x1a8(%rbp)
movl   $0x3e8,-0x1ac(%rbp)
lea    -0x1a0(%rbp),%rdi
mov    -0x1a8(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x1b0(%rbp)
mov    -0x1ac(%rbp),%eax
cmp    -0x1b0(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0xda2(%rip),%rax
mov    %rax,-0x1d0(%rbp)
mov    0xd9c(%rip),%rax
mov    %rax,-0x1c8(%rbp)
mov    0xd97(%rip),%eax
mov    %eax,-0x1c0(%rbp)
movq   $0x5,-0x1d8(%rbp)
movl   $0xfffffffd,-0x1dc(%rbp)
ff ff ff
lea    -0x1d0(%rbp),%rdi
mov    -0x1d8(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x1e0(%rbp)
mov    -0x1dc(%rbp),%eax
cmp    -0x1e0(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    -0x220(%rbp),%rdi
lea    0xd4c(%rip),%rsi
mov    $0x34,%edx
call   1040 <memcpy@plt>
movq   $0xd,-0x228(%rbp)
movl   $0xffffffdd,-0x22c(%rbp)
ff ff ff
lea    -0x220(%rbp),%rdi
mov    -0x228(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x230(%rbp)
mov    -0x22c(%rbp),%eax
cmp    -0x230(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0xd34(%rip),%rax
mov    %rax,-0x250(%rbp)
mov    0xd2e(%rip),%rax
mov    %rax,-0x248(%rbp)
mov    0xd28(%rip),%rax
mov    %rax,-0x240(%rbp)
mov    0xd23(%rip),%eax
mov    %eax,-0x238(%rbp)
movq   $0x7,-0x258(%rbp)
movl   $0xffffffec,-0x25c(%rbp)
ff ff ff
lea    -0x250(%rbp),%rdi
mov    -0x258(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x260(%rbp)
mov    -0x25c(%rbp),%eax
cmp    -0x260(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
lea    -0x2a0(%rbp),%rdi
lea    0xcd0(%rip),%rsi
mov    $0x38,%edx
call   1040 <memcpy@plt>
movq   $0xe,-0x2a8(%rbp)
movl   $0xffffffd4,-0x2ac(%rbp)
ff ff ff
lea    -0x2a0(%rbp),%rdi
mov    -0x2a8(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x2b0(%rbp)
mov    -0x2ac(%rbp),%eax
cmp    -0x2b0(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0xcb0(%rip),%rax
mov    %rax,-0x2bc(%rbp)
mov    0xcab(%rip),%eax
mov    %eax,-0x2b4(%rbp)
movq   $0x3,-0x2c8(%rbp)
movl   $0x1,-0x2cc(%rbp)
lea    -0x2bc(%rbp),%rdi
mov    -0x2c8(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x2d0(%rbp)
mov    -0x2cc(%rbp),%eax
cmp    -0x2d0(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0xc67(%rip),%rax
mov    %rax,-0x2f0(%rbp)
mov    0xc61(%rip),%rax
mov    %rax,-0x2e8(%rbp)
mov    0xc5b(%rip),%rax
mov    %rax,-0x2e0(%rbp)
mov    0xc56(%rip),%eax
mov    %eax,-0x2d8(%rbp)
movq   $0x7,-0x2f8(%rbp)
movl   $0x0,-0x2fc(%rbp)
lea    -0x2f0(%rbp),%rdi
mov    -0x2f8(%rbp),%rsi
call   1050 <find_outlier@plt>
mov    %eax,-0x300(%rbp)
mov    -0x2fc(%rbp),%eax
cmp    -0x300(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
add    $0x300,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
sub    $0x78,%rsp
mov    0xee6(%rip),%eax
mov    %eax,0x10(%rsp)
movaps 0xecb(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x5,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0x3,%eax
sete   %dil
call   1030 <assert@plt>
mov    0xee6(%rip),%eax
mov    %eax,0x20(%rsp)
movaps 0xecb(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xeaf(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x9,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1030 <assert@plt>
movaps 0x1099(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0x107d(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x8,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0x11,%eax
sete   %dil
call   1030 <assert@plt>
movups 0xe93(%rip),%xmm0
movups %xmm0,0xc(%rsp)
movaps 0xe7b(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x7,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0x2,%eax
sete   %dil
call   1030 <assert@plt>
mov    0xea5(%rip),%rax
mov    %rax,0x30(%rsp)
movaps 0xe89(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xe6d(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xe51(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0xe,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0x2c,%eax
sete   %dil
call   1030 <assert@plt>
mov    0xedb(%rip),%rax
mov    %rax,0x70(%rsp)
movaps 0xebf(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xea3(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xe87(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xe6b(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xe4f(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xe33(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xe17(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x1e,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0x3e8,%eax
sete   %dil
call   1030 <assert@plt>
mov    0xe80(%rip),%eax
mov    %eax,0x10(%rsp)
movaps 0xe65(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x5,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0xfffffffd,%eax
sete   %dil
call   1030 <assert@plt>
mov    0xe90(%rip),%eax
mov    %eax,0x30(%rsp)
movaps 0xe75(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xe59(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xe3d(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0xd,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0xffffffdd,%eax
sete   %dil
call   1030 <assert@plt>
movups 0xe63(%rip),%xmm0
movups %xmm0,0xc(%rsp)
movaps 0xe4b(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x7,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0xffffffec,%eax
sete   %dil
call   1030 <assert@plt>
mov    0xe75(%rip),%rax
mov    %rax,0x30(%rsp)
movaps 0xe59(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xe3d(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xe21(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0xe,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0xffffffd4,%eax
sete   %dil
call   1030 <assert@plt>
mov    0xe3c(%rip),%eax
mov    %eax,0x8(%rsp)
mov    0xe29(%rip),%rax
mov    %rax,(%rsp)
mov    %rsp,%rdi
mov    $0x3,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
cmp    $0x1,%eax
sete   %dil
call   1030 <assert@plt>
movups 0xe27(%rip),%xmm0
movups %xmm0,0xc(%rsp)
movaps 0xe0f(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %rsp,%rdi
mov    $0x7,%esi
call   1040 <find_outlier@plt>
xor    %edi,%edi
test   %eax,%eax
sete   %dil
call   1030 <assert@plt>
xor    %eax,%eax
add    $0x78,%rsp
ret

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

LLVM IR (-O2):
@__const.main.values = [5 x i32] [i32 2, i32 6, i32 8, i32 10, i32 3]
@__const.main.values.1 = [9 x i32] [i32 2, i32 6, i32 8, i32 200, i32 700, i32 1, i32 84, i32 10, i32 4]
@__const.main.values.2 = [8 x i32] [i32 17, i32 6, i32 8, i32 10, i32 6, i32 12, i32 24, i32 36]
@__const.main.values.3 = [7 x i32] [i32 2, i32 1, i32 7, i32 17, i32 19, i32 211, i32 7]
@__const.main.values.4 = [14 x i32] [i32 1, i32 1, i32 1, i32 1, i32 1, i32 44, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7]
@__const.main.values.5 = [30 x i32] [i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 35, i32 5, i32 5, i32 5, i32 5, i32 5, i32 5, i32 5, i32 5, i32 5, i32 5, i32 7, i32 7, i32 7, i32 7, i32 1000]
@__const.main.values.6 = [5 x i32] [i32 2, i32 -6, i32 8, i32 -10, i32 -3]
@__const.main.values.7 = [13 x i32] [i32 2, i32 6, i32 8, i32 2, i32 -66, i32 34, i32 -35, i32 66, i32 700, i32 1002, i32 -84, i32 10, i32 4]
@__const.main.values.8 = [7 x i32] [i32 -20, i32 1, i32 7, i32 17, i32 19, i32 211, i32 7]
@__const.main.values.9 = [14 x i32] [i32 1, i32 1, i32 -1, i32 1, i32 1, i32 -44, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7]
@__const.main.values.10 = [3 x i32] [i32 1, i32 0, i32 0]
@__const.main.values.11 = [7 x i32] [i32 3, i32 7, i32 -99, i32 81, i32 90211, i32 0, i32 7]
define i32 @main() {
%1 = alloca [5 x i32]
%2 = alloca [9 x i32]
%3 = alloca [8 x i32]
%4 = alloca [7 x i32]
%5 = alloca [14 x i32]
%6 = alloca [30 x i32]
%7 = alloca [5 x i32]
%8 = alloca [13 x i32]
%9 = alloca [7 x i32]
%10 = alloca [14 x i32]
%11 = alloca [3 x i32]
%12 = alloca [7 x i32]
%13 = bitcast [5 x i32]* %1 to i8*
%14 = getelementptr inbounds [5 x i32], [5 x i32]* %1, i64 0, i64 0
%15 = call i32 @find_outlier(i32* %14, i64 5)
%16 = icmp eq i32 %15, 3
%17 = zext i1 %16 to i32
%18 = call i32 @assert(i32 %17)
%19 = bitcast [9 x i32]* %2 to i8*
%20 = getelementptr inbounds [9 x i32], [9 x i32]* %2, i64 0, i64 0
%21 = call i32 @find_outlier(i32* %20, i64 9)
%22 = icmp eq i32 %21, 1
%23 = zext i1 %22 to i32
%24 = call i32 @assert(i32 %23)
%25 = bitcast [8 x i32]* %3 to i8*
%26 = getelementptr inbounds [8 x i32], [8 x i32]* %3, i64 0, i64 0
%27 = call i32 @find_outlier(i32* %26, i64 8)
%28 = icmp eq i32 %27, 17
%29 = zext i1 %28 to i32
%30 = call i32 @assert(i32 %29)
%31 = bitcast [7 x i32]* %4 to i8*
%32 = getelementptr inbounds [7 x i32], [7 x i32]* %4, i64 0, i64 0
%33 = call i32 @find_outlier(i32* %32, i64 7)
%34 = icmp eq i32 %33, 2
%35 = zext i1 %34 to i32
%36 = call i32 @assert(i32 %35)
%37 = bitcast [14 x i32]* %5 to i8*
%38 = getelementptr inbounds [14 x i32], [14 x i32]* %5, i64 0, i64 0
%39 = call i32 @find_outlier(i32* %38, i64 14)
%40 = icmp eq i32 %39, 44
%41 = zext i1 %40 to i32
%42 = call i32 @assert(i32 %41)
%43 = bitcast [30 x i32]* %6 to i8*
%44 = getelementptr inbounds [30 x i32], [30 x i32]* %6, i64 0, i64 0
%45 = call i32 @find_outlier(i32* %44, i64 30)
%46 = icmp eq i32 %45, 1000
%47 = zext i1 %46 to i32
%48 = call i32 @assert(i32 %47)
%49 = bitcast [5 x i32]* %7 to i8*
%50 = getelementptr inbounds [5 x i32], [5 x i32]* %7, i64 0, i64 0
%51 = call i32 @find_outlier(i32* %50, i64 5)
%52 = icmp eq i32 %51, -3
%53 = zext i1 %52 to i32
%54 = call i32 @assert(i32 %53)
%55 = bitcast [13 x i32]* %8 to i8*
%56 = getelementptr inbounds [13 x i32], [13 x i32]* %8, i64 0, i64 0
%57 = call i32 @find_outlier(i32* %56, i64 13)
%58 = icmp eq i32 %57, -35
%59 = zext i1 %58 to i32
%60 = call i32 @assert(i32 %59)
%61 = bitcast [7 x i32]* %9 to i8*
%62 = getelementptr inbounds [7 x i32], [7 x i32]* %9, i64 0, i64 0
%63 = call i32 @find_outlier(i32* %62, i64 7)
%64 = icmp eq i32 %63, -20
%65 = zext i1 %64 to i32
%66 = call i32 @assert(i32 %65)
%67 = bitcast [14 x i32]* %10 to i8*
%68 = getelementptr inbounds [14 x i32], [14 x i32]* %10, i64 0, i64 0
%69 = call i32 @find_outlier(i32* %68, i64 14)
%70 = icmp eq i32 %69, -44
%71 = zext i1 %70 to i32
%72 = call i32 @assert(i32 %71)
%73 = bitcast [3 x i32]* %11 to i8*
%74 = getelementptr inbounds [3 x i32], [3 x i32]* %11, i64 0, i64 0
%75 = call i32 @find_outlier(i32* %74, i64 3)
%76 = icmp eq i32 %75, 1
%77 = zext i1 %76 to i32
%78 = call i32 @assert(i32 %77)
%79 = bitcast [7 x i32]* %12 to i8*
%80 = getelementptr inbounds [7 x i32], [7 x i32]* %12, i64 0, i64 0
%81 = call i32 @find_outlier(i32* %80, i64 7)
%82 = icmp eq i32 %81, 0
%83 = zext i1 %82 to i32
%84 = call i32 @assert(i32 %83)
ret i32 0
}