anchor.diff:          if isEmpty m then MapTree(k,v)
           else
               let c = comparer.Compare(k,m.Key)
  -            match m with
  -            | :? MapTreeNode<'Key, 'Value> as mn ->
  +            if m.Height = 1 then
  +                if c < 0   then MapTreeNode (k,v,empty,m,2) :> MapTree<'Key, 'Value>
  +                elif c = 0 then MapTree(k,v)
  +                else            MapTreeNode (k,v,m,empty,2) :> MapTree<'Key, 'Value> 
  +            else
  +                let mn = asNode m
                   if c < 0 then rebalance (add comparer k v mn.Left) mn.Key mn.Value mn.Right
                   elif c = 0 then MapTreeNode(k,v,mn.Left,mn.Right,mn.Height) :> MapTree<'Key, 'Value>
                   else rebalance mn.Left mn.Key mn.Value (add comparer k v mn.Right)
  -            | _ ->
  -                if c < 0   then MapTreeNode (k,v,empty,m,2) :> MapTree<'Key, 'Value>
  -                elif c = 0 then MapTree(k,v)
  -                else            MapTreeNode (k,v,m,empty,2) :> MapTree<'Key, 'Value> 
  -
  +                
       let rec tryGetValue (comparer: IComparer<'Key>) k (v: byref<'Value>) (m: MapTree<'Key, 'Value>) =                     
           if isEmpty m then false
           else
               let c = comparer.Compare(k, m.Key)
               if c = 0 then v <- m.Value; true
               else
  -                match m with
  -                | :? MapTreeNode<'Key, 'Value> as mn ->
  +                if m.Height = 1 then false
  +                else
  +                    let mn = asNode m
                       tryGetValue comparer k &v (if c < 0 then mn.Left else mn.Right)
  -                | _ -> false
  -
  +                
  +    [<MethodImpl(MethodImplOptions.NoInlining)>]
  +    let throwKeyNotFound() = raise (KeyNotFoundException())
  +    
  +    [<MethodImpl(MethodImplOptions.NoInlining)>]
       let find (comparer: IComparer<'Key>) k (m: MapTree<'Key, 'Value>) =
           let mutable v = Unchecked.defaultof<'Value>
           if tryGetValue comparer k &v m then
               v
           else
  -            raise (KeyNotFoundException())
  +            throwKeyNotFound()
   
       let tryFind (comparer: IComparer<'Key>) k (m: MapTree<'Key, 'Value>) = 
           let mutable v = Unchecked.defaultof<'Value>
  
positive.code:     let rec tryPickOpt (f: OptimizedClosures.FSharpFunc<_, _, _>) (m: MapTree<'Key, 'Value>) =
          if isEmpty m then None
          else
              match m with 
              | :? MapTreeNode<'Key, 'Value> as mn ->
                  match tryPickOpt f mn.Left with 
                  | Some _ as res -> res 
                  | None -> 
  
negative.code:         | m :: rest ->
              if isEmpty m then collapseLHS rest
              else
                  if m.Height = 1 then
                      stack
                  else
                      let mn = asNode m
                      collapseLHS (mn.Left :: MapTree (mn.Key, mn.Value) :: mn.Right :: rest)
  
      let mkIterator m =
          { stack = collapseLHS [m]; started = false }
  