anchor.diff:      if i = 0 then
         Some (mk (A.PatWild))
       else
  -      BU.bind_opt (resugar_arg_qual qual) (fun aq -> mk (A.PatVar(bv_as_unique_ident x, )))
  +      BU.bind_opt (resugar_arg_qual qual) (fun aq -> Some (mk (A.PatVar(bv_as_unique_ident x, aq))))
     | _ ->
       BU.bind_opt (resugar_arg_qual qual)
         begin fun aq ->
           let pat = mk (A.PatVar(bv_as_unique_ident x, aq)) in
           if Options.print_bound_var_types() then
  -          mk (A.PatAscribed(pat, resugar_term x.sort))
  +          Some (mk (A.PatAscribed(pat, resugar_term x.sort)))
           else
  -          pat
  +          Some pat
         end
   
   and resugar_match_pat (p:S.pat) : A.pattern =
  
positive.code:   aux p
  
  let resugar_qualifier : S.qualifier -> option<A.qualifier> = function
    | Assumption -> Some A.Assumption
    | New -> Some A.New
    | Private -> Some A.Private
    | Unfold_for_unification_and_vcgen -> Some A.Unfold_for_unification_and_vcgen
    (* TODO : Find the correct option to display this *)
    | Visible_default -> if true then None else Some A.Visible
    | Irreducible -> Some A.Irreducible
    | Abstract -> Some A.Abstract
    | Inline_for_extraction -> Some A.Inline_for_extraction
    | NoExtract -> Some A.NoExtract
    | Noeq -> Some A.Noeq
    | Unopteq -> Some A.Unopteq
    | TotalEffect -> Some A.TotalEffect
    (* TODO : Find the correct option to display this *)
    | Logic -> if true then None else Some A.Logic
    | Reifiable -> Some A.Reifiable
    | Reflectable _ -> Some A.Reflectable
    | Discriminator _ -> None
    | Projector _ -> None
    | RecordType _ -> None
    | RecordConstructor _ -> None
    | Action _ -> None
    | ExceptionConstructor -> None
    | HasMaskedEffect -> None
    | Effect -> Some A.Effect_qual
    | OnlyName -> None
  
  
  let resugar_pragma = function
    | SetOptions s -> A.SetOptions s
    | ResetOptions s -> A.ResetOptions s
    | LightOff -> A.LightOff
  
  let resugar_typ datacon_ses se : sigelts * A.tycon =
    match se.sigel with
    | Sig_inductive_typ (tylid, uvs, bs, t, _, datacons) ->
        let current_datacons, other_datacons = List.partition (function
          | Sig_datacon (_, _, _, inductive_lid, _, _) -> lid_equals inductive_lid tylid)
        in
        assert (List.length current_datacons = List.length datacons) ;
        let tyc =
  
negative.code: let resugar_sigelt se : option <A.decl> =
    match se.sigel with
    | Sig_bundle (ses, _) ->
      let decl_typ_ses, datacon_ses = ses |> List.partition
        (fun se -> match se.sigel with
          | Sig_inductive_typ _ | Sig_declare_typ _ -> true
          | Sig_datacon _ -> false
  