anchor.diff:              let firstPos = x.FirstPos.Value
               lastPos |> Set.iter (fun idx -> followPos.[idx] <- Set.union followPos.[idx] firstPos)
               impl x
  -        | Chars _ | End _ -> ()
  +        | Leaf _ -> ()
       impl regex
       followPos.ToImmutableArray()
   
  
positive.code:     LastPos: Lazy<int Set>
  }
  
  type internal RegexBuildLeaves = RegexBuildLeaves of ImmutableArray<obj>
  with
      member x.Length = match x with | RegexBuildLeaves arr -> arr.Length
      member x.Characters idx =
          let (RegexBuildLeaves arr) = x
          match arr.[idx] with
          | :? RegexLeaf as leaf -> leaf.Characters
          | _ -> Set.empty
      member x.TryGetAcceptSymbol idx =
          let (RegexBuildLeaves arr) = x
          match arr.[idx] with
          | :? RegexEnd as leaf -> Some leaf.AcceptSymbol
          | _ -> None
  
  let private fIsNullable =
      function
      | Concat (xs, _) -> xs |> List.forall (fun x -> x.IsNullable.Value)
      | Alt xs -> xs |> List.exists (fun x -> x.IsNullable.Value)
      | Star _ -> true
      // The set of a Chars regex must never be empty; it's just here for completeness.
      | Chars x -> x.Characters.IsEmpty
      // End is the end, so I guess it is nullable.
      | End _ -> true
  
  let private fFirstPos =
      function
  
negative.code:         |> fst
      | Alt xs -> xs |> Seq.map (fun x -> x.LastPos.Value) |> Set.unionMany
      | Star x -> x.LastPos.Value
      | Leaf x -> Set.singleton x.Index
  
  let private makeLazy tree = {
      Tree = tree
  