anchor.diff:          let lb = match lb with 
             | (Inl _, _, _) -> failwith "impossible"
             | (Inr l, t, e) -> 
  -            //let _ = printfn "Looking up %s\n" l.str in
               let (lb, t, e) = match Tc.Env.try_lookup_val_decl env l with 
                 | None -> 
  -              //  let _ = printfn "Not found!" in
                   let t = Tc.Util.extract_lb_annotation is_rec env t e in
                   (Inr l, t, e)
                 | Some t' -> match t.t with 
                     | Typ_unknown -> 
  -                  //  let _ = printfn "Found at type %s!" (Print.typ_to_string t') in
                       (Inr l, t', e)
                     | _ -> 
                       Util.print_string <| Util.format1 "%s: Warning: Annotation from val declaration overrides inline type annotation" (Range.string_of_range r);
  
positive.code: 
  and tc_decls (env:Tc.Env.env) ses = 
    let ses, env = List.fold_left (fun (ses, (env:Tc.Env.env)) se ->
  //  if (env.curmodule.str <> "Prims")
  //  //then Util.print_string (Util.format1 "Checking sigelt\t%s\n" (Util.lids_of_sigelt se |> List.map (fun l -> l.str) |> String.concat(", ")))
  //  then Util.print_string (Util.format1 "Checking sigelt\t%s\n" (Print.sigelt_to_string se))
  //  else ();
    let se, env = tc_decl env se in 
  //  if (env.curmodule.str <> "Prims")
  //  then Util.print_string (Util.format1 "Checked sigelt\n\t%s\n" (Print.sigelt_to_string_short se))// (Print.sigelt_to_string se))
  //  else ();
    se::ses, env) ([], env) ses in
    List.rev ses, env 
  
  let tc_modul env modul = 
    let env = Tc.Env.set_current_module env modul.name in 
    let ses, env = tc_decls env modul.declarations in 
    let modul = {name=modul.name; declarations=ses; exports=[]; is_interface=modul.is_interface} in (* TODO: handle exports *) 
    let env = Tc.Env.finish_module env modul in
    modul, env
  
  
negative.code:       let lbs' = List.rev lbs' in
        let e = Exp_let((fst lbs, lbs'), Exp_constant(Syntax.Const_unit)) in
        let se = match tc_exp env e with 
          | Exp_let(lbs, _), _ -> (* TODO: Call the solver here to check that the inferred type is compatible with any annotation *)
            Sig_let(lbs, r)
          | _ -> failwith "impossible" in
        let env = Tc.Env.push_sigelt env se in 
  