anchor.diff:    let loop break' continue' test body =
       loop_ test void' body break' continue'
   
  -  let sub left right = Et.Subtract(left, right) :> Et
  -  let subChk left right = Et.SubtractChecked(left, right) :> Et
  -  let subAsn left right = Et.SubtractAssign(left, right) :> Et
  -  let subAsnChk left right = Et.SubtractAssignChecked(left, right) :> Et
  -
  -  let add left right = Et.Add(left, right) :> Et
  -  let addChk left right = Et.AddChecked(left, right) :> Et
  -  let addAsn left right = Et.AddAssign(left, right) :> Et
  -  let addAsnChk left right = Et.AddAssignChecked(left, right) :> Et
  +  let sub left right = Expr.Subtract(left, right) :> Expr
  +  let subChk left right = Expr.SubtractChecked(left, right) :> Expr
  +  let subAsn left right = Expr.SubtractAssign(left, right) :> Expr
  +  let subAsnChk left right = Expr.SubtractAssignChecked(left, right) :> Expr
  +
  +  let add left right = Expr.Add(left, right) :> Expr
  +  let addChk left right = Expr.AddChecked(left, right) :> Expr
  +  let addAsn left right = Expr.AddAssign(left, right) :> Expr
  +  let addAsnChk left right = Expr.AddAssignChecked(left, right) :> Expr
   
     let concat left right = callStaticT<System.String> "Concat" [left; right]
   
  -  let mul left right = Et.Multiply(left, right) :> Et
  -  let mulChk left right = Et.MultiplyChecked(left, right) :> Et
  -  let mulAsn left right = Et.MultiplyAssign(left, right) :> Et
  -  let mulAsnChk left right = Et.MultiplyAssignChecked(left, right) :> Et
  -
  -  let div left right = Et.Divide(left, right) :> Et
  -  let divAsn left right = Et.DivideAssign(left, right) :> Et
  -
  -  let pow left right = Et.Power(left, right) :> Et
  -  let powAsn left right = Et.PowerAssign(left, right) :> Et
  -
  -  let mod' left right = Et.Modulo(left, right) :> Et
  -  let modAsn left right = Et.ModuloAssign(left, right) :> Et
  -
  -  let or' left right = Et.OrElse(left, right) :> Et
  -  let orChain (c:Et list) = 
  +  let mul left right = Expr.Multiply(left, right) :> Expr
  +  let mulChk left right = Expr.MultiplyChecked(left, right) :> Expr
  +  let mulAsn left right = Expr.MultiplyAssign(left, right) :> Expr
  +  let mulAsnChk left right = Expr.MultiplyAssignChecked(left, right) :> Expr
  +
  +  let div left right = Expr.Divide(left, right) :> Expr
  +  let divAsn left right = Expr.DivideAssign(left, right) :> Expr
  +
  +  let pow left right = Expr.Power(left, right) :> Expr
  +  let powAsn left right = Expr.PowerAssign(left, right) :> Expr
  +
  +  let mod' left right = Expr.Modulo(left, right) :> Expr
  +  let modAsn left right = Expr.ModuloAssign(left, right) :> Expr
  +
  +  let or' left right = Expr.OrElse(left, right) :> Expr
  +  let orChain (c:Expr list) = 
       match c with
       | [] -> true'
       | _  -> List.fold (fun s x -> or' s x) c.Head c.Tail 
   
  -  let and' left right = Et.AndAlso(left, right) :> Et
  -  let andChain (c:Et list) = 
  +  let and' left right = Expr.AndAlso(left, right) :> Expr
  +  let andChain (c:Expr list) = 
       match c with
       | [] -> true'
       | _  -> List.fold (fun s x -> and' s x) c.Head c.Tail
   
  -  let is' typ target = Et.TypeIs(target, typ) :> Et
  +  let is' typ target = Expr.TypeIs(target, typ) :> Expr
     let isT<'a> = is' typeof<'a> 
   
  -  let typeEq target typ = Et.TypeEqual(target, typ) :> Et
  -
  -  let refEq left right = Et.ReferenceEqual(left, right) :> Et
  -  let refNotEq left right = Et.ReferenceNotEqual(left, right) :> Et
  -
  -  let eq left right = Et.Equal(left, right) :> Et
  -  let notEq left right = Et.NotEqual(left, right) :> Et
  -
  -  let lt left right = Et.LessThan(left, right) :> Et
  -  let ltEq left right = Et.LessThanOrEqual(left, right) :> Et
  -
  -  let gt left right = Et.GreaterThan(left, right) :> Et
  -  let gtEq left right = Et.GreaterThanOrEqual(left, right) :> Et
  -
  -  let not target = Et.OnesComplement target :> Et
  +  let typeEq target typ = Expr.TypeEqual(target, typ) :> Expr
  +
  +  let refEq left right = Expr.ReferenceEqual(left, right) :> Expr
  +  let refNotEq left right = Expr.ReferenceNotEqual(left, right) :> Expr
  +
  +  let eq left right = Expr.Equal(left, right) :> Expr
  +  let notEq left right = Expr.NotEqual(left, right) :> Expr
  +
  +  let lt left right = Expr.LessThan(left, right) :> Expr
  +  let ltEq left right = Expr.LessThanOrEqual(left, right) :> Expr
  +
  +  let gt left right = Expr.GreaterThan(left, right) :> Expr
  +  let gtEq left right = Expr.GreaterThanOrEqual(left, right) :> Expr
  +
  +  let not target = Expr.OnesComplement target :> Expr
     let notDefault target = notEq target (default' target.Type)
   
  -  let isFalse target = Et.IsFalse(target) :> Et
  -  let isTrue target = Et.IsTrue(target) :> Et
  +  let isFalse target = Expr.IsFalse(target) :> Expr
  +  let isTrue target = Expr.IsTrue(target) :> Expr
   
     let isDefault ex = eq ex (default' ex.Type)
     let isNull = isDefault
  
positive.code:   let newGenericArgsT<'a> = newGenericArgs typedefof<'a> 
  
    let delegateType (types:System.Type seq) = 
      Et.GetDelegateType(Seq.toArray types)
      
    let lambda (typ:System.Type) (parms:EtParam seq) body = 
      Et.Lambda(typ, body, parms)
  
    let lambdaT<'a> (parms:EtParam seq) (body:Et) = Et.Lambda<'a>(body, parms)
    let lambdaAuto (parms:EtParam seq) (body:Et) = Et.Lambda(body, parms)
  
    let invoke (func:Et) (args:Et seq) = Et.Invoke(func, args) :> Et
  
    let dynamic typ binder (args:Et seq) = Et.Dynamic(binder, typ, args) :> Et
    let dynamicT<'a> = dynamic typeof<'a>
  
    let length target = Et.ArrayLength(target) :> Et
  
    let item (expr:Expr) index = 
      let item = expr.Type.GetProperty("Item")
      Expr.MakeIndex(expr, item, [const' index]) :> Expr
  
    let index target (exprs:Et seq) = Et.ArrayAccess(target, exprs) :> Expr
    let indexInts target indexes = index target (indexes |> Seq.map (fun (x:int) -> const' x))
    let indexInt target index = indexInts target [index]
    let index0 target = index target [const' 0]
    let index1 target = index target [const' 1]
    let index2 target = index target [const' 2]
  
    let newArray typ (bounds:Et seq) = Et.NewArrayBounds(typ, bounds) :> Expr
    let newArrayT<'a> = new' typeof<'a>
  
    let newArrayItems typ (exprs:Et seq) = Et.NewArrayInit(typ, exprs) :> Expr
    let newArrayItemsT<'a> = newArrayItems typeof<'a>
  
    let newArrayBounds typ (size:Expr) = Expr.NewArrayBounds(typ, size) :> Expr
  
negative.code:     let local name type' = Expr.Variable(type', name)
      let localT<'a> name = var name typeof<'a>
      
      let param name type' = Expr.Parameter(type', name)
      let paramT<'a> name = param name typeof<'a>
  
      let paramRef name (type':Type) = param name (type'.MakeByRefType())
  