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:                 // OPTIMIZE : Try calling Object.Equals or similar -- if the existing
                  // value is the same as the new value, we can return this node instead
                  // of creating a new one.
                  Lf (key, value)
              else
                  PatriciaHashMap.Join (key, Lf (key, value), j, map)
          | Br (p, m, t0, t1) ->
              if matchPrefix (key, p, m) then
                  if zeroBit (key, m) then
                      let left = PatriciaHashMap.Add (key, value, t0)
                      Br (p, m, left, t1)
                  else
                      let right = PatriciaHashMap.Add (key, value, t1)
                      Br (p, m, t0, right)
              else
                  PatriciaHashMap.Join (keyHash, Lf (key, Tail (key, value)), p, map)
  
      /// Insert a binding (key-value pair) into a map, returning a new, updated map.
      /// If a binding already exists for the same key, the map is not altered.
      static member TryAdd (key, value : 'T, map) =
          match map with
          | Empty ->
              Lf (key, value)
          | Lf (j, listMap) ->
              if j = key then
                  // A binding already exists with the given key.
                  // This method does not overwrite the existing value, so we can
                  // just return the existing map instead of creating an identical new one.
                  map
              else
                  PatriciaHashMap.Join (key, Lf (key, value), j, t)
          | Br (p, m, t0, t1) ->
              if matchPrefix (key, p, m) then
                  if zeroBit (key, m) then
                      let left = PatriciaHashMap.TryAdd (key, value, t0)
                      Br (p, m, left, t1)
                  else
                      let right = PatriciaHashMap.TryAdd (key, value, t1)
                      Br (p, m, t0, right)
              else
                  PatriciaHashMap.Join (key, Lf (key, value), p, map)
  
      /// Computes the union of two PatriciaHashMaps.
      static member Union (s, t) : PatriciaHashMap<'Key, 'T> =
          match s, t with
  
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)
  