anchor.diff:              | Tip(kx, x) -> f kx x z
               | Bin(_, _, l, r) -> go (go z r) l
           match x with
  -        | Bin(_, m, l, r) when m < 0 -> go (go z l) r  // put negative numbers before.
  -        | Bin(_, m, l, r) -> go (go z r) l
  +        | Bin(_, m, l, r) -> 
  +            if m < 0 then go (go z l) r  // put negative numbers before.
  +            else go (go z r) l
           | _ -> go z x
       
       member x.ToList() = x.FoldBackWithKey (fun k x xs -> (k, x) :: xs) []
  
positive.code:     let tryFindLE k t =
          let rec go def =
              function
              | Bin(p, m, l, r) when nomatch k p m -> if k < p then unsafeFindMax def else unsafeFindMax r
              | Bin(p, m, l, r) when zero k m -> go def l
              | Bin(p, m, l, r) -> go l r
              | Tip(ky, y) when k < ky -> unsafeFindMax def
              | Tip(ky, y) -> Some(ky, y)
              | Nil -> unsafeFindMax def
          match t with
          | Bin(_, m, l, r) when m < 0 -> if k >= 0 then go r l else go Nil r
          | _ -> go Nil t
  
negative.code:     let split k t =
          let rec go k t =
              match t with
              | Bin(p, m, l, r) ->
                  if nomatch k p m then
                      if k > p then (t, Nil) else (Nil, t)
                  elif zero k m then
                      let (lt, gt) = go k l
                      (lt, append gt r)
                  else
                      let (lt, gt) = go k r
                      (append l lt, gt)
              | Tip(ky, _) ->
                  if k > ky then (t, Nil)
                  else if k < ky then (Nil, t)
                  else (Nil, Nil)
              | _ -> (Nil, Nil)
          match t with
          | Bin(_, m, l, r) when  m < 0 ->
              if k >= 0 // handle negative numbers.
  