anchor.diff:      in
       let string_compare' rng (s1:string) (s2:string) : term =
           let r = String.compare s1 s2 in
  -        int_as_const rng r
  +        EMB.embed_int rng r
       in
       let string_concat' rng args : option<term> =
           match args with
           | [a1; a2] ->
               begin match arg_as_string a1 with
               | Some s1 ->
  -                begin match arg_as_list arg_as_string a2 with
  +                begin match arg_as_list EMB.unembed_string_safe a2 with
                   | Some s2 ->
                       let r = String.concat s1 s2 in
  -                    Some (string_as_const rng r)
  +                    Some (EMB.embed_string rng r)
                   | _ -> None
                   end
               | _ -> None
  
positive.code:         interpretation=f
      } in
      let unary_int_op (f:int -> int) =
          unary_op arg_as_int (fun r x -> int_as_const r (f x))
      in
      let binary_int_op (f:int -> int -> int) =
          binary_op arg_as_int (fun r x y -> int_as_const r (f x y))
      in
      let unary_bool_op (f:bool -> bool) =
          unary_op arg_as_bool (fun r x -> bool_as_const r (f x))
      in
      let binary_bool_op (f:bool -> bool -> bool) =
          binary_op arg_as_bool (fun r x y -> bool_as_const r (f x y))
      in
      let binary_string_op (f : string -> string -> string) =
          binary_op arg_as_string (fun r x y -> string_as_const r (f x y))
      in
      let list_of_string' rng (s:string) : term =
          let name l = mk (Tm_fvar (lid_as_fv l Delta_constant None)) rng in
  
negative.code: (* Semantics for primitive operators (+, -, >, &&, ...)            *)
  (*******************************************************************)
  let built_in_primitive_steps : list<primitive_step> =
      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 lift_unary
          : ('a -> 'b) -> list<option<'a>> ->option<'b>
  