anchor.diff:  open Microsoft.FStar.Absyn.Util
   open Microsoft.FStar.Util
   
  +let constructors = Util.smap_create 100
  +
  +let _ = 
  +    Util.smap_add constructors "Prims.op_Minus" (1, Some(function x::[] -> JSE_Minus(x) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_Negation" (1, Some(function x::[] -> JSE_Lnot(x) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_Addition" (2, Some(function x::y::[] -> JSE_Add(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_Subtraction" (2, Some(function x::y::[] -> JSE_Sub(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_Division" (2, Some(function x::y::[] -> JSE_Divide(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_Multiply" (2, Some(function x::y::[] -> JSE_Multiply(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_Modulus" (2, Some(function x::y::[] -> JSE_Mod(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_BarBar" (2, Some(function x::y::[] -> JSE_Lor(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_AmpAmp" (2, Some(function x::y::[] -> JSE_Land(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_GreaterThan" (2, Some(function x::y::[] -> JSE_Gt(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_LessThanOrEqual" (2, Some(function x::y::[] -> JSE_Le(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_LessThan" (2, Some(function x::y::[] -> JSE_Lt(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_GreaterThanOrEqual" (2, Some(function x::y::[] -> JSE_Ge(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_Equality" (2, Some(function x::y::[] -> JSE_Equal(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.op_disEquality" (2, Some(function x::y::[] -> JSE_Lnot(JSE_Equal(x,y)) | _ -> failwith ""));
  +    Util.smap_add constructors "String.strcat" (2, Some(function x::y::[] -> JSE_Add(x,y) | _ -> failwith ""));
  +    Util.smap_add constructors "Prims.MkTuple2" (2, None);
  +    Util.smap_add constructors "Prims.MkTuple3" (3, None);
  +    Util.smap_add constructors "Prims.MkTuple4" (4, None);
  +    Util.smap_add constructors "Prims.MkTuple5" (5, None);
  +    Util.smap_add constructors "Prims.MkTuple6" (6, None);
  +    Util.smap_add constructors "Prims.MkTuple7" (7, None);
  +    Util.smap_add constructors "Prims.MkTuple8" (8, None);
  +    ()
  +
   let rec js_of_const (c:sconst) : expression_t =
       match c with
       | Const_unit -> JSE_Undefined
  
positive.code:         match js_of_expr None e with JSE_Elision | JSE_Undefined -> None | e -> Some(e)
      ))])
  
  and js_of_app (e1:exp) (e2:exp) =
      let (e1,e2) = (Absyn.Util.compress_exp e1, Absyn.Util.compress_exp e2) in
      let nonstd e1 e2 = Util.print_any e1; JSE_Call(js_of_expr None e1, [js_of_expr None e2]) in
      match e1 with
      | Exp_fvar(x,b) -> (match x.v.str with
          | "Prims.op_Minus" -> JSE_Minus(js_of_expr None e2)
          | "Prims.op_Negation" -> JSE_Lnot(js_of_expr None e2)
          | _ -> nonstd e1 e2)
      | Exp_app(Exp_fvar(x,b), e3, f) ->
          (match x.v.str with
          | "Prims.op_Addition" -> JSE_Add(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_Subtraction" -> JSE_Sub(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_Multiply" -> JSE_Multiply(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_Modulus" -> JSE_Mod(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_Division" -> JSE_Divide(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_BarBar" -> JSE_Lor(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_AmpAmp" -> JSE_Land(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_GreaterThan" -> JSE_Gt(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_LessThanOrEqual" -> JSE_Le(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_LessThan" -> JSE_Lt(js_of_expr None e3, js_of_expr None e2)
          | "Prims.op_GreaterThanOrEqual" -> JSE_Ge(js_of_expr None e3, js_of_expr None e2)
          | "" -> JSE_Lor(js_of_expr None e3, js_of_expr None e2)
          | _ -> nonstd e1 e2)
      | _ -> nonstd e1 e2
  
  and js_of_binding (x:either<bvvdef,lident>, t:typ, e:exp) =
      let n = match x with Inl(x) -> x.ppname.idText | Inr(x) -> x.ident.idText in
  
negative.code:     | Exp_match(e, pl) -> Exp_match(untype_expr e, List.map unt_pat pl)
      | _ -> e
  
  and type_arity = function
    | Typ_fun(_,t,_,_) -> 1 + (type_arity t.t)
    | Typ_refine(_, t, _) -> type_arity t.t
    | Typ_app(t, _, _) -> (type_arity t.t) - 1
    | Typ_dep(t,_,_) -> type_arity t.t
    | Typ_lam(_,_,t) -> 1 + (type_arity t.t)
    | Typ_tlam(_, _, t) -> type_arity t.t
    | Typ_ascribed(t,_) -> type_arity t.t
    | Typ_meta(Meta_pos(t,_)) -> type_arity t.t
    | Typ_meta(Meta_pattern(t,_)) -> type_arity t.t
    | Typ_meta(Meta_named(t,_)) -> type_arity t.t
    | _ -> 0 
  
  and compile_def (d:sigelt) =
      match d with
      | Sig_datacon(n,ty,tyn,_) -> printf "\nAdding %s\n" n.str; Util.smap_add constructors n.str (type_arity ty.t, None)
      | Sig_bundle(defs, range) -> List.iter compile_def defs
      | _ -> ()
  
  and js_of_exports isrec (id,typ,expr) : source_t =
      let (n,sn) = match id with Inl(x) -> failwith "unexpected boundvar in module export"
              | Inr(x) -> (x.str,x.ident.idText) in
  