anchor.diff:          | Br (_,_,_,_) as t ->
               let action = FSharpFunc<_,_,_>.Adapt action
   
  -            // TODO : Run some experiments to determine if this is a good initial capacity,
  -            // or if there is a more suitable value.
  -            let stack = System.Collections.Generic.Stack (64)
  +            /// The stack of trie nodes pending traversal.
  +            let stack = Stack (defaultTraversalStackSize)
   
               // Add the initial tree to the stack.
               stack.Push t
  
positive.code:         | Br (_,_,_,_) as t ->
              let predicate = FSharpFunc<_,_,_>.Adapt predicate
  
              // TODO : Run some experiments to determine if this is a good initial capacity,
              // or if there is a more suitable value.
              let stack = System.Collections.Generic.Stack (64)
  
              // Add the initial tree to the stack.
              stack.Push t
  
negative.code:     let inline matchPrefix (k : ^T, p, m) =
          mask (k, m) = p
  
  //    //
  //    let inline leastSignificantSetBit (x : uint32) : uint32 =
  //        x &&& (uint32 -(int x))
  
      // http://aggregate.org/MAGIC/#Most%20Significant%201%20Bit
      // OPTIMIZE : This could be even faster if we could take advantage of a built-in
      // CPU instruction here (such as 'bsr', 'ffs', or 'clz').
      // Could we expose these instructions through Mono?
      let inline private mostSignificantSetBit (x : uint32) =
          let x = x ||| (x >>> 1)
          let x = x ||| (x >>> 2)
          let x = x ||| (x >>> 4)
  