anchor.diff:                     |> THENC <| RATOR_CONV(RATOR_CONV(RAND_CONV NUM_EVEN_CONV))
                      |> THENC <| GEN_REWRITE_CONV I [tth]
                      |> THENC <| (fun tm -> 
  -                       if Choice.get <| rator tm = neg_tm
  -                       then RAND_CONV (RAND_CONV NUM_EXP_CONV) tm
  -                       else RAND_CONV NUM_EXP_CONV tm))
  +                                    choice {
  +                                       let! tm1 = rator tm
  +                                       if tm1 = neg_tm then 
  +                                           return! RAND_CONV (RAND_CONV NUM_EXP_CONV) tm
  +                                       else 
  +                                           return! RAND_CONV NUM_EXP_CONV tm
  +                                    }))
   
   /// Conversion to produce absolute value of an integer literal of type :int.
   let INT_ABS_CONV = 
  
positive.code:                                        let! a, b = dest_gcd tm
                                         return SPECL [a; b] int_gcd
                                     }) gts
                             return!
                                 (MAP_EVERY MP_TAC ths
                                  |> THEN <| MAP_EVERY SPEC_TAC (zip gts (map (genvar << Choice.get << type_of) gts))) gl
                          })
      REPEAT(GEN_TAC
             |> ORELSE <| CONJ_TAC)
  
negative.code:         choice {
              let k = equo_num x y
              let l = emod_num x y
              let! x' = mk_intconst x
              let! y' = mk_intconst y
              let! k' = mk_intconst k
              let! l' = mk_intconst l
              let! th0 = 
                  INST [x', m;
                        y', n;
                        k', q;
                        l', r] pth
              let! tm1 = lhand(concl th0)
              let! tm0 = lhand tm1
              let th1 = (LAND_CONV INT_MUL_CONV
                         |> THENC <| INT_ADD_CONV) tm0
              let! th2 = MP (Choice.result th0) th1
              let! tm2 = lhand(concl th2)
              let! th3 = MP (Choice.result th2) (EQT_ELIM(INT_LE_CONV tm2))
              let! tm3 = lhand(concl th3)
              return! MP (Choice.result th3) (EQT_ELIM((RAND_CONV INT_ABS_CONV
                                                        |> THENC <| INT_LT_CONV) tm3))
          }
      (fun tm -> 
          choice { 
  