anchor.diff:  
   /// An association list implementing a simple map-like data structure.
   /// This is used within PatriciaHashMap to handle hash collisions in a manner reminiscent of a hashtable.
  -type private NonEmptyAssociationList<'Key, [<EqualityConditionalOn; ComparisonConditionalOn>] 'T when 'Key : equality> =
  +type private ListMap<'Key, [<EqualityConditionalOn; ComparisonConditionalOn>] 'T when 'Key : equality> =
       /// The tail (last element) in the list.
       | Tail of 'Key * 'T
       /// A list element (key-value pair) along with the rest of the list.
  -    | Element of NonEmptyAssociationList<'Key, 'T> * 'Key * 'T
  +    | Element of ListMap<'Key, 'T> * 'Key * 'T
   
       /// Returns the number of bindings in the map.
  -    static member private CountImpl (listMap : NonEmptyAssociationList<'Key, 'T>, acc) : int =
  +    static member private CountImpl (listMap : ListMap<'Key, 'T>, acc) : int =
           match listMap with
           | Tail (_,_) ->
               acc + 1
           | Element (listMap,_,_) ->
  -            NonEmptyAssociationList.CountImpl (listMap, acc + 1)
  +            ListMap.CountImpl (listMap, acc + 1)
   
       /// Returns the number of bindings in the map.
  -    static member Count (listMap : NonEmptyAssociationList<'Key, 'T>) : int =
  +    static member Count (listMap : ListMap<'Key, 'T>) : int =
           // Call the recursive implementation.
  -        NonEmptyAssociationList.CountImpl (listMap, 0)
  -
  -    //
  -    static member TryFind (key : 'Key, listMap : NonEmptyAssociationList<'Key, 'T>) : 'T option =
  -        notImpl "NonEmptyAssociationList.ContainsKey"
  -
  -    //
  -    static member ContainsKey (key : 'Key, listMap : NonEmptyAssociationList<'Key, 'T>) : bool =
  -        notImpl "NonEmptyAssociationList.ContainsKey"
  +        ListMap.CountImpl (listMap, 0)
  +
  +    //
  +    static member TryFind (key : 'Key, listMap : ListMap<'Key, 'T>) : 'T option =
  +        match listMap with
  +        | Tail (k, v) ->
  +            if k = key then Some v
  +            else None
  +        | Element (listMap, k, v) ->
  +            if k = key then Some v
  +            else ListMap.TryFind (key, listMap)
  +
  +    //
  +    static member ContainsKey (key : 'Key, listMap : ListMap<'Key, 'T>) : bool =
  +        match listMap with
  +        | Tail (k, v) ->
  +            k = key
  +        | Element (listMap, k, v) ->
  +            k = key || ListMap.ContainsKey (key, listMap)
   
   
   
  
positive.code:                 match stack.Pop () with
                  | Empty -> ()
                  | Lf (_, listMap) ->
                      count <- count + (uint32 <| NonEmptyAssociationList.Count listMap)
                      
                  (* OPTIMIZATION :   When one or both children of this node are leaves,
                                      we handle them directly since it's a little faster. *)
                  | Br (_, _, Lf (_,_), Lf (_,_)) ->
                      count <- count + 2u
                      
                  | Br (_, _, Lf (_,_), child)
                  | Br (_, _, child, Lf (_,_)) ->
                      count <- count + 1u
                      stack.Push child
  
                  | Br (_, _, left, right) ->
  
negative.code:         match map with
          | Empty -> 0
          | Lf (_, listMap) ->
              ListMap.Count listMap
          | Br (_,_,_,_) as t ->
              /// The stack of trie nodes pending traversal.
              let stack = Stack (defaultTraversalStackSize)
  