Test Cases:
-----------

Optimization1 (5 Points)
-------------
Test0:
0 div a

Test1:
x + 5

Test2(a):
5 + x

Test2(b):
6.7 + 0.0

Test3(b):
4.3 + a

Test3: 
(a + 6) + (b + 6)

Test4:
true andalso a andalso b orelse false

Test5:
let
 val x = (5 + a)
 val y = (x + 2) + (9 div x)
 val z = 10 - y
in
 (x + 10) + (y * 100) + (7 div z)
end

Test6:
let
 val x = 0 div a
 val z = true andalso a
 val o = let
           val q = x + (100 + x)
	 in
           if (z andalso false) then (40 * q) 
	   else (10 + x)
	 end
in
 x + o
end

Test7:
let
 val x = fn(a,y) => a + (y * 100)
 val z = x(100 * (900 + a))
in
 x(100) + (5 * z)
end

Test8:
~((a andalso true) orelse (false orelse a))

Test9:
(4 + 6,7 + a,let val x = 6.7 + (8.9 + b) in 4 * b end)

Test10:
(5 - a,10 div b)

Test11:
let
 val x = fn(a,b) => (5 + a) + (42 - b)
in
 x
end

Test12:
let
 val x = fn(a) => fn(b) => a + b
in
 x a 10+b
end

Test13:
let
 val f = fn(a) => (10 - a) * (a * 83)
in
 f (5 + a)
end

Optimization2 (10 Points)
-------------
Test0:
let
 val x = 2 * 5
in 
 f(x)
end

Test1:
let
 val x = 2 * 8 + 5 * 10 div 2
 val y = x + 4
 val z = x + y + 9
in
 (x - y * z) + (1 + 9)
end

Test2:
let
 val x = 1.2 + 5.6 / 2.3
in
 x * 2.3
end

Test3:
let
 val x = (true andalso false) andalso (false andalso false)
 val y = (x andalso true)
in
 (x andalso true) andalso (y orelse false) orelse (true orelse false)
end

Test4:
(2 + 5 + 9,2 * 20,10 - 42)

Test5:
let
 val x = if 38 + 4 = 42 then 36 else 0 
in 
 x 
end

Test6a):
let 
 val x = ~4
 val y = 10
in
 5 + x
end

Test6b)
let 
 val x = ~4
 val y = 10
in
 5
end

Test7:
let val x = if true then (let 
			   val x = 100
			   val y = 420
			  in
			   if (4 >= 100) then 42 else ~42
			  end)
	    else ~84
in
 x
end

Test8:
let 
 val y = let
	  val y' = let
 		    val y'' = let
		               val y''' = fn(a) => a + (42 * 100 + ~43)	      
  			      in
			       99
			      end
		   in
		    99
		   end
 	 in
	  y'
	 end
in
 y
end

Test9:
let 
 val y = let
	  val y' = let
 		    val y'' = let
		               val y''' = fn(a) => a + (42 * 100 + ~43)	      
  			      in
			       yy'
			      end
		   in
		    y''
		   end
 	 in
	  y'
	 end
in
 y
end

Test10:
let
in
 if (let val x = 42 in let in let in let in let in let in let in not (true andalso false) end end end end end end end) then 42 else ~42 end

Optimization3 (5 Points)
-------------
Test0(a):
true andalso false

Test0(b):
true andalso true

Test0(c):
true andalso true andalso false

Test0(d):
x andalso true

Test0(e):
x andalso false

Test0(f):
x orelse false

Test0(g):
x orelse true

Test0(f):
x orelse false

Test1(a):
0 + x

Test1(b):
x * 1

Test1(c):
x * 0

Test1(d):
x - x

Test1(e):
x div 1

Test1(f):
1 div x

Test1(g):
0 * x

Test1(h):
1 * x

Test2:
(x + (y * 0)) - x

Test2:
true andalso (w andalso (z andalso false))

Test2:
(w andalso (z andalso (x orelse (y andalso(e orelse (true andalso false))))))

Test2:
(w andalso (z andalso (x orelse (y andalso(e orelse (true andalso false)))))) andalso false

Optimization4 (15 Points)
-------------
Test0:
let
 val x = y + 0
in
 f(x,z andalso false)
end

Test1:
let
 val x = ((a andalso (y orelse (not (z andalso (true andalso (x andalso y)))))) andalso false)
in
 x
end

Test2:
((x div 1 + (y - x * 0)) + (y * 1 + x * 0) * ((x div (1 + 0)) - x) - (x + y))

Test 3:
if (a - (a * (1 * 0))) = 1 then a else b

Test4:
a - (a * (1 * 0) + a)

Test5:
if a - (a * (1 * 0) + a) = 0 then a else b

Test6:
let 
 val x = x * x * x * (x - x)
in
 apply(if a - (a * (1 * 0) + a) = 0 then a else b)
end

Test8:
let 
 val M = (x div 1 + (y - x * 0)) + (y * 1 + x * 0) * ((x div (1 + 0)) - x) - (x + (y - x * 0)) + (y + x * 0) * ((x div (1 + 0)) - x) 
in 
 f(M) 
end

Test9:
let
 val M = (x + y) + z
in
 M * 0 * (1 + 0)
end

Test10:
let
 val M = (x + y) + z
in
 M * 0 * 1 + 0
end

Test10:
M * (1 div (x * 0 + 1))

Test11:
let
 val a = 42
 val b = a
 val c = b
 val d = c
 val y = ((a + b + 100) * (b + ~c))
 val x = ((a + b + 100) * (b + ~c) + (c * (d - (0 + d))))
in
 x - x
end

Test12:
let
 val x = fn(a) => fn(b)=> a - b * (42 - (1 * (0 + 42)))
in
 x((100 * 42)*(1 - 1))
end

Optimization5 (20 Points)
-------------
Test0a):
let
 val x = 1
in
 x
end

Test0b)
let
 val y = 100 >= 99
 val z = 200 <= 200
 val o = not (true andalso (false orelse true))
 val p = 42 > 42
 val q = 42 < 42
 val m = if y andalso z andalso o andalso (not p) andalso (not q) then 42
         else ~42
in
 m
end

Test1:
let
 val x = 200 div ((5 * 9) - 15)
 val y = x + 10
 val z = x + y
 val w = x + y + z
in 
 w
end

Test2:
let
 val x = true andalso (false andalso (true orelse false))
 val y = true orelse x orelse false
 val z = not y
in
 z
end

Test3:
let
 val x = 1.1 + (5.6 * 8.9) / 5.2
 val y = x * 5.6
 val z = 12.0 + x
 val w = x + y * z
in
 w
end

Test4:
let
 val x = 23 + a * 1000
 val X = 42
 val y = x * (20 + X)
 val w = x * y
in
 w
end

Test5:
let
 val x = true
 val v = if x then 1 else 0
in
 v
end

Test6:
let
 val x = let val x' = 10 val y' = 20 in x' + y' end
 val y = x + 10
 val o = let 
          val w = 42
         in
          x + y + w
	 end
in
 o
end
 
Test7:
let
 val add = fn(a,b) => a + b
 val y = 42
in
 let
  val w = y * 2
 in
  add(y,w)
 end
end

Test8:
let
 val x = (20 + 45 * 100 div 5)
 val y = x + 42
 val z = x * y
in
 f(z)
end

Test9:
let 
 val x = fn(a) => 
                let 
                  val x' = fn(a')=> a' * 2 
                  val y' = fn(b,w) => b + w + a
                in
                  x'(a) - y'(x'(a),y'(x'(100),10))
		end
in
 x(100)
end

Test10:
let 
 val y = let
	  val y' = let
 		    val y'' = let
		               val y''' =  (42 * 100 + ~43)	      
  			      in
			       y'''
			      end
		   in
		    y''
		   end
 	 in
	  y'
	 end
in
 y
end

Test11:
let
 val y = 
 if (let val x = 42 in let val x' = x in let val x'' = x' in let in let in let in let in x + x' + x'' = 42 * 3 end end end end end end end) then 42 else ~42 
in
 y
end

Optimization6 (22 Points)
-------------

Test0:
let
 val a = fn(a') => a' * 5
 val b = fn(a',b') => a' + b'
 val c = fn(x) => b(a(x),x + 5)
 val d = fn(y) => c(y) - a(y)
in
 d(10)
end


Test1:
let
 val a = fn(a) => a * 5
 val b = fn(a',b') => a' + b'
 val c = fn(x) => b(a(x),x + 5)
 val d = fn(y) => c(y) - a(y)
in
 (let
  val a' = fn(a'') => a'' - 5
  val d' = fn(y) => c(y) + a(y)
 in
  d'(10)
 end) + d(10)
end


Test2:
let
 val x = fn(a) => a * 2
 val y = fn(b,u) => b(u)
 val z = fn() => y (z,2)
in 
 z()
end

Test3:
let
 val x = fn(a) => a * 2
 val y = fn(b) => let
 		   val c = fn()=> x(b)
		   val d = x(c())
		  in
		   d
		  end
in
 x(y)
end

Test4:
let
 val add = fn(x,y) => x + y
 val addTwice = fn(a,b) => add(add(a,b),add(a,b))
 val addAgain = fn(a',b') => addTwice(addTwice(a',b'),addTwice(a',b'))
in
 addAgain(10,20)
end

Test5:
let
 val a = fn(a) => a * 5
 val b = fn(a,b) => a(b)
 val w = fn() => b(a,10)
in
 w 
end

Test6:
let 
 val x = fn(a) => 
                let 
                  val x' = fn(a')=> a' * 2 
                  val y' = fn(b,w) => b + w + a
                in
                  x'(a) - y'(x'(a),y'(x'(100),10))
		end
in
 x(100)
end

Test7:
let
 val x = fn(a) => fn(b) => a(b)
 val triple = fn(a) => a * 3
 val z = fn() => x triple
in
 z() 2
end

Test8:
let
 val x = fn(a) => a + 101
 val y = fn(b) => let 
		   val w = fn(j) => j * 25
		  in
		   w(b)
  		  end
in
 y(1)
end

Test9:
let
 val x = fn(a) => fn(b) => a(b)
 val triple = fn(a) => a * 3
 val z = fn(b) => let 
		   val j = x triple
		  in
	 	   (j 5) + b
	 	  end
in
 z 2
end

Test10:
let 
 val l = fn() =>
   let
    val x = fn(a) => fn(b) => a(b)
    val triple = fn(a) => a * 3
    val z = fn(b) => let 
  		      val j = x triple
		     in
	 	      (j 5) + b
	 	     end
   in
    z 2
   end
in
 l()
end


Optimization7 (23 Points)
-------------------------
Test0:
let 
 val x = fn(a) => 
                let 
                  val x = fn(a)=> a * 2 
                  val y = fn(b,w) => b + w + a
                in
                  x(a) - y(x(a),y(x(100),10))
		end
in
 x(100)
end


Test1:
let
 val a = fn(a) => a * 5
 val b = fn(a,b) => a + b
 val c = fn(x) => b(a(x),x + 5)
 val d = fn(y) => c(y) - a(y)
in
 (let
  val a = fn(a) => a - 5
  val d = fn(y) => c(y) + a(y)
 in
  d(10)
 end) + d(10)
end


Test2:
let
 val b = 42
 val a = fn(a,b) => a(b)
in
 a(b)
end

Test3:
let 
 val x = fn(x) => fn(x) => x + x
 val x = fn(x) => x * 5
in 
 x(5)
end

Test4:
let
 val x = fn(x) => fn(x) => x + x
 val x = fn(a) = > x a a
in
 x 5
end

Test5:
let
 val x = let
          val x = let
                   val x = x
		  in
                   x
		  end
         in
          x
         end
in
 x
end

Test6:
let
 val x = 42
 val y = (x,let val x = 84 in x end)
in
 x + y
end


Test8:
let
 val x = fn(a) => a + 101
 val y = fn(b) => let 
		   val w = fn(j) => j * 25
		  in
		   w(b)
  		  end
in
 y(1)
end

Test9:
let 
 val y = 42
 val x = fn(a) => 
                 let
		  val b = 84
		 in
                   (let
                     val a = fn(a) => a - 5
		    in
                     a(y)
		    end) + a * y
		 end
in
 x(x(y))
end

Test10:
let 
 val x = fn() =>
   let
    val x = fn(x) => fn(b) => x(b)
    val triple = fn(x) => x * 3
    val z = fn(z) => let 
  		      val j = x triple
		     in
	 	      (j 5) + z
	 	     end
   in
    z 2
   end
in
 x()
end