anchor.diff:                              else if tokenSet.Tokens.[1].Tokens.Length > 1 || tokenSet.Tokens.[1].Tokens.[0].Token <> OpenCurly then
                                   (name, true, (ParseErrors [|(makeParseError tokens.[1].LineNumber tokens.[1].Tokens.[0].TokenStartLocation tokens.[1].Tokens.[0].TokenEndLocation "Invalid token")|]))
                               else
  -                                let tree = tokenSet.Tokens |> List.skip 2 |> List.take (tokenSet.Tokens.Length - 3) |> parseFunctionInner
  +                                let tree = tokenSet.Tokens |> List.skip 2 |> List.take (tokenSet.Tokens.Length - 3) |> parseSequentialOrChoiceInner (fun a -> ParsedSeq(a, ParsedUnconditional)) []
                                   let hasErrors = match tree with | ParseErrors _ -> true | _ -> false
                                   (name, hasErrors, tree)
                           else if firstLine.[2].Token <> OpenCurly then
                               (name, true, (ParseErrors [|(makeParseError fl.LineNumber firstLine.[2].TokenStartLocation firstLine.[2].TokenEndLocation "Invalid token")|]))
                           else
  -                            let tree = tokenSet.Tokens |> List.skip 1 |> List.take (tokenSet.Tokens.Length - 2) |> parseFunctionInner
  +                            let tree = tokenSet.Tokens |> List.skip 1 |> List.take (tokenSet.Tokens.Length - 2) |> parseSequentialOrChoiceInner (fun a -> ParsedSeq(a, ParsedUnconditional)) []
                               let hasErrors = match tree with | ParseErrors _ -> true | _ -> false
                               (name, hasErrors, tree)
           {   File = tokenSet.File
  
positive.code:     /// - The start of a choice.
      /// - The end of a choice (permits condition).
      /// - Some text (permits condition).
      let rec private parseFunctionInner (tokens:AttributedTokenizedLine list) =
          
          failwith ""
  
      /// Parse the CategorizedAttributedTokenSet for a function definition into a tree.
  
negative.code:         match indices with
          | [] -> [li]
          | h::t -> [(li |> List.take h)]@(listPartition (t |> List.map (fun x -> x - h - 1)) (li |> List.skip (h + 1)))
      let rec private parseSimpleSequentialInner line output tokens =
          match tokens with
          | [] ->
              // Success!
  