anchor.diff:  (* Semantics for primitive operators (+, -, >, &&, ...)            *)
   (*******************************************************************)
   let built_in_primitive_steps : list<primitive_step> =
  -    let const_as_tm c p = mk (Tm_constant c) p in
  -    let int_as_const  : Range.range -> int  -> term =
  -        fun p i -> const_as_tm (FC.Const_int (BU.string_of_int i, None)) p
  -    in
  -    let bool_as_const : Range.range -> bool -> term =
  -        fun p b -> const_as_tm (FC.Const_bool b) p
  -    in
  -    let string_as_const : Range.range -> string -> term =
  -        fun p b -> const_as_tm (FC.Const_string (b, p)) p
  -    in
  -    let arg_as_int (a, _) : option<int> =
  -        match (SS.compress a).n with
  -        | Tm_constant (FC.Const_int(i, None)) ->
  -          Some (BU.int_of_string i)
  -        | _ ->
  -          None
  -    in
  +    let arg_as_int    (a:arg) = fst a |> EMB.unembed_int_safe in
  +    let arg_as_bool   (a:arg) = fst a |> EMB.unembed_bool_safe in
  +    let arg_as_char   (a:arg) = fst a |> EMB.unembed_char_safe in
  +    let arg_as_string (a:arg) = fst a |> EMB.unembed_string_safe in
  +    let arg_as_list (u : EMB.unembedder<'a>) a = fst a |> EMB.unembed_list_safe u in
       let arg_as_bounded_int (a, _) : option<(fv * int)> =
           match (SS.compress a).n with
           | Tm_app ({n=Tm_fvar fv1}, [({n=Tm_constant (FC.Const_int (i, None))}, _)])
               when BU.ends_with (Ident.text_of_lid fv1.fv_name.v) "int_to_t" ->
             Some (fv1, BU.int_of_string i)
           | _ -> None
  -    in
  -    let arg_as_bool (a, _) : option<bool> =
  -        match (SS.compress a).n with
  -        | Tm_constant (FC.Const_bool b) ->
  -          Some b
  -        | _ ->
  -          None
  -    in
  -    let arg_as_char (a, _) : option<char> =
  -        match (SS.compress a).n with
  -        | Tm_constant (Const_char c) ->
  -          Some c
  -        | _ ->
  -          None
  -    in
  -    let arg_as_string (a, _) : option<string> =
  -        match (SS.compress a).n with
  -        | Tm_constant (FC.Const_string(s, _)) ->
  -          Some s
  -        | _ ->
  -          None
  -    in
  -    let arg_as_list (f : arg -> option<'a>) (a, _) : option<list<'a>> =
  -        let rec sequence (l:list<option<'a>>) : option<list<'a>> =
  -            match l with
  -            | [] -> Some []
  -            | None::_ -> None
  -            | Some x::xs -> begin match sequence xs with
  -                            | None -> None
  -                            | Some xs' -> Some (x::xs')
  -                            end
  -        in
  -        match U.list_elements a with
  -        | None -> None
  -        | Some elts -> sequence (List.map (fun x -> f (as_arg x)) elts)
       in
       let lift_unary
           : ('a -> 'b) -> list<option<'a>> ->option<'b>
  
positive.code:            [ "Int8"; "UInt8"; "Int16"; "UInt16"; "Int32"; "UInt32"; "Int64"; "UInt64"; "UInt128"]
          in
          let int_as_bounded r int_to_t n =
              let c = int_as_const r n in
              let int_to_t = S.fv_to_tm int_to_t in
              S.mk_Tm_app int_to_t [S.as_arg c] None r
          in
  
negative.code:              (PC.p2l ["FStar"; "String"; "list_of_string"],
                                      1, unary_op arg_as_string list_of_string');
               (PC.p2l ["FStar"; "String"; "string_of_list"],
                                      1, unary_op (arg_as_list EMB.unembed_char_safe) string_of_list');
               (PC.p2l ["FStar"; "String"; "concat"], 2, string_concat');
               (PC.p2l ["Prims"; "range_of"], 2, range_of);
               (PC.p2l ["Prims"; "set_range_of"], 3, set_range_of);
  