signature TREE = 
    sig 
	type label
	type size

	datatype stm =
	    SEQ of stm * stm
	  | LABEL of label
	  | JUMP of exp * label list
	  | CJUMP of relop * exp * exp * label * label
	  | MOVE of exp * exp
	  | EXP of exp

	and exp =
	    BINOP of binop * exp * exp
	  | MEM of exp
	  | TEMP of Temp.temp
	  | ESEQ of stm * exp
	  | NAME of label
	  | CONST of int
	  | CALL of exp * exp list

	and binop =
	    PLUS | MINUS | MUL | DIV | AND | OR

	and relop =
	    EQ | NE
	  | LT | GT | LE | GE
	  | ULT | ULE | UGT | UGE
	  
	val printTree : TextIO.outstream * stm -> unit
	val printTreeList : TextIO.outstream * stm list -> unit

	val UNIT: exp
	val ZERO: exp
	val ONE: exp

	val plus: exp * exp -> exp
	val minus: exp * exp -> exp

	val negRel : relop -> relop
	val commute: relop -> relop
	val seqStm: stm * stm * stm list -> stm
	val jumpLab: label -> stm

    end (* signatire TREE *)

structure Tree :> TREE where type label = Temp.label = 
    struct
	type label = Temp.label
	type size = int

	datatype stm =
	    SEQ of stm * stm
	  | LABEL of label
	  | JUMP of exp * label list
	  | CJUMP of relop * exp * exp * label * label
	  | MOVE of exp * exp
	  | EXP of exp

	and exp =
	    BINOP of binop * exp * exp
	  | MEM of exp
	  | TEMP of Temp.temp
	  | ESEQ of stm * exp
	  | NAME of label
	  | CONST of int
	  | CALL of exp * exp list

	and binop =
	    PLUS | MINUS | MUL | DIV | AND | OR 

	and relop =
	    EQ | NE | LT | GT | LE | GE 
	  | ULT | ULE | UGT | UGE

	fun printTree (outstream, s0) = (* Appel's code *)
	    let fun say s =  TextIO.output(outstream,s)
		fun sayln s= (say s; say "\n") 

		fun indent 0 = ()
		  | indent i = (say " "; indent(i-1))

		fun stm(SEQ(a,b),d) = (indent d; sayln "SEQ("; stm(a,d+1); sayln ","; stm(b,d+1); say ")")
		  | stm(LABEL lab, d) = (indent d; say "LABEL "; say (Symbol.name lab))
		  | stm(JUMP (e,_), d) =  (indent d; sayln "JUMP("; exp(e,d+1); say ")")
		  | stm(CJUMP(r,a,b,t,f),d) = 
		    (indent d; say "CJUMP(";
		     relop r; sayln ",";
		     exp(a,d+1); sayln ","; exp(b,d+1); sayln ",";
		     indent(d+1); say(Symbol.name t); 
		     say ","; say (Symbol.name f); say ")")
		  | stm(MOVE(a,b),d) =
		    (indent d; sayln "MOVE("; exp(a,d+1); sayln ",";
		     exp(b,d+1); say ")")
		  | stm(EXP e, d) =
		    (indent d; sayln "EXP("; exp(e,d+1); say ")")

		and exp(BINOP(p,a,b),d) =
		    (indent d; say "BINOP("; binop p; sayln ",";
		     exp(a,d+1); sayln ","; exp(b,d+1); say ")")
		  | exp(MEM(e),d) = (indent d; sayln "MEM("; exp(e,d+1); say ")")
		  | exp(TEMP t, d) =
		    (indent d; say "TEMP t"; say(Int.toString t))
		  | exp(ESEQ(s,e),d) =
		    (indent d; sayln "ESEQ("; stm(s,d+1); sayln ",";
		     exp(e,d+1); say ")")
		  | exp(NAME lab, d) = (indent d; say "NAME "; say (Symbol.name lab))
		  | exp(CONST i, d) = (indent d; say "CONST "; say(Int.toString i))
		  | exp(CALL(e,el),d) =
		    (indent d; sayln "CALL("; exp(e,d+1);
		     app (fn a => (sayln ","; exp(a,d+2))) el;
		     say ")")

		and binop PLUS = say "PLUS"
		  | binop MINUS = say "MINUS"
		  | binop MUL = say "MUL"
		  | binop DIV = say "DIV"
		  | binop AND = say "AND"
		  | binop OR = say "OR"
(*
		  | binop LSHIFT = say "LSHIFT"
		  | binop RSHIFT = say "RSHIFT"
		  | binop ARSHIFT = say "ARSHIFT"
		  | binop XOR = say "XOR"
*)

		and relop EQ = say "EQ"
		  | relop NE = say "NE"
		  | relop LT = say "LT"
		  | relop GT = say "GT"
		  | relop LE = say "LE"
		  | relop GE = say "GE"
(*
		  | relop ULT = say "ULT"
		  | relop ULE = say "ULE"
		  | relop UGT = say "UGT"
		  | relop UGE = say "UGE"
*)
	    in
		stm(s0, 0); sayln ""; TextIO.flushOut outstream
	    end

	fun printTreeList (outstream, stms) =
	    case stms of
		[] => ()
	      | stm :: stms =>
		(printTree (outstream, stm); printTreeList (outstream, stms))

	val UNIT = CONST 0
	val ZERO = CONST 0
	val ONE = CONST 1

	fun plus (l: exp, r: exp): exp = BINOP (PLUS, l, r)
	fun minus (l: exp, r: exp): exp = BINOP (MINUS, l, r)

	fun negRel EQ = NE 
	  | negRel NE = EQ
	  | negRel LT = GE
	  | negRel GE = LT
	  | negRel GT = LE 
	  | negRel LE =  GT
	  | negRel ULT = UGE
	  | negRel UGE = ULT
	  | negRel ULE = UGT 
	  | negRel UGT =  ULE

	fun commute EQ = EQ
	  | commute NE = NE
	  | commute LT = GT
	  | commute GE = LE
	  | commute GT = LT 
	  | commute LE =  GE
	  | commute ULT = UGT
	  | commute UGE = ULE
	  | commute ULE = UGE 
	  | commute UGT =  ULT

	fun seqStm (st1, st2, []) = SEQ (st1, st2)
	  | seqStm (st1, st2, st3 :: sts) =
	    SEQ (st1, seqStm (st2, st3, sts))

	fun jumpLab (lab: label) = JUMP (NAME lab, [lab])

    end (* structure Tree *)