anchor.diff:                  | None -> m
                   | Some v -> MapTree (k, v)
           else
  -            match m with
  -            | :? MapTreeNode<'Key, 'Value> as mn ->
  +            if m.Height = 1 then
  +                let c = comparer.Compare(k, m.Key)
  +                if c < 0 then
  +                    match u None with
  +                    | None -> m
  +                    | Some v -> MapTreeNode (k, v, empty, m, 2) :> MapTree<'Key,'Value>
  +                elif c = 0 then
  +                    match u (Some m.Value) with
  +                    | None -> empty
  +                    | Some v -> MapTree (k, v)
  +                else
  +                    match u None with
  +                    | None -> m
  +                    | Some v -> MapTreeNode (k, v, m, empty, 2) :> MapTree<'Key,'Value>
  +            else
  +                let mn = asNode m
                   let c = comparer.Compare(k, mn.Key)
                   if c < 0 then
                       rebalance (change comparer k u mn.Left) mn.Key mn.Value mn.Right
  
positive.code:         let rec loop (m: MapTree<'Key, 'Value>) acc = 
              if isEmpty m then acc
              else
                  match m with
                  | :? MapTreeNode<'Key, 'Value> as mn -> loop mn.Left ((mn.Key, mn.Value) :: loop mn.Right acc)
                  | _ -> (m.Key, m.Value) :: acc
          loop m []
  
      let toArray m =
  
negative.code: 
      let alreadyFinished() =
          raise (InvalidOperationException(SR.GetString(SR.enumerationAlreadyFinished)))
          
      let unexpectedStackForCurrent() =
          failwith "Please report error: Map iterator, unexpected stack for current"
          
      let unexpectedStackForMoveNext() =
          failwith "Please report error: Map iterator, unexpected stack for moveNext"
  
      let current i =
          if i.started then
              match i.stack with
              | []     -> alreadyFinished()
              | m :: _ ->
                  if m.Height = 1 then KeyValuePair<_, _>(m.Key, m.Value)
                  else unexpectedStackForCurrent()
          else
              notStarted()
  
  