anchor.diff:  [<Sealed>]
   [<DebuggerTypeProxy(typedefof<IntMapDebuggerProxy<int>>)>]
   [<DebuggerDisplay("Count = {Count}")>]
  -type IntMap<'T> private (trie : PatriciaMap<'T>) =
  +type IntMap< [<EqualityConditionalOn>] 'T> private (trie : PatriciaMap<'T>) =
       /// The empty IntMap.
       static member Empty
           with get () : IntMap<'T> =
  
positive.code: //
  namespace ExtCore.Collections
  
  open System.Collections.Generic
  open System.Diagnostics
  open LanguagePrimitives
  
negative.code:                 map1,
                  map2.Add (key, value)), (IntMap.Empty, IntMap.Empty))
  
      interface IEnumerable with
          /// <inherit />
          member __.GetEnumerator () =
              (trie.ToSeq () |> Seq.map (fun (k, v) -> DictionaryEntry (k, v))).GetEnumerator ()
              :> IEnumerator
  
      interface IEnumerable<KeyValuePair<int, 'T>> with
          /// <inherit />
          member __.GetEnumerator () =
              (trie.ToSeq () |> Seq.map (fun (k, v) -> KeyValuePair (k, v))).GetEnumerator ()
  
      interface ICollection<KeyValuePair<int, 'T>> with
          /// <inherit />
          member __.Count
              with get () =
                  PatriciaMap.Count trie
  
          /// <inherit />
          member __.IsReadOnly
              with get () = true
  
          /// <inherit />
          member __.Add x =
              notSupported "IntMaps cannot be mutated."
  
          /// <inherit />
          member __.Clear () =
              notSupported "IntMaps cannot be mutated."
  
          /// <inherit />
          member __.Contains (item : KeyValuePair<int, 'T>) =
              notImpl "Contains"
  //            match PatriciaMap.TryFind (uint32 item.Key, trie) with
  //            | None ->
  //                false
  //            | Some value ->
  //                LanguagePrimitives.HashCompare.GenericEqualityIntrinsic<'T>(value, item.Value)
  
          /// <inherit />
          member __.CopyTo (array, arrayIndex) =
              // Preconditions
              checkNonNull "array" array
              if arrayIndex < 0 then
                  raise <| System.ArgumentOutOfRangeException "arrayIndex"
  
              // Raise an ArgumentException if there's not enough room in the array (starting at 'arrayIndex')
              // to hold _all_ of the elements in this IntMap.
  
              notImpl "CopyTo"
  
          /// <inherit />
          member __.Remove item : bool =
              notSupported "IntMaps cannot be mutated."
  
      interface IDictionary<int, 'T> with
          /// <inherit />
          member __.Item
              with get key =
                  match PatriciaMap.TryFind (uint32 key, trie) with
                  | Some value ->
                      value
                  | None ->
                      raise <| System.Collections.Generic.KeyNotFoundException ()
              and set key value =
                  notSupported "IntMaps cannot be mutated."
  
          /// <inherit />
          member __.Keys
              with get () =
                  notImpl "Keys"
  
          /// <inherit />
          member __.Values
              with get () =
                  notImpl "Values"
  
          /// <inherit />
          member __.Add (key, value) =
              notSupported "IntMaps cannot be mutated."
  
          /// <inherit />
          member __.ContainsKey key =
              PatriciaMap.ContainsKey (uint32 key, trie)
  
          /// <inherit />
          member __.Remove key =
              notSupported "IntMaps cannot be mutated."
  
          /// <inherit />
          member __.TryGetValue (key, value) =
              match PatriciaMap.TryFind (uint32 key, trie) with
              | None ->
                  false
              | Some v ->
                  value <- v
                  true
  
  //
  and [<Sealed>]
  