anchor.diff:              match rev_assoc v !vstore with
               | Some x -> Choice.result x
               | None ->
  -                rev_assoc v (!gstore)
  +                rev_assoc v !gstore
                   |> Option.toChoiceWithError "find"
   
           let hol_of_bumped_var v = 
  
positive.code:     (* Test for equality under the pending instantiations.                     *)
      (* ----------------------------------------------------------------------- *)
  
      let rec fol_eq insts tm1 tm2 = 
          tm1 == tm2 || 
          match tm1, tm2 with
          | Fnapp(f, fargs), Fnapp(g, gargs) -> 
              f = g && forall2 (fol_eq insts) fargs gargs
          | _, Fvar(x) -> 
              match rev_assoc x insts with
              | Some tm2' ->
                   fol_eq insts tm1 tm2'
              | None -> 
                   istriv insts x tm1
                   |> Choice.fill false
  
          | Fvar(x), _ -> 
              match rev_assoc x insts with
              | Some tm1' ->
                   fol_eq insts tm1' tm2
              | None -> 
                   istriv insts x tm2
                   |> Choice.fill false
  
      let fol_atom_eq insts (p1, args1) (p2, args2) = 
          p1 = p2 && forall2 (fol_eq insts) args1 args2
  
      (* ----------------------------------------------------------------------- *)
      (* Cacheing continuations. Very crude, but it works remarkably well.       *)
      (* ----------------------------------------------------------------------- *)
  
      let cacheconts f = 
          let memory = ref []
          fun (_, (insts, _, size) as input) -> 
              if exists (fun (_, (insts', _, size')) -> insts = insts' && (size <= size' || !meson_depth)) (!memory) then 
                  failwith "cachecont"
              else 
                  memory := input :: (!memory)
                  f input
  
      (* ----------------------------------------------------------------------- *)
  
negative.code:                                 | _ -> false) 
                              equals_thm 
                              (mapfilter (Choice.toOption << Choice.map Choice.result << C INST_TYPE th) tyins)
                      if List.isEmpty ths' then 
                          warn true "No useful-looking instantiations of lemma"
                          return [th]
                      else 
  