#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 */
int INT_MAX;
int INT_MIN;
int /*<<< orphan*/ binaryArray(int, int *, int);
int /*<<< orphan*/ binaryPrinter(int *, int);
int /*<<< orphan*/ binaryTester(int *, int *, int);
int /*<<< orphan*/ printf(char *);
int main() {
  int size = sizeof(int) * 8;
  int array[size], i;
  printf("\n\t=========Testing Conversion of 2===========\n\n");
  binaryArray(2, array, size);
  binaryPrinter(array, size);
  int test1[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0};
  binaryTester(array, test1, size);
  printf("\n\t\t....Converting 2 Passed\n");
  printf("\n\t=========Testing Conversion of 255===========\n\n");
  binaryArray(255, array, size);
  binaryPrinter(array, size);
  int test2[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1};
  binaryTester(array, test2, size);
  printf("\n\t\t....Converting 255 Passed\n");
  printf("\n\t=========Testing Conversion of -1===========\n\n");
  binaryArray(-1, array, size);
  binaryPrinter(array, size);
  int test3[32] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
  binaryTester(array, test3, size);
  printf("\n\t\t....Converting -1 Passed\n");
  printf("\n\t=========Testing Conversion of INT_MAX===========\n\n");
  binaryArray(INT_MAX, array, size);
  binaryPrinter(array, size);
  int test4[32] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
  binaryTester(array, test4, size);
  printf("\n\t\t....Converting INT_MAX Passed\n");
  printf("\n\t=========Testing Conversion of INT_MIN===========\n\n");
  binaryArray(INT_MIN, array, size);
  binaryPrinter(array, size);
  int test5[32] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  binaryTester(array, test5, size);
  printf("\n\t\t....Converting INT_MIN Passed\n");
  printf(
      "\n\t=========All Tests Passed. Don't forget to submit!===========\n\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x20,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x10(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x2a8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x18(%rbp)
lea    0xe56(%rip),%rdi
call   1040 <printf@plt>
mov    -0x2a8(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    $0x2,%edi
call   1030 <binaryArray@plt>
mov    -0x2a8(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1080 <binaryPrinter@plt>
lea    -0xa0(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1050 <memset@plt>
mov    -0x2a8(%rbp),%rdi
movl   $0x1,-0x28(%rbp)
lea    -0xa0(%rbp),%rsi
mov    -0x8(%rbp),%edx
call   1060 <binaryTester@plt>
lea    0xe27(%rip),%rdi
call   1040 <printf@plt>
lea    0xe37(%rip),%rdi
call   1040 <printf@plt>
mov    -0x2a8(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    $0xff,%edi
call   1030 <binaryArray@plt>
mov    -0x2a8(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1080 <binaryPrinter@plt>
lea    -0x120(%rbp),%rdi
lea    0xf95(%rip),%rsi
mov    $0x80,%edx
call   1070 <memcpy@plt>
mov    -0x2a8(%rbp),%rdi
lea    -0x120(%rbp),%rsi
mov    -0x8(%rbp),%edx
call   1060 <binaryTester@plt>
lea    0xe0c(%rip),%rdi
call   1040 <printf@plt>
lea    0xe1e(%rip),%rdi
call   1040 <printf@plt>
mov    -0x2a8(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    $0xffffffff,%edi
call   1030 <binaryArray@plt>
mov    -0x2a8(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1080 <binaryPrinter@plt>
lea    -0x1a0(%rbp),%rdi
lea    0xfac(%rip),%rsi
mov    $0x80,%edx
call   1070 <memcpy@plt>
mov    -0x2a8(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
mov    -0x8(%rbp),%edx
call   1060 <binaryTester@plt>
lea    0xdf2(%rip),%rdi
call   1040 <printf@plt>
lea    0xe03(%rip),%rdi
call   1040 <printf@plt>
mov    -0x2a8(%rbp),%rsi
mov    0x2cee(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%edx
call   1030 <binaryArray@plt>
mov    -0x2a8(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1080 <binaryPrinter@plt>
lea    -0x220(%rbp),%rdi
lea    0xfbf(%rip),%rsi
mov    $0x80,%edx
call   1070 <memcpy@plt>
mov    -0x2a8(%rbp),%rdi
lea    -0x220(%rbp),%rsi
mov    -0x8(%rbp),%edx
call   1060 <binaryTester@plt>
lea    0xdd8(%rip),%rdi
call   1040 <printf@plt>
lea    0xdee(%rip),%rdi
call   1040 <printf@plt>
mov    -0x2a8(%rbp),%rsi
mov    0x2c79(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%edx
call   1030 <binaryArray@plt>
mov    -0x2a8(%rbp),%rdi
mov    -0x8(%rbp),%esi
call   1080 <binaryPrinter@plt>
lea    -0x2a0(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1050 <memset@plt>
mov    -0x2a8(%rbp),%rdi
movl   $0x1,-0x2a0(%rbp)
lea    -0x2a0(%rbp),%rsi
mov    -0x8(%rbp),%edx
call   1060 <binaryTester@plt>
lea    0xdbe(%rip),%rdi
call   1040 <printf@plt>
lea    0xdd4(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x300,%rsp
lea    0x1031(%rip),%rdi
call   1030 <puts@plt>
lea    0x280(%rsp),%rbx
mov    $0x2,%edi
mov    %rbx,%rsi
mov    $0x20,%edx
call   1040 <binaryArray@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1060 <binaryPrinter@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movl   $0x1,0xf8(%rsp)
lea    0x80(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x20,%edx
call   1050 <binaryTester@plt>
lea    0xfca(%rip),%rdi
call   1030 <puts@plt>
lea    0xfd9(%rip),%rdi
call   1030 <puts@plt>
mov    $0xff,%edi
mov    %rbx,%rsi
mov    $0x20,%edx
call   1040 <binaryArray@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1060 <binaryPrinter@plt>
movaps 0xe54(%rip),%xmm0
movaps %xmm0,0x270(%rsp)
movaps 0xe35(%rip),%xmm0
movaps %xmm0,0x260(%rsp)
movaps 0xe16(%rip),%xmm0
movaps %xmm0,0x250(%rsp)
movaps 0xdf7(%rip),%xmm0
movaps %xmm0,0x240(%rsp)
movaps 0xdd8(%rip),%xmm0
movaps %xmm0,0x230(%rsp)
movaps 0xdb9(%rip),%xmm0
movaps %xmm0,0x220(%rsp)
movaps 0xd9a(%rip),%xmm0
movaps %xmm0,0x210(%rsp)
movaps 0xd7b(%rip),%xmm0
movaps %xmm0,0x200(%rsp)
lea    0x200(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x20,%edx
call   1050 <binaryTester@plt>
lea    0xf52(%rip),%rdi
call   1030 <puts@plt>
lea    0xf63(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%edi
mov    %rbx,%rsi
mov    $0x20,%edx
call   1040 <binaryArray@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1060 <binaryPrinter@plt>
movaps 0xe10(%rip),%xmm0
movaps %xmm0,0x1f0(%rsp)
movaps 0xdf1(%rip),%xmm0
movaps %xmm0,0x1e0(%rsp)
movaps 0xdd2(%rip),%xmm0
movaps %xmm0,0x1d0(%rsp)
movaps 0xdb3(%rip),%xmm0
movaps %xmm0,0x1c0(%rsp)
movaps 0xd94(%rip),%xmm0
movaps %xmm0,0x1b0(%rsp)
movaps 0xd75(%rip),%xmm0
movaps %xmm0,0x1a0(%rsp)
movaps 0xd56(%rip),%xmm0
movaps %xmm0,0x190(%rsp)
movaps 0xd37(%rip),%xmm0
movaps %xmm0,0x180(%rsp)
lea    0x180(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x20,%edx
call   1050 <binaryTester@plt>
lea    0xedb(%rip),%rdi
call   1030 <puts@plt>
lea    0xeeb(%rip),%rdi
call   1030 <puts@plt>
mov    0x2c63(%rip),%rax
mov    (%rax),%edi
mov    %rbx,%rsi
mov    $0x20,%edx
call   1040 <binaryArray@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1060 <binaryPrinter@plt>
movaps 0xdc8(%rip),%xmm0
movaps %xmm0,0x170(%rsp)
movaps 0xda9(%rip),%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0xd8a(%rip),%xmm0
movaps %xmm0,0x150(%rsp)
movaps 0xd6b(%rip),%xmm0
movaps %xmm0,0x140(%rsp)
movaps 0xd4c(%rip),%xmm0
movaps %xmm0,0x130(%rsp)
movaps 0xd2d(%rip),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0xd0e(%rip),%xmm0
movaps %xmm0,0x110(%rsp)
movaps 0xcef(%rip),%xmm0
movaps %xmm0,0x100(%rsp)
lea    0x100(%rsp),%rsi
mov    %rbx,%rdi
mov    $0x20,%edx
call   1050 <binaryTester@plt>
lea    0xe64(%rip),%rdi
call   1030 <puts@plt>
lea    0xe79(%rip),%rdi
call   1030 <puts@plt>
mov    0x2b93(%rip),%rax
mov    (%rax),%edi
mov    %rbx,%rsi
mov    $0x20,%edx
call   1040 <binaryArray@plt>
mov    %rbx,%rdi
mov    $0x20,%esi
call   1060 <binaryPrinter@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movl   $0x1,(%rsp)
mov    %rsp,%rsi
mov    %rbx,%rdi
mov    $0x20,%edx
call   1050 <binaryTester@plt>
lea    0xe3e(%rip),%rdi
call   1030 <puts@plt>
lea    0xe53(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x300,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [48 x i8] c"\0A\09=========Testing Conversion of 2===========\0A\0A\00"
@.str.1 = [28 x i8] c"\0A\09\09....Converting 2 Passed\0A\00"
@.str.2 = [50 x i8] c"\0A\09=========Testing Conversion of 255===========\0A\0A\00"
@__const.main.test2 = [32 x i32] [i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1]
@.str.3 = [30 x i8] c"\0A\09\09....Converting 255 Passed\0A\00"
@.str.4 = [49 x i8] c"\0A\09=========Testing Conversion of -1===========\0A\0A\00"
@__const.main.test3 = [32 x i32] [i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1]
@.str.5 = [29 x i8] c"\0A\09\09....Converting -1 Passed\0A\00"
@.str.6 = [54 x i8] c"\0A\09=========Testing Conversion of INT_MAX===========\0A\0A\00"
@INT_MAX = global i32 0
@__const.main.test4 = [32 x i32] [i32 0, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1]
@.str.7 = [34 x i8] c"\0A\09\09....Converting INT_MAX Passed\0A\00"
@.str.8 = [54 x i8] c"\0A\09=========Testing Conversion of INT_MIN===========\0A\0A\00"
@INT_MIN = global i32 0
@.str.9 = [34 x i8] c"\0A\09\09....Converting INT_MIN Passed\0A\00"
@.str.10 = [66 x i8] c"\0A\09=========All Tests Passed. Don't forget to submit!===========\0A\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i64
%5 = alloca i32
%6 = alloca [32 x i32]
%7 = alloca [32 x i32]
%8 = alloca [32 x i32]
%9 = alloca [32 x i32]
%10 = alloca [32 x i32]
store i32 0, i32* %1
store i32 32, i32* %2
%11 = load i32, i32* %2
%12 = zext i32 %11 to i64
%13 = call i8* @llvm.stacksave()
store i8* %13, i8** %3
%14 = alloca i32, i64 %12
store i64 %12, i64* %4
%15 = call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str, i64 0, i64 0))
%16 = load i32, i32* %2
%17 = call i32 @binaryArray(i32 2, i32* %14, i32 %16)
%18 = load i32, i32* %2
%19 = call i32 @binaryPrinter(i32* %14, i32 %18)
%20 = bitcast [32 x i32]* %6 to i8*
%21 = bitcast i8* %20 to [32 x i32]*
%22 = getelementptr inbounds [32 x i32], [32 x i32]* %21, i32 0, i32 30
store i32 1, i32* %22
%23 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 0
%24 = load i32, i32* %2
%25 = call i32 @binaryTester(i32* %14, i32* %23, i32 %24)
%26 = call i32 @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0))
%27 = call i32 @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.2, i64 0, i64 0))
%28 = load i32, i32* %2
%29 = call i32 @binaryArray(i32 255, i32* %14, i32 %28)
%30 = load i32, i32* %2
%31 = call i32 @binaryPrinter(i32* %14, i32 %30)
%32 = bitcast [32 x i32]* %7 to i8*
%33 = getelementptr inbounds [32 x i32], [32 x i32]* %7, i64 0, i64 0
%34 = load i32, i32* %2
%35 = call i32 @binaryTester(i32* %14, i32* %33, i32 %34)
%36 = call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0))
%37 = call i32 @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.4, i64 0, i64 0))
%38 = load i32, i32* %2
%39 = call i32 @binaryArray(i32 -1, i32* %14, i32 %38)
%40 = load i32, i32* %2
%41 = call i32 @binaryPrinter(i32* %14, i32 %40)
%42 = bitcast [32 x i32]* %8 to i8*
%43 = getelementptr inbounds [32 x i32], [32 x i32]* %8, i64 0, i64 0
%44 = load i32, i32* %2
%45 = call i32 @binaryTester(i32* %14, i32* %43, i32 %44)
%46 = call i32 @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0))
%47 = call i32 @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.6, i64 0, i64 0))
%48 = load i32, i32* @INT_MAX
%49 = load i32, i32* %2
%50 = call i32 @binaryArray(i32 %48, i32* %14, i32 %49)
%51 = load i32, i32* %2
%52 = call i32 @binaryPrinter(i32* %14, i32 %51)
%53 = bitcast [32 x i32]* %9 to i8*
%54 = getelementptr inbounds [32 x i32], [32 x i32]* %9, i64 0, i64 0
%55 = load i32, i32* %2
%56 = call i32 @binaryTester(i32* %14, i32* %54, i32 %55)
%57 = call i32 @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.7, i64 0, i64 0))
%58 = call i32 @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.8, i64 0, i64 0))
%59 = load i32, i32* @INT_MIN
%60 = load i32, i32* %2
%61 = call i32 @binaryArray(i32 %59, i32* %14, i32 %60)
%62 = load i32, i32* %2
%63 = call i32 @binaryPrinter(i32* %14, i32 %62)
%64 = bitcast [32 x i32]* %10 to i8*
%65 = bitcast i8* %64 to <{ i32, [31 x i32] }>*
%66 = getelementptr inbounds <{ i32, [31 x i32] }>, <{ i32, [31 x i32] }>* %65, i32 0, i32 0
store i32 1, i32* %66
%67 = getelementptr inbounds [32 x i32], [32 x i32]* %10, i64 0, i64 0
%68 = load i32, i32* %2
%69 = call i32 @binaryTester(i32* %14, i32* %67, i32 %68)
%70 = call i32 @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.9, i64 0, i64 0))
%71 = call i32 @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.10, i64 0, i64 0))
store i32 0, i32* %1
%72 = load i8*, i8** %3
%73 = load i32, i32* %1
ret i32 %73
}

LLVM IR (-O2):
@__const.main.test2 = [32 x i32] [i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1]
@__const.main.test3 = [32 x i32] [i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1]
@INT_MAX = global i32 0
@__const.main.test4 = [32 x i32] [i32 0, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1]
@INT_MIN = global i32 0
@str = [47 x i8] c"\0A\09=========Testing Conversion of 2===========\0A\00"
@str.11 = [27 x i8] c"\0A\09\09....Converting 2 Passed\00"
@str.12 = [49 x i8] c"\0A\09=========Testing Conversion of 255===========\0A\00"
@str.13 = [29 x i8] c"\0A\09\09....Converting 255 Passed\00"
@str.14 = [48 x i8] c"\0A\09=========Testing Conversion of -1===========\0A\00"
@str.15 = [28 x i8] c"\0A\09\09....Converting -1 Passed\00"
@str.16 = [53 x i8] c"\0A\09=========Testing Conversion of INT_MAX===========\0A\00"
@str.17 = [33 x i8] c"\0A\09\09....Converting INT_MAX Passed\00"
@str.18 = [53 x i8] c"\0A\09=========Testing Conversion of INT_MIN===========\0A\00"
@str.19 = [33 x i8] c"\0A\09\09....Converting INT_MIN Passed\00"
@str.20 = [65 x i8] c"\0A\09=========All Tests Passed. Don't forget to submit!===========\0A\00"
define i32 @main() {
%1 = alloca [32 x i32]
%2 = alloca [32 x i32]
%3 = alloca [32 x i32]
%4 = alloca [32 x i32]
%5 = alloca [32 x i32]
%6 = alloca [32 x i32]
%7 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 0
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str, i64 0, i64 0))
%9 = call i32 @binaryArray(i32 2, i32* %7, i32 32)
%10 = call i32 @binaryPrinter(i32* %7, i32 32)
%11 = bitcast [32 x i32]* %1 to i8*
%12 = getelementptr inbounds [32 x i32], [32 x i32]* %1, i64 0, i64 30
store i32 1, i32* %12
%13 = getelementptr inbounds [32 x i32], [32 x i32]* %1, i64 0, i64 0
%14 = call i32 @binaryTester(i32* %7, i32* %13, i32 32)
%15 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.11, i64 0, i64 0))
%16 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @str.12, i64 0, i64 0))
%17 = call i32 @binaryArray(i32 255, i32* %7, i32 32)
%18 = call i32 @binaryPrinter(i32* %7, i32 32)
%19 = bitcast [32 x i32]* %2 to i8*
%20 = getelementptr inbounds [32 x i32], [32 x i32]* %2, i64 0, i64 0
%21 = call i32 @binaryTester(i32* %7, i32* %20, i32 32)
%22 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.13, i64 0, i64 0))
%23 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.14, i64 0, i64 0))
%24 = call i32 @binaryArray(i32 -1, i32* %7, i32 32)
%25 = call i32 @binaryPrinter(i32* %7, i32 32)
%26 = bitcast [32 x i32]* %3 to i8*
%27 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 0
%28 = call i32 @binaryTester(i32* %7, i32* %27, i32 32)
%29 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.15, i64 0, i64 0))
%30 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @str.16, i64 0, i64 0))
%31 = load i32, i32* @INT_MAX
%32 = call i32 @binaryArray(i32 %31, i32* %7, i32 32)
%33 = call i32 @binaryPrinter(i32* %7, i32 32)
%34 = bitcast [32 x i32]* %4 to i8*
%35 = getelementptr inbounds [32 x i32], [32 x i32]* %4, i64 0, i64 0
%36 = call i32 @binaryTester(i32* %7, i32* %35, i32 32)
%37 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.17, i64 0, i64 0))
%38 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @str.18, i64 0, i64 0))
%39 = load i32, i32* @INT_MIN
%40 = call i32 @binaryArray(i32 %39, i32* %7, i32 32)
%41 = call i32 @binaryPrinter(i32* %7, i32 32)
%42 = bitcast [32 x i32]* %5 to i8*
%43 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
store i32 1, i32* %43
%44 = call i32 @binaryTester(i32* %7, i32* %43, i32 32)
%45 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.19, i64 0, i64 0))
%46 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str.20, i64 0, i64 0))
ret i32 0
}