anchor.diff:  
           /// OPTIMIZATION: Array.Clone () is not used since it's been profiled to be slower
           let inline private cloneArray (arr : HNode<'k, 'v> array) =
  -            let arr' = Array.zeroCreate 32 : HNode<'k, 'v> array    // NOTE: there's an unecessary check against the size here, but that's the only inefficiency
  +            let arr' = Array.zeroCreate 16 : HNode<'k, 'v> array    // NOTE: there's an unecessary check against the size here, but that's the only inefficiency
                                                                       // TODO: P1: use Array.zeroCreateUnchecked if / when it becomes available
  -            Array.Copy (arr, 0, arr', 0, 32) // param checks are inefficient, but hopefully there's at least a memcpy underneath...
  +            Array.Copy (arr, 0, arr', 0, 16) // param checks are inefficient, but hopefully there's at least a memcpy underneath...
               arr'
       
           let inline private hashToIndex h dep =
  -            (h >>> (dep * 5)) &&& 0x1F
  -
  -        let private addToBucket (entry : Hkv<'k, 'v>) (bucket : Hkv<'k, 'v> array) =
  -            let bucketLength = bucket.Length
  -            let bucket2 = Array.zeroCreate (bucketLength + 1) : Hkv<'k, 'v> array
  -            Array.Copy (bucket, 0, bucket2, 0, bucketLength)
  -            bucket2.[bucketLength] <- entry
  -            bucket2
  -
  -        let private removeFromBucket (k : 'k) (bucket : Hkv<'k, 'v> array) =
  -            match Array.tryFindIndexBack (fun (entry2 : Hkv<'k, 'v>) -> entry2.K.Equals k) bucket with
  -            | Some index ->
  -                let bucket2 = Array.zeroCreate (bucket.Length - 1) : Hkv<'k, 'v> array
  -                Array.Copy (bucket, 0, bucket2, 0, index)
  -                Array.Copy (bucket, index + 1, bucket2, index, bucket2.Length - index)
  -                bucket2
  -            | None -> bucket
  -
  -        let private tryFindInBucket (k : 'k) (bucket : Hkv<'k, 'v> array) =
  -            match Array.tryFindBack (fun (entry2 : Hkv<'k, 'v>) -> entry2.K.Equals k) bucket with
  -            | Some hkv -> Some hkv.V
  -            | None -> None
  +            (h >>> (dep * 4)) &&& 0xF
  +
  +        let private addToGutter (entry : Hkv<'k, 'v>) (gutter : Hkv<'k, 'v> array) =
  +            let gutterLength = gutter.Length
  +            let gutter2 = Array.zeroCreate 16 : Hkv<'k, 'v> array
  +            Array.Copy (gutter, 0, gutter2, 0, gutterLength)
  +            gutter2.[gutterLength] <- entry
  +            gutter2
  +
  +        let private removeFromGutter (k : 'k) (gutter : Hkv<'k, 'v> array) =
  +            match Array.FindLastIndex (gutter, fun (entry2 : Hkv<'k, 'v>) -> entry2.B && entry2.K.Equals k) with
  +            | -1 -> gutter
  +            | index ->
  +                let gutter2 = Array.zeroCreate (gutter.Length - 1) : Hkv<'k, 'v> array
  +                Array.Copy (gutter, 0, gutter2, 0, index)
  +                Array.Copy (gutter, index + 1, gutter2, index, gutter2.Length - index)
  +                gutter2
  +
  +        let private tryFindInGutter (k : 'k) (gutter : Hkv<'k, 'v> array) =
  +            match Array.FindLastIndex (gutter, fun (entry2 : Hkv<'k, 'v>) -> entry2.B && entry2.K.Equals k) with
  +            | -1 -> FOption.none ()
  +            | index -> FOption.some gutter.[index].V
  +
  +        let empty =
  +            Nil
   
           let isEmpty node =
               match node with
               | Nil -> true
               | _ -> false
       
  -        let rec fold folder state node =
  -            match node with
  -            | Nil -> state
  -            | Singleton hkv -> folder state hkv.K hkv.V
  -            | Multiple arr -> Array.fold (fold folder) state arr
  -            | Bucket bucket -> Array.fold (fun state (hkv : Hkv<_, _>) -> folder state hkv.K hkv.V) state bucket
  -    
  -        /// NOTE: This function seems to profile as being very slow. I don't know if it's the seq / yields syntax or what.
  -        let rec toSeq node =
  -            seq {
  -                match node with
  -                | Nil -> yield! Seq.empty
  -                | Singleton hkv -> yield (hkv.K, hkv.V)
  -                | Multiple arr -> for n in arr do yield! toSeq n
  -                | Bucket bucket -> yield! Array.map (fun (hkv : Hkv<_, _>) -> (hkv.K, hkv.V)) bucket }
  -    
           /// OPTIMIZATION: Requires an empty array to use the source of new array clones in order to avoid Array.create.
           let rec add (hkv : Hkv<'k, 'v>) (earr : HNode<'k, 'v> array) (dep : int) (node : HNode<'k, 'v>) : HNode<'k, 'v> =
       
               // lower than max depth, non-clashing
  -            if dep < 8 then
  +            if dep < 9 then
       
                   // handle non-clash cases
                   match node with
  
positive.code:         | Nil
          | Singleton of Hkv<'k, 'v>
          | Multiple of HNode<'k, 'v> array
          | Bucket of Hkv<'k, 'v> array
  
      [<RequireQualifiedAccess>]
      module private HNode =
  
negative.code:                     arr.[idx] <- add hkv earr (dep + 1) entry
                      Multiple arr
      
                  | Gutter _ ->
      
                      // logically should never hit here
                      failwithumf ()
  