/usr/bin/lli

###### Testing test-array-float-arr-add
../pienum.native -c compiler_tests/test-array-float-arr-add.pn > test-array-float-arr-add.ll
llc test-array-float-arr-add.ll
gcc -o test-array-float-arr-add test-array-float-arr-add.s ../image_ops.c
./test-array-float-arr-add
diff -b test-array-float-arr-add.out compiler_tests/test-array-float-arr-add.out > test-array-float-arr-add.diff
###### SUCCESS

###### Testing test-array-float-arr-div
../pienum.native -c compiler_tests/test-array-float-arr-div.pn > test-array-float-arr-div.ll
llc test-array-float-arr-div.ll
gcc -o test-array-float-arr-div test-array-float-arr-div.s ../image_ops.c
./test-array-float-arr-div
diff -b test-array-float-arr-div.out compiler_tests/test-array-float-arr-div.out > test-array-float-arr-div.diff
###### SUCCESS

###### Testing test-array-float-arr-mul
../pienum.native -c compiler_tests/test-array-float-arr-mul.pn > test-array-float-arr-mul.ll
llc test-array-float-arr-mul.ll
gcc -o test-array-float-arr-mul test-array-float-arr-mul.s ../image_ops.c
./test-array-float-arr-mul
diff -b test-array-float-arr-mul.out compiler_tests/test-array-float-arr-mul.out > test-array-float-arr-mul.diff
###### SUCCESS

###### Testing test-array-float-arr-sub
../pienum.native -c compiler_tests/test-array-float-arr-sub.pn > test-array-float-arr-sub.ll
llc test-array-float-arr-sub.ll
gcc -o test-array-float-arr-sub test-array-float-arr-sub.s ../image_ops.c
./test-array-float-arr-sub
diff -b test-array-float-arr-sub.out compiler_tests/test-array-float-arr-sub.out > test-array-float-arr-sub.diff
###### SUCCESS

###### Testing test-array-float-scalar-add
../pienum.native -c compiler_tests/test-array-float-scalar-add.pn > test-array-float-scalar-add.ll
llc test-array-float-scalar-add.ll
gcc -o test-array-float-scalar-add test-array-float-scalar-add.s ../image_ops.c
./test-array-float-scalar-add
diff -b test-array-float-scalar-add.out compiler_tests/test-array-float-scalar-add.out > test-array-float-scalar-add.diff
###### SUCCESS

###### Testing test-array-float-scalar-div
../pienum.native -c compiler_tests/test-array-float-scalar-div.pn > test-array-float-scalar-div.ll
llc test-array-float-scalar-div.ll
gcc -o test-array-float-scalar-div test-array-float-scalar-div.s ../image_ops.c
./test-array-float-scalar-div
diff -b test-array-float-scalar-div.out compiler_tests/test-array-float-scalar-div.out > test-array-float-scalar-div.diff
###### SUCCESS

###### Testing test-array-float-scalar-mul
../pienum.native -c compiler_tests/test-array-float-scalar-mul.pn > test-array-float-scalar-mul.ll
llc test-array-float-scalar-mul.ll
gcc -o test-array-float-scalar-mul test-array-float-scalar-mul.s ../image_ops.c
./test-array-float-scalar-mul
diff -b test-array-float-scalar-mul.out compiler_tests/test-array-float-scalar-mul.out > test-array-float-scalar-mul.diff
###### SUCCESS

###### Testing test-array-float-scalar-sub
../pienum.native -c compiler_tests/test-array-float-scalar-sub.pn > test-array-float-scalar-sub.ll
llc test-array-float-scalar-sub.ll
gcc -o test-array-float-scalar-sub test-array-float-scalar-sub.s ../image_ops.c
./test-array-float-scalar-sub
diff -b test-array-float-scalar-sub.out compiler_tests/test-array-float-scalar-sub.out > test-array-float-scalar-sub.diff
###### SUCCESS

###### Testing test-array-int-access
../pienum.native -c compiler_tests/test-array-int-access.pn > test-array-int-access.ll
llc test-array-int-access.ll
gcc -o test-array-int-access test-array-int-access.s ../image_ops.c
./test-array-int-access
diff -b test-array-int-access.out compiler_tests/test-array-int-access.out > test-array-int-access.diff
###### SUCCESS

###### Testing test-array-int-arr-add
../pienum.native -c compiler_tests/test-array-int-arr-add.pn > test-array-int-arr-add.ll
llc test-array-int-arr-add.ll
gcc -o test-array-int-arr-add test-array-int-arr-add.s ../image_ops.c
./test-array-int-arr-add
diff -b test-array-int-arr-add.out compiler_tests/test-array-int-arr-add.out > test-array-int-arr-add.diff
###### SUCCESS

###### Testing test-array-int-arr-mul
../pienum.native -c compiler_tests/test-array-int-arr-mul.pn > test-array-int-arr-mul.ll
llc test-array-int-arr-mul.ll
gcc -o test-array-int-arr-mul test-array-int-arr-mul.s ../image_ops.c
./test-array-int-arr-mul
diff -b test-array-int-arr-mul.out compiler_tests/test-array-int-arr-mul.out > test-array-int-arr-mul.diff
###### SUCCESS

###### Testing test-array-int-arr-sub
../pienum.native -c compiler_tests/test-array-int-arr-sub.pn > test-array-int-arr-sub.ll
llc test-array-int-arr-sub.ll
gcc -o test-array-int-arr-sub test-array-int-arr-sub.s ../image_ops.c
./test-array-int-arr-sub
diff -b test-array-int-arr-sub.out compiler_tests/test-array-int-arr-sub.out > test-array-int-arr-sub.diff
###### SUCCESS

###### Testing test-array-int-scalar-add
../pienum.native -c compiler_tests/test-array-int-scalar-add.pn > test-array-int-scalar-add.ll
llc test-array-int-scalar-add.ll
gcc -o test-array-int-scalar-add test-array-int-scalar-add.s ../image_ops.c
./test-array-int-scalar-add
diff -b test-array-int-scalar-add.out compiler_tests/test-array-int-scalar-add.out > test-array-int-scalar-add.diff
###### SUCCESS

###### Testing test-array-int-scalar-div
../pienum.native -c compiler_tests/test-array-int-scalar-div.pn > test-array-int-scalar-div.ll
llc test-array-int-scalar-div.ll
gcc -o test-array-int-scalar-div test-array-int-scalar-div.s ../image_ops.c
./test-array-int-scalar-div
diff -b test-array-int-scalar-div.out compiler_tests/test-array-int-scalar-div.out > test-array-int-scalar-div.diff
###### SUCCESS

###### Testing test-array-int-scalar-mul
../pienum.native -c compiler_tests/test-array-int-scalar-mul.pn > test-array-int-scalar-mul.ll
llc test-array-int-scalar-mul.ll
gcc -o test-array-int-scalar-mul test-array-int-scalar-mul.s ../image_ops.c
./test-array-int-scalar-mul
diff -b test-array-int-scalar-mul.out compiler_tests/test-array-int-scalar-mul.out > test-array-int-scalar-mul.diff
###### SUCCESS

###### Testing test-array-int-scalar-sub
../pienum.native -c compiler_tests/test-array-int-scalar-sub.pn > test-array-int-scalar-sub.ll
llc test-array-int-scalar-sub.ll
gcc -o test-array-int-scalar-sub test-array-int-scalar-sub.s ../image_ops.c
./test-array-int-scalar-sub
diff -b test-array-int-scalar-sub.out compiler_tests/test-array-int-scalar-sub.out > test-array-int-scalar-sub.diff
###### SUCCESS

###### Testing test-forloop-double1
../pienum.native -c compiler_tests/test-forloop-double1.pn > test-forloop-double1.ll
llc test-forloop-double1.ll
gcc -o test-forloop-double1 test-forloop-double1.s ../image_ops.c
./test-forloop-double1
diff -b test-forloop-double1.out compiler_tests/test-forloop-double1.out > test-forloop-double1.diff
###### SUCCESS

###### Testing test-forloop-double2
../pienum.native -c compiler_tests/test-forloop-double2.pn > test-forloop-double2.ll
llc test-forloop-double2.ll
gcc -o test-forloop-double2 test-forloop-double2.s ../image_ops.c
./test-forloop-double2
diff -b test-forloop-double2.out compiler_tests/test-forloop-double2.out > test-forloop-double2.diff
###### SUCCESS

###### Testing test-forloop1
../pienum.native -c compiler_tests/test-forloop1.pn > test-forloop1.ll
llc test-forloop1.ll
gcc -o test-forloop1 test-forloop1.s ../image_ops.c
./test-forloop1
diff -b test-forloop1.out compiler_tests/test-forloop1.out > test-forloop1.diff
###### SUCCESS

###### Testing test-forloop2
../pienum.native -c compiler_tests/test-forloop2.pn > test-forloop2.ll
llc test-forloop2.ll
gcc -o test-forloop2 test-forloop2.s ../image_ops.c
./test-forloop2
diff -b test-forloop2.out compiler_tests/test-forloop2.out > test-forloop2.diff
###### SUCCESS

###### Testing test-function1
../pienum.native -c compiler_tests/test-function1.pn > test-function1.ll
llc test-function1.ll
gcc -o test-function1 test-function1.s ../image_ops.c
./test-function1
diff -b test-function1.out compiler_tests/test-function1.out > test-function1.diff
###### SUCCESS

###### Testing test-function2
../pienum.native -c compiler_tests/test-function2.pn > test-function2.ll
llc test-function2.ll
gcc -o test-function2 test-function2.s ../image_ops.c
./test-function2
diff -b test-function2.out compiler_tests/test-function2.out > test-function2.diff
###### SUCCESS

###### Testing test-function3
../pienum.native -c compiler_tests/test-function3.pn > test-function3.ll
llc test-function3.ll
gcc -o test-function3 test-function3.s ../image_ops.c
./test-function3
diff -b test-function3.out compiler_tests/test-function3.out > test-function3.diff
###### SUCCESS

###### Testing test-function4
../pienum.native -c compiler_tests/test-function4.pn > test-function4.ll
llc test-function4.ll
gcc -o test-function4 test-function4.s ../image_ops.c
./test-function4
diff -b test-function4.out compiler_tests/test-function4.out > test-function4.diff
###### SUCCESS

###### Testing test-global1
../pienum.native -c compiler_tests/test-global1.pn > test-global1.ll
llc test-global1.ll
gcc -o test-global1 test-global1.s ../image_ops.c
./test-global1
diff -b test-global1.out compiler_tests/test-global1.out > test-global1.diff
###### SUCCESS

###### Testing test-global2
../pienum.native -c compiler_tests/test-global2.pn > test-global2.ll
llc test-global2.ll
gcc -o test-global2 test-global2.s ../image_ops.c
./test-global2
diff -b test-global2.out compiler_tests/test-global2.out > test-global2.diff
###### SUCCESS

###### Testing test-global3
../pienum.native -c compiler_tests/test-global3.pn > test-global3.ll
llc test-global3.ll
gcc -o test-global3 test-global3.s ../image_ops.c
./test-global3
diff -b test-global3.out compiler_tests/test-global3.out > test-global3.diff
###### SUCCESS

###### Testing test-global4
../pienum.native -c compiler_tests/test-global4.pn > test-global4.ll
llc test-global4.ll
gcc -o test-global4 test-global4.s ../image_ops.c
./test-global4
diff -b test-global4.out compiler_tests/test-global4.out > test-global4.diff
###### SUCCESS

###### Testing test-global5
../pienum.native -c compiler_tests/test-global5.pn > test-global5.ll
llc test-global5.ll
gcc -o test-global5 test-global5.s ../image_ops.c
./test-global5
diff -b test-global5.out compiler_tests/test-global5.out > test-global5.diff
###### SUCCESS

###### Testing test-if1
../pienum.native -c compiler_tests/test-if1.pn > test-if1.ll
llc test-if1.ll
gcc -o test-if1 test-if1.s ../image_ops.c
./test-if1
diff -b test-if1.out compiler_tests/test-if1.out > test-if1.diff
###### SUCCESS

###### Testing test-if2
../pienum.native -c compiler_tests/test-if2.pn > test-if2.ll
llc test-if2.ll
gcc -o test-if2 test-if2.s ../image_ops.c
./test-if2
diff -b test-if2.out compiler_tests/test-if2.out > test-if2.diff
###### SUCCESS

###### Testing test-if3
../pienum.native -c compiler_tests/test-if3.pn > test-if3.ll
llc test-if3.ll
gcc -o test-if3 test-if3.s ../image_ops.c
./test-if3
diff -b test-if3.out compiler_tests/test-if3.out > test-if3.diff
###### SUCCESS

###### Testing test-ifelse1
../pienum.native -c compiler_tests/test-ifelse1.pn > test-ifelse1.ll
llc test-ifelse1.ll
gcc -o test-ifelse1 test-ifelse1.s ../image_ops.c
./test-ifelse1
diff -b test-ifelse1.out compiler_tests/test-ifelse1.out > test-ifelse1.diff
###### SUCCESS

###### Testing test-ifelse2
../pienum.native -c compiler_tests/test-ifelse2.pn > test-ifelse2.ll
llc test-ifelse2.ll
gcc -o test-ifelse2 test-ifelse2.s ../image_ops.c
./test-ifelse2
diff -b test-ifelse2.out compiler_tests/test-ifelse2.out > test-ifelse2.diff
###### SUCCESS

###### Testing test-matrix-float-dot-add
../pienum.native -c compiler_tests/test-matrix-float-dot-add.pn > test-matrix-float-dot-add.ll
llc test-matrix-float-dot-add.ll
gcc -o test-matrix-float-dot-add test-matrix-float-dot-add.s ../image_ops.c
./test-matrix-float-dot-add
diff -b test-matrix-float-dot-add.out compiler_tests/test-matrix-float-dot-add.out > test-matrix-float-dot-add.diff
###### SUCCESS

###### Testing test-matrix-float-dot-div
../pienum.native -c compiler_tests/test-matrix-float-dot-div.pn > test-matrix-float-dot-div.ll
llc test-matrix-float-dot-div.ll
gcc -o test-matrix-float-dot-div test-matrix-float-dot-div.s ../image_ops.c
./test-matrix-float-dot-div
diff -b test-matrix-float-dot-div.out compiler_tests/test-matrix-float-dot-div.out > test-matrix-float-dot-div.diff
###### SUCCESS

###### Testing test-matrix-float-dot-mul
../pienum.native -c compiler_tests/test-matrix-float-dot-mul.pn > test-matrix-float-dot-mul.ll
llc test-matrix-float-dot-mul.ll
gcc -o test-matrix-float-dot-mul test-matrix-float-dot-mul.s ../image_ops.c
./test-matrix-float-dot-mul
diff -b test-matrix-float-dot-mul.out compiler_tests/test-matrix-float-dot-mul.out > test-matrix-float-dot-mul.diff
###### SUCCESS

###### Testing test-matrix-float-dot-sub
../pienum.native -c compiler_tests/test-matrix-float-dot-sub.pn > test-matrix-float-dot-sub.ll
llc test-matrix-float-dot-sub.ll
gcc -o test-matrix-float-dot-sub test-matrix-float-dot-sub.s ../image_ops.c
./test-matrix-float-dot-sub
diff -b test-matrix-float-dot-sub.out compiler_tests/test-matrix-float-dot-sub.out > test-matrix-float-dot-sub.diff
###### SUCCESS

###### Testing test-matrix-float-scalar-add
../pienum.native -c compiler_tests/test-matrix-float-scalar-add.pn > test-matrix-float-scalar-add.ll
llc test-matrix-float-scalar-add.ll
gcc -o test-matrix-float-scalar-add test-matrix-float-scalar-add.s ../image_ops.c
./test-matrix-float-scalar-add
diff -b test-matrix-float-scalar-add.out compiler_tests/test-matrix-float-scalar-add.out > test-matrix-float-scalar-add.diff
###### SUCCESS

###### Testing test-matrix-float-scalar-div
../pienum.native -c compiler_tests/test-matrix-float-scalar-div.pn > test-matrix-float-scalar-div.ll
llc test-matrix-float-scalar-div.ll
gcc -o test-matrix-float-scalar-div test-matrix-float-scalar-div.s ../image_ops.c
./test-matrix-float-scalar-div
diff -b test-matrix-float-scalar-div.out compiler_tests/test-matrix-float-scalar-div.out > test-matrix-float-scalar-div.diff
###### SUCCESS

###### Testing test-matrix-float-scalar-mul
../pienum.native -c compiler_tests/test-matrix-float-scalar-mul.pn > test-matrix-float-scalar-mul.ll
llc test-matrix-float-scalar-mul.ll
gcc -o test-matrix-float-scalar-mul test-matrix-float-scalar-mul.s ../image_ops.c
./test-matrix-float-scalar-mul
diff -b test-matrix-float-scalar-mul.out compiler_tests/test-matrix-float-scalar-mul.out > test-matrix-float-scalar-mul.diff
###### SUCCESS

###### Testing test-matrix-float-scalar-sub
../pienum.native -c compiler_tests/test-matrix-float-scalar-sub.pn > test-matrix-float-scalar-sub.ll
llc test-matrix-float-scalar-sub.ll
gcc -o test-matrix-float-scalar-sub test-matrix-float-scalar-sub.s ../image_ops.c
./test-matrix-float-scalar-sub
diff -b test-matrix-float-scalar-sub.out compiler_tests/test-matrix-float-scalar-sub.out > test-matrix-float-scalar-sub.diff
###### SUCCESS

###### Testing test-matrix-int-declare
../pienum.native -c compiler_tests/test-matrix-int-declare.pn > test-matrix-int-declare.ll
llc test-matrix-int-declare.ll
gcc -o test-matrix-int-declare test-matrix-int-declare.s ../image_ops.c
./test-matrix-int-declare
diff -b test-matrix-int-declare.out compiler_tests/test-matrix-int-declare.out > test-matrix-int-declare.diff
###### SUCCESS

###### Testing test-matrix-int-dot-add
../pienum.native -c compiler_tests/test-matrix-int-dot-add.pn > test-matrix-int-dot-add.ll
llc test-matrix-int-dot-add.ll
gcc -o test-matrix-int-dot-add test-matrix-int-dot-add.s ../image_ops.c
./test-matrix-int-dot-add
diff -b test-matrix-int-dot-add.out compiler_tests/test-matrix-int-dot-add.out > test-matrix-int-dot-add.diff
###### SUCCESS

###### Testing test-matrix-int-dot-div
../pienum.native -c compiler_tests/test-matrix-int-dot-div.pn > test-matrix-int-dot-div.ll
llc test-matrix-int-dot-div.ll
gcc -o test-matrix-int-dot-div test-matrix-int-dot-div.s ../image_ops.c
./test-matrix-int-dot-div
diff -b test-matrix-int-dot-div.out compiler_tests/test-matrix-int-dot-div.out > test-matrix-int-dot-div.diff
###### SUCCESS

###### Testing test-matrix-int-dot-mul
../pienum.native -c compiler_tests/test-matrix-int-dot-mul.pn > test-matrix-int-dot-mul.ll
llc test-matrix-int-dot-mul.ll
gcc -o test-matrix-int-dot-mul test-matrix-int-dot-mul.s ../image_ops.c
./test-matrix-int-dot-mul
diff -b test-matrix-int-dot-mul.out compiler_tests/test-matrix-int-dot-mul.out > test-matrix-int-dot-mul.diff
###### SUCCESS

###### Testing test-matrix-int-dot-sub
../pienum.native -c compiler_tests/test-matrix-int-dot-sub.pn > test-matrix-int-dot-sub.ll
llc test-matrix-int-dot-sub.ll
gcc -o test-matrix-int-dot-sub test-matrix-int-dot-sub.s ../image_ops.c
./test-matrix-int-dot-sub
diff -b test-matrix-int-dot-sub.out compiler_tests/test-matrix-int-dot-sub.out > test-matrix-int-dot-sub.diff
###### SUCCESS

###### Testing test-matrix-int-scalar-add
../pienum.native -c compiler_tests/test-matrix-int-scalar-add.pn > test-matrix-int-scalar-add.ll
llc test-matrix-int-scalar-add.ll
gcc -o test-matrix-int-scalar-add test-matrix-int-scalar-add.s ../image_ops.c
./test-matrix-int-scalar-add
diff -b test-matrix-int-scalar-add.out compiler_tests/test-matrix-int-scalar-add.out > test-matrix-int-scalar-add.diff
###### SUCCESS

###### Testing test-matrix-int-scalar-div
../pienum.native -c compiler_tests/test-matrix-int-scalar-div.pn > test-matrix-int-scalar-div.ll
llc test-matrix-int-scalar-div.ll
gcc -o test-matrix-int-scalar-div test-matrix-int-scalar-div.s ../image_ops.c
./test-matrix-int-scalar-div
diff -b test-matrix-int-scalar-div.out compiler_tests/test-matrix-int-scalar-div.out > test-matrix-int-scalar-div.diff
###### SUCCESS

###### Testing test-matrix-int-scalar-mul
../pienum.native -c compiler_tests/test-matrix-int-scalar-mul.pn > test-matrix-int-scalar-mul.ll
llc test-matrix-int-scalar-mul.ll
gcc -o test-matrix-int-scalar-mul test-matrix-int-scalar-mul.s ../image_ops.c
./test-matrix-int-scalar-mul
diff -b test-matrix-int-scalar-mul.out compiler_tests/test-matrix-int-scalar-mul.out > test-matrix-int-scalar-mul.diff
###### SUCCESS

###### Testing test-matrix-int-scalar-sub
../pienum.native -c compiler_tests/test-matrix-int-scalar-sub.pn > test-matrix-int-scalar-sub.ll
llc test-matrix-int-scalar-sub.ll
gcc -o test-matrix-int-scalar-sub test-matrix-int-scalar-sub.s ../image_ops.c
./test-matrix-int-scalar-sub
diff -b test-matrix-int-scalar-sub.out compiler_tests/test-matrix-int-scalar-sub.out > test-matrix-int-scalar-sub.diff
###### SUCCESS

###### Testing test-operation-float
../pienum.native -c compiler_tests/test-operation-float.pn > test-operation-float.ll
llc test-operation-float.ll
gcc -o test-operation-float test-operation-float.s ../image_ops.c
./test-operation-float
diff -b test-operation-float.out compiler_tests/test-operation-float.out > test-operation-float.diff
###### SUCCESS

###### Testing test-operation-int
../pienum.native -c compiler_tests/test-operation-int.pn > test-operation-int.ll
llc test-operation-int.ll
gcc -o test-operation-int test-operation-int.s ../image_ops.c
./test-operation-int
diff -b test-operation-int.out compiler_tests/test-operation-int.out > test-operation-int.diff
###### SUCCESS

###### Testing test-print-declared-float
../pienum.native -c compiler_tests/test-print-declared-float.pn > test-print-declared-float.ll
llc test-print-declared-float.ll
gcc -o test-print-declared-float test-print-declared-float.s ../image_ops.c
./test-print-declared-float
diff -b test-print-declared-float.out compiler_tests/test-print-declared-float.out > test-print-declared-float.diff
###### SUCCESS

###### Testing test-print-declared-int
../pienum.native -c compiler_tests/test-print-declared-int.pn > test-print-declared-int.ll
llc test-print-declared-int.ll
gcc -o test-print-declared-int test-print-declared-int.s ../image_ops.c
./test-print-declared-int
diff -b test-print-declared-int.out compiler_tests/test-print-declared-int.out > test-print-declared-int.diff
###### SUCCESS

###### Testing test-print-declared-string
../pienum.native -c compiler_tests/test-print-declared-string.pn > test-print-declared-string.ll
llc test-print-declared-string.ll
gcc -o test-print-declared-string test-print-declared-string.s ../image_ops.c
./test-print-declared-string
diff -b test-print-declared-string.out compiler_tests/test-print-declared-string.out > test-print-declared-string.diff
###### SUCCESS

###### Testing test-print-float
../pienum.native -c compiler_tests/test-print-float.pn > test-print-float.ll
llc test-print-float.ll
gcc -o test-print-float test-print-float.s ../image_ops.c
./test-print-float
diff -b test-print-float.out compiler_tests/test-print-float.out > test-print-float.diff
###### SUCCESS

###### Testing test-print-int
../pienum.native -c compiler_tests/test-print-int.pn > test-print-int.ll
llc test-print-int.ll
gcc -o test-print-int test-print-int.s ../image_ops.c
./test-print-int
diff -b test-print-int.out compiler_tests/test-print-int.out > test-print-int.diff
###### SUCCESS

###### Testing test-print-string
../pienum.native -c compiler_tests/test-print-string.pn > test-print-string.ll
llc test-print-string.ll
gcc -o test-print-string test-print-string.s ../image_ops.c
./test-print-string
diff -b test-print-string.out compiler_tests/test-print-string.out > test-print-string.diff
###### SUCCESS

###### Testing test-whileloop-double
../pienum.native -c compiler_tests/test-whileloop-double.pn > test-whileloop-double.ll
llc test-whileloop-double.ll
gcc -o test-whileloop-double test-whileloop-double.s ../image_ops.c
./test-whileloop-double
diff -b test-whileloop-double.out compiler_tests/test-whileloop-double.out > test-whileloop-double.diff
###### SUCCESS

###### Testing test-whileloop
../pienum.native -c compiler_tests/test-whileloop.pn > test-whileloop.ll
llc test-whileloop.ll
gcc -o test-whileloop test-whileloop.s ../image_ops.c
./test-whileloop
diff -b test-whileloop.out compiler_tests/test-whileloop.out > test-whileloop.diff
###### SUCCESS

###### Testing fail-array-dot-add
../pienum.native -c compiler_tests/fail-array-dot-add.pn 2> fail-array-dot-add.err >> testall.log
diff -b fail-array-dot-add.err compiler_tests/fail-array-dot-add.err > fail-array-dot-add.diff
###### SUCCESS

###### Testing fail-array-dot-div
../pienum.native -c compiler_tests/fail-array-dot-div.pn 2> fail-array-dot-div.err >> testall.log
diff -b fail-array-dot-div.err compiler_tests/fail-array-dot-div.err > fail-array-dot-div.diff
###### SUCCESS

###### Testing fail-array-dot-mul
../pienum.native -c compiler_tests/fail-array-dot-mul.pn 2> fail-array-dot-mul.err >> testall.log
diff -b fail-array-dot-mul.err compiler_tests/fail-array-dot-mul.err > fail-array-dot-mul.diff
###### SUCCESS

###### Testing fail-array-dot-sub
../pienum.native -c compiler_tests/fail-array-dot-sub.pn 2> fail-array-dot-sub.err >> testall.log
diff -b fail-array-dot-sub.err compiler_tests/fail-array-dot-sub.err > fail-array-dot-sub.diff
###### SUCCESS

###### Testing fail-array-scalar-add
../pienum.native -c compiler_tests/fail-array-scalar-add.pn 2> fail-array-scalar-add.err >> testall.log
diff -b fail-array-scalar-add.err compiler_tests/fail-array-scalar-add.err > fail-array-scalar-add.diff
###### SUCCESS

###### Testing fail-array-scalar-add1
../pienum.native -c compiler_tests/fail-array-scalar-add1.pn 2> fail-array-scalar-add1.err >> testall.log
diff -b fail-array-scalar-add1.err compiler_tests/fail-array-scalar-add1.err > fail-array-scalar-add1.diff
###### SUCCESS

###### Testing fail-array-scalar-div
../pienum.native -c compiler_tests/fail-array-scalar-div.pn 2> fail-array-scalar-div.err >> testall.log
diff -b fail-array-scalar-div.err compiler_tests/fail-array-scalar-div.err > fail-array-scalar-div.diff
###### SUCCESS

###### Testing fail-array-scalar-div1
../pienum.native -c compiler_tests/fail-array-scalar-div1.pn 2> fail-array-scalar-div1.err >> testall.log
diff -b fail-array-scalar-div1.err compiler_tests/fail-array-scalar-div1.err > fail-array-scalar-div1.diff
###### SUCCESS

###### Testing fail-array-scalar-mul
../pienum.native -c compiler_tests/fail-array-scalar-mul.pn 2> fail-array-scalar-mul.err >> testall.log
diff -b fail-array-scalar-mul.err compiler_tests/fail-array-scalar-mul.err > fail-array-scalar-mul.diff
###### SUCCESS

###### Testing fail-array-scalar-mul1
../pienum.native -c compiler_tests/fail-array-scalar-mul1.pn 2> fail-array-scalar-mul1.err >> testall.log
diff -b fail-array-scalar-mul1.err compiler_tests/fail-array-scalar-mul1.err > fail-array-scalar-mul1.diff
###### SUCCESS

###### Testing fail-array-scalar-sub
../pienum.native -c compiler_tests/fail-array-scalar-sub.pn 2> fail-array-scalar-sub.err >> testall.log
diff -b fail-array-scalar-sub.err compiler_tests/fail-array-scalar-sub.err > fail-array-scalar-sub.diff
###### SUCCESS

###### Testing fail-array-scalar-sub1
../pienum.native -c compiler_tests/fail-array-scalar-sub1.pn 2> fail-array-scalar-sub1.err >> testall.log
diff -b fail-array-scalar-sub1.err compiler_tests/fail-array-scalar-sub1.err > fail-array-scalar-sub1.diff
###### SUCCESS

###### Testing fail-assign1
../pienum.native -c compiler_tests/fail-assign1.pn 2> fail-assign1.err >> testall.log
diff -b fail-assign1.err compiler_tests/fail-assign1.err > fail-assign1.diff
###### SUCCESS

###### Testing fail-assign2
../pienum.native -c compiler_tests/fail-assign2.pn 2> fail-assign2.err >> testall.log
diff -b fail-assign2.err compiler_tests/fail-assign2.err > fail-assign2.diff
###### SUCCESS

###### Testing fail-assign3
../pienum.native -c compiler_tests/fail-assign3.pn 2> fail-assign3.err >> testall.log
diff -b fail-assign3.err compiler_tests/fail-assign3.err > fail-assign3.diff
###### SUCCESS

###### Testing fail-dead1
../pienum.native -c compiler_tests/fail-dead1.pn 2> fail-dead1.err >> testall.log
diff -b fail-dead1.err compiler_tests/fail-dead1.err > fail-dead1.diff
###### SUCCESS

###### Testing fail-declare2
../pienum.native -c compiler_tests/fail-declare2.pn 2> fail-declare2.err >> testall.log
diff -b fail-declare2.err compiler_tests/fail-declare2.err > fail-declare2.diff
###### SUCCESS

###### Testing fail-expr1
../pienum.native -c compiler_tests/fail-expr1.pn 2> fail-expr1.err >> testall.log
diff -b fail-expr1.err compiler_tests/fail-expr1.err > fail-expr1.diff
###### SUCCESS

###### Testing fail-expr2
../pienum.native -c compiler_tests/fail-expr2.pn 2> fail-expr2.err >> testall.log
diff -b fail-expr2.err compiler_tests/fail-expr2.err > fail-expr2.diff
###### SUCCESS

###### Testing fail-func1
../pienum.native -c compiler_tests/fail-func1.pn 2> fail-func1.err >> testall.log
diff -b fail-func1.err compiler_tests/fail-func1.err > fail-func1.diff
###### SUCCESS

###### Testing fail-matrix-dot-add
../pienum.native -c compiler_tests/fail-matrix-dot-add.pn 2> fail-matrix-dot-add.err >> testall.log
diff -b fail-matrix-dot-add.err compiler_tests/fail-matrix-dot-add.err > fail-matrix-dot-add.diff
###### SUCCESS

###### Testing fail-matrix-dot-div
../pienum.native -c compiler_tests/fail-matrix-dot-div.pn 2> fail-matrix-dot-div.err >> testall.log
diff -b fail-matrix-dot-div.err compiler_tests/fail-matrix-dot-div.err > fail-matrix-dot-div.diff
###### SUCCESS

###### Testing fail-matrix-dot-mul
../pienum.native -c compiler_tests/fail-matrix-dot-mul.pn 2> fail-matrix-dot-mul.err >> testall.log
diff -b fail-matrix-dot-mul.err compiler_tests/fail-matrix-dot-mul.err > fail-matrix-dot-mul.diff
###### SUCCESS

###### Testing fail-matrix-dot-sub
../pienum.native -c compiler_tests/fail-matrix-dot-sub.pn 2> fail-matrix-dot-sub.err >> testall.log
diff -b fail-matrix-dot-sub.err compiler_tests/fail-matrix-dot-sub.err > fail-matrix-dot-sub.diff
###### SUCCESS

###### Testing fail-matrix-scalar-add
../pienum.native -c compiler_tests/fail-matrix-scalar-add.pn 2> fail-matrix-scalar-add.err >> testall.log
diff -b fail-matrix-scalar-add.err compiler_tests/fail-matrix-scalar-add.err > fail-matrix-scalar-add.diff
###### SUCCESS

###### Testing fail-matrix-scalar-add1
../pienum.native -c compiler_tests/fail-matrix-scalar-add1.pn 2> fail-matrix-scalar-add1.err >> testall.log
diff -b fail-matrix-scalar-add1.err compiler_tests/fail-matrix-scalar-add1.err > fail-matrix-scalar-add1.diff
###### SUCCESS

###### Testing fail-matrix-scalar-div
../pienum.native -c compiler_tests/fail-matrix-scalar-div.pn 2> fail-matrix-scalar-div.err >> testall.log
diff -b fail-matrix-scalar-div.err compiler_tests/fail-matrix-scalar-div.err > fail-matrix-scalar-div.diff
###### SUCCESS

###### Testing fail-matrix-scalar-div1
../pienum.native -c compiler_tests/fail-matrix-scalar-div1.pn 2> fail-matrix-scalar-div1.err >> testall.log
diff -b fail-matrix-scalar-div1.err compiler_tests/fail-matrix-scalar-div1.err > fail-matrix-scalar-div1.diff
###### SUCCESS

###### Testing fail-matrix-scalar-mul
../pienum.native -c compiler_tests/fail-matrix-scalar-mul.pn 2> fail-matrix-scalar-mul.err >> testall.log
diff -b fail-matrix-scalar-mul.err compiler_tests/fail-matrix-scalar-mul.err > fail-matrix-scalar-mul.diff
###### SUCCESS

###### Testing fail-matrix-scalar-mul1
../pienum.native -c compiler_tests/fail-matrix-scalar-mul1.pn 2> fail-matrix-scalar-mul1.err >> testall.log
diff -b fail-matrix-scalar-mul1.err compiler_tests/fail-matrix-scalar-mul1.err > fail-matrix-scalar-mul1.diff
###### SUCCESS

###### Testing fail-matrix-scalar-sub
../pienum.native -c compiler_tests/fail-matrix-scalar-sub.pn 2> fail-matrix-scalar-sub.err >> testall.log
diff -b fail-matrix-scalar-sub.err compiler_tests/fail-matrix-scalar-sub.err > fail-matrix-scalar-sub.diff
###### SUCCESS

###### Testing fail-matrix-scalar-sub1
../pienum.native -c compiler_tests/fail-matrix-scalar-sub1.pn 2> fail-matrix-scalar-sub1.err >> testall.log
diff -b fail-matrix-scalar-sub1.err compiler_tests/fail-matrix-scalar-sub1.err > fail-matrix-scalar-sub1.diff
###### SUCCESS
