anchor.diff:      | a::q ->
       let (x, t, _, _, _) = a in
       let t = base_typ t in
  -    let s = if arg_in_rets a rets then s else Local(x, t, (param_info false a)):: s in
  +    let s = if arg_in_rets a rets then s else Variable (x, t, (param_info false a)):: s in
       aux s q in
     {env with scope_mods = aux env.scope_mods args}
   
  
positive.code: 
  let lookup_proc (env:env) (x:id): proc_decl =
    match lookup_name env x false with
    | Some (Proc_decl (proc_decl, _)) -> (proc_decl)
    | _ -> err ("cannot find proc '" + (err_id x) + "'")
  
  let compute_bound (l1:bigint) (h1:bigint) (l2:bigint) (h2:bigint) (op:bop): (bigint * bigint) =
    let s = 
  
negative.code:     | None -> err ("Identifier not found " + (err_id id))
      | Some r -> ()
  
  let rec kind_equal k1 k2 =
    match (k1, k2) with
    | (TYPE i1, TYPE i2) -> i1=i2
    | (KApp (ks1, k1), KApp(ks2, k2)) ->
      (List.fold2 (fun b k1 k2 -> b && (kind_equal k1 k2)) true ks1 ks2) && (kind_equal k1 k2)
    
  let rec resolve_type env t:kind =
    match t with 
    | TName id -> lookup_type env id
    | TApp (t, ts) -> 
        let k = resolve_type env t in
        tc_kind env k ts
    | TArrow (ts, t) -> err ("not implemented")
    | _ -> err ("not implemented")
  and tc_kind env k ts = 
    let check env k t = 
      if kind_equal k (resolve_type env t) then ()
      else err ("kind of types not matching") in
    match k with
    | KApp (ks, k) ->
      if (List.length ks <> List.length ts) then err ("number of parameters not match in type construct")
      else List.iter2 (fun k t -> check env k t) ks ts;
      k
    | _ -> err ("wrong kind for the type")
  and resolve_types env ts = List.map (resolve_type env) ts;
  
  let rec tc_stmt (env:env) (s:stmt):stmt =
    match s with
  