// ------------------------------------------------------------------------------
//  <auto-generated>
//      This code was generated by Berp (http://https://github.com/gasparnagy/berp/).
// 
//      Changes to this file may cause incorrect behavior and will be lost if
//      the code is regenerated.
//  </auto-generated>
// ------------------------------------------------------------------------------
#region Designer generated code
#pragma warning disable
using System;
using System.Linq;
using System.Collections.Generic;
namespace Gherkin
{
    public enum TokenType
    {
        None,
        EOF,
        Empty,
        Comment,
        TagLine,
        FeatureLine,
        RuleLine,
        BackgroundLine,
        ScenarioLine,
        ExamplesLine,
        StepLine,
        DocStringSeparator,
        TableRow,
        Language,
        Other,
    }

    public enum RuleType
    {
        None,
        _EOF, // #EOF
        _Empty, // #Empty
        _Comment, // #Comment
        _TagLine, // #TagLine
        _FeatureLine, // #FeatureLine
        _RuleLine, // #RuleLine
        _BackgroundLine, // #BackgroundLine
        _ScenarioLine, // #ScenarioLine
        _ExamplesLine, // #ExamplesLine
        _StepLine, // #StepLine
        _DocStringSeparator, // #DocStringSeparator
        _TableRow, // #TableRow
        _Language, // #Language
        _Other, // #Other
        GherkinDocument, // GherkinDocument! := Feature?
        Feature, // Feature! := FeatureHeader Background? ScenarioDefinition* Rule*
        FeatureHeader, // FeatureHeader! := #Language? Tags? #FeatureLine DescriptionHelper
        Rule, // Rule! := RuleHeader Background? ScenarioDefinition*
        RuleHeader, // RuleHeader! := Tags? #RuleLine DescriptionHelper
        Background, // Background! := #BackgroundLine DescriptionHelper Step*
        ScenarioDefinition, // ScenarioDefinition! [#Empty|#Comment|#TagLine->#ScenarioLine] := Tags? Scenario
        Scenario, // Scenario! := #ScenarioLine DescriptionHelper Step* ExamplesDefinition*
        ExamplesDefinition, // ExamplesDefinition! [#Empty|#Comment|#TagLine->#ExamplesLine] := Tags? Examples
        Examples, // Examples! := #ExamplesLine DescriptionHelper ExamplesTable?
        ExamplesTable, // ExamplesTable! := #TableRow #TableRow*
        Step, // Step! := #StepLine StepArg?
        StepArg, // StepArg := (DataTable | DocString)
        DataTable, // DataTable! := #TableRow+
        DocString, // DocString! := #DocStringSeparator #Other* #DocStringSeparator
        Tags, // Tags! := #TagLine+
        DescriptionHelper, // DescriptionHelper := #Empty* Description? #Comment*
        Description, // Description! := #Other+
    }

    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public partial class Parser<T>
    {
        private readonly IAstBuilder<T> astBuilder;

        public Parser()
            : this(new AstBuilder<T>())
        {
        }

        public Parser(IAstBuilder<T> astBuilder)
        {
            this.astBuilder = astBuilder;
        }

        public bool StopAtFirstError { get; set;}

        [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
        protected class ParserContext
        {
            public ITokenScanner TokenScanner { get; set; }
            public ITokenMatcher TokenMatcher { get; set; }
            public Queue<Token> TokenQueue { get; set; }
            public List<ParserException> Errors { get; set; }
        }

        public T Parse(ITokenScanner tokenScanner)
        {
            return Parse(tokenScanner, new TokenMatcher());
        }

        public T Parse(ITokenScanner tokenScanner, ITokenMatcher tokenMatcher)
        {
            tokenMatcher.Reset();
            astBuilder.Reset();
            var context = new ParserContext
            {
                TokenScanner = tokenScanner,
                TokenMatcher = tokenMatcher,
                TokenQueue = new Queue<Token>(),
                Errors = new List<ParserException>()
            };

            StartRule(context, RuleType.GherkinDocument);
            int state = 0;
            Token token;
            do
            {
                token = ReadToken(context);
                state = MatchToken(state, token, context);
            } while(!token.IsEOF);

            EndRule(context, RuleType.GherkinDocument);

            if (context.Errors.Count > 0)
            {
                throw new CompositeParserException(context.Errors.ToArray());
            }

            return GetResult(context);
        }

        private void AddError(ParserContext context, ParserException error)
        {
            if (context.Errors.Any(e => e.Message == error.Message))
                return;
            context.Errors.Add(error);
            if (context.Errors.Count > 10)
                throw new CompositeParserException(context.Errors.ToArray());
        }

        private void HandleAstError(ParserContext context, Action action)
        {
            HandleExternalError(context, () => { action(); return true; });
        }

        private T HandleExternalError<T>(ParserContext context, Func<T> action, T defaultValue = default(T))
        {
            if (StopAtFirstError)
            {
                return action();
            }

            try
            {
                return action();
            }
            catch (CompositeParserException compositeParserException)
            {
                foreach (var error in compositeParserException.Errors)
                    AddError(context, error);
            }
            catch (ParserException error)
            {
                AddError(context, error);
            }
            return defaultValue;
        }

        void Build(ParserContext context, Token token)
        {
            HandleAstError(context, () => this.astBuilder.Build(token));
        }

        void StartRule(ParserContext context, RuleType ruleType)
        {
            HandleAstError(context, () => this.astBuilder.StartRule(ruleType));
        }

        void EndRule(ParserContext context, RuleType ruleType)
        {
            HandleAstError(context, () => this.astBuilder.EndRule(ruleType));
        }

        T GetResult(ParserContext context)
        {
            return this.astBuilder.GetResult();
        }

        Token ReadToken(ParserContext context)
        {
            return context.TokenQueue.Count > 0 ? context.TokenQueue.Dequeue() : context.TokenScanner.Read();
        }


        bool Match_EOF(ParserContext context, Token token)
        {
            return HandleExternalError(context, () => context.TokenMatcher.Match_EOF(token), false); 
        }
        bool Match_Empty(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_Empty(token), false); 
        }
        bool Match_Comment(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_Comment(token), false); 
        }
        bool Match_TagLine(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_TagLine(token), false); 
        }
        bool Match_FeatureLine(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_FeatureLine(token), false); 
        }
        bool Match_RuleLine(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_RuleLine(token), false); 
        }
        bool Match_BackgroundLine(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_BackgroundLine(token), false); 
        }
        bool Match_ScenarioLine(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_ScenarioLine(token), false); 
        }
        bool Match_ExamplesLine(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_ExamplesLine(token), false); 
        }
        bool Match_StepLine(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_StepLine(token), false); 
        }
        bool Match_DocStringSeparator(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_DocStringSeparator(token), false); 
        }
        bool Match_TableRow(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_TableRow(token), false); 
        }
        bool Match_Language(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_Language(token), false); 
        }
        bool Match_Other(ParserContext context, Token token)
        {
            if (token.IsEOF) return false;
            return HandleExternalError(context, () => context.TokenMatcher.Match_Other(token), false); 
        }
        protected virtual int MatchToken(int state, Token token, ParserContext context)
        {
            int newState;
            switch(state)
            {
                case 0:
                    newState = MatchTokenAt_0(token, context);
                    break;
                case 1:
                    newState = MatchTokenAt_1(token, context);
                    break;
                case 2:
                    newState = MatchTokenAt_2(token, context);
                    break;
                case 3:
                    newState = MatchTokenAt_3(token, context);
                    break;
                case 4:
                    newState = MatchTokenAt_4(token, context);
                    break;
                case 5:
                    newState = MatchTokenAt_5(token, context);
                    break;
                case 6:
                    newState = MatchTokenAt_6(token, context);
                    break;
                case 7:
                    newState = MatchTokenAt_7(token, context);
                    break;
                case 8:
                    newState = MatchTokenAt_8(token, context);
                    break;
                case 9:
                    newState = MatchTokenAt_9(token, context);
                    break;
                case 10:
                    newState = MatchTokenAt_10(token, context);
                    break;
                case 11:
                    newState = MatchTokenAt_11(token, context);
                    break;
                case 12:
                    newState = MatchTokenAt_12(token, context);
                    break;
                case 13:
                    newState = MatchTokenAt_13(token, context);
                    break;
                case 14:
                    newState = MatchTokenAt_14(token, context);
                    break;
                case 15:
                    newState = MatchTokenAt_15(token, context);
                    break;
                case 16:
                    newState = MatchTokenAt_16(token, context);
                    break;
                case 17:
                    newState = MatchTokenAt_17(token, context);
                    break;
                case 18:
                    newState = MatchTokenAt_18(token, context);
                    break;
                case 19:
                    newState = MatchTokenAt_19(token, context);
                    break;
                case 20:
                    newState = MatchTokenAt_20(token, context);
                    break;
                case 21:
                    newState = MatchTokenAt_21(token, context);
                    break;
                case 22:
                    newState = MatchTokenAt_22(token, context);
                    break;
                case 23:
                    newState = MatchTokenAt_23(token, context);
                    break;
                case 24:
                    newState = MatchTokenAt_24(token, context);
                    break;
                case 25:
                    newState = MatchTokenAt_25(token, context);
                    break;
                case 26:
                    newState = MatchTokenAt_26(token, context);
                    break;
                case 27:
                    newState = MatchTokenAt_27(token, context);
                    break;
                case 28:
                    newState = MatchTokenAt_28(token, context);
                    break;
                case 29:
                    newState = MatchTokenAt_29(token, context);
                    break;
                case 30:
                    newState = MatchTokenAt_30(token, context);
                    break;
                case 31:
                    newState = MatchTokenAt_31(token, context);
                    break;
                case 32:
                    newState = MatchTokenAt_32(token, context);
                    break;
                case 33:
                    newState = MatchTokenAt_33(token, context);
                    break;
                case 34:
                    newState = MatchTokenAt_34(token, context);
                    break;
                case 35:
                    newState = MatchTokenAt_35(token, context);
                    break;
                case 36:
                    newState = MatchTokenAt_36(token, context);
                    break;
                case 37:
                    newState = MatchTokenAt_37(token, context);
                    break;
                case 38:
                    newState = MatchTokenAt_38(token, context);
                    break;
                case 39:
                    newState = MatchTokenAt_39(token, context);
                    break;
                case 40:
                    newState = MatchTokenAt_40(token, context);
                    break;
                case 41:
                    newState = MatchTokenAt_41(token, context);
                    break;
                case 43:
                    newState = MatchTokenAt_43(token, context);
                    break;
                case 44:
                    newState = MatchTokenAt_44(token, context);
                    break;
                case 45:
                    newState = MatchTokenAt_45(token, context);
                    break;
                case 46:
                    newState = MatchTokenAt_46(token, context);
                    break;
                case 47:
                    newState = MatchTokenAt_47(token, context);
                    break;
                case 48:
                    newState = MatchTokenAt_48(token, context);
                    break;
                case 49:
                    newState = MatchTokenAt_49(token, context);
                    break;
                case 50:
                    newState = MatchTokenAt_50(token, context);
                    break;
                default:
                    throw new InvalidOperationException("Unknown state: " + state);
            }
            return newState;
        }


        // Start
        int MatchTokenAt_0(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                Build(context, token);
                return 42;
            }
            if (Match_Language(context, token))
            {
                StartRule(context, RuleType.Feature);
                StartRule(context, RuleType.FeatureHeader);
                Build(context, token);
                return 1;
            }
            if (Match_TagLine(context, token))
            {
                StartRule(context, RuleType.Feature);
                StartRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 2;
            }
            if (Match_FeatureLine(context, token))
            {
                StartRule(context, RuleType.Feature);
                StartRule(context, RuleType.FeatureHeader);
                Build(context, token);
                return 3;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 0;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 0;
            }

            const string stateComment = "State: 0 - Start";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Language", "#TagLine", "#FeatureLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 0;
        }
        
        // GherkinDocument:0>Feature:0>FeatureHeader:0>#Language:0
        int MatchTokenAt_1(Token token, ParserContext context)
        {
            if (Match_TagLine(context, token))
            {
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 2;
            }
            if (Match_FeatureLine(context, token))
            {
                Build(context, token);
                return 3;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 1;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 1;
            }

            const string stateComment = "State: 1 - GherkinDocument:0>Feature:0>FeatureHeader:0>#Language:0";
            token.Detach();
            var expectedTokens = new string[] {"#TagLine", "#FeatureLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 1;
        }
        
        // GherkinDocument:0>Feature:0>FeatureHeader:1>Tags:0>#TagLine:0
        int MatchTokenAt_2(Token token, ParserContext context)
        {
            if (Match_TagLine(context, token))
            {
                Build(context, token);
                return 2;
            }
            if (Match_FeatureLine(context, token))
            {
                EndRule(context, RuleType.Tags);
                Build(context, token);
                return 3;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 2;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 2;
            }

            const string stateComment = "State: 2 - GherkinDocument:0>Feature:0>FeatureHeader:1>Tags:0>#TagLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#TagLine", "#FeatureLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 2;
        }
        
        // GherkinDocument:0>Feature:0>FeatureHeader:2>#FeatureLine:0
        int MatchTokenAt_3(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 3;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 5;
            }
            if (Match_BackgroundLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Background);
                Build(context, token);
                return 6;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 4;
            }

            const string stateComment = "State: 3 - GherkinDocument:0>Feature:0>FeatureHeader:2>#FeatureLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 3;
        }
        
        // GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_4(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.FeatureHeader);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 5;
            }
            if (Match_BackgroundLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Background);
                Build(context, token);
                return 6;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 4;
            }

            const string stateComment = "State: 4 - GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 4;
        }
        
        // GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_5(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 5;
            }
            if (Match_BackgroundLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Background);
                Build(context, token);
                return 6;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.FeatureHeader);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 5;
            }

            const string stateComment = "State: 5 - GherkinDocument:0>Feature:0>FeatureHeader:3>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 5;
        }
        
        // GherkinDocument:0>Feature:1>Background:0>#BackgroundLine:0
        int MatchTokenAt_6(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 6;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 8;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 9;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 7;
            }

            const string stateComment = "State: 6 - GherkinDocument:0>Feature:1>Background:0>#BackgroundLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 6;
        }
        
        // GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_7(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 8;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 9;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 7;
            }

            const string stateComment = "State: 7 - GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 7;
        }
        
        // GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_8(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 8;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 9;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 8;
            }

            const string stateComment = "State: 8 - GherkinDocument:0>Feature:1>Background:1>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 8;
        }
        
        // GherkinDocument:0>Feature:1>Background:2>Step:0>#StepLine:0
        int MatchTokenAt_9(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.DataTable);
                Build(context, token);
                return 10;
            }
            if (Match_DocStringSeparator(context, token))
            {
                StartRule(context, RuleType.DocString);
                Build(context, token);
                return 49;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 9;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 9;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 9;
            }

            const string stateComment = "State: 9 - GherkinDocument:0>Feature:1>Background:2>Step:0>#StepLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 9;
        }
        
        // GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
        int MatchTokenAt_10(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                Build(context, token);
                return 10;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 9;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 10;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 10;
            }

            const string stateComment = "State: 10 - GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 10;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:0>Tags:0>#TagLine:0
        int MatchTokenAt_11(Token token, ParserContext context)
        {
            if (Match_TagLine(context, token))
            {
                Build(context, token);
                return 11;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Tags);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 11;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 11;
            }

            const string stateComment = "State: 11 - GherkinDocument:0>Feature:2>ScenarioDefinition:0>Tags:0>#TagLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#TagLine", "#ScenarioLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 11;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0
        int MatchTokenAt_12(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 12;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 14;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 15;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 13;
            }

            const string stateComment = "State: 12 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 12;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_13(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 14;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 15;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 13;
            }

            const string stateComment = "State: 13 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 13;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_14(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 14;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 15;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 14;
            }

            const string stateComment = "State: 14 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 14;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0
        int MatchTokenAt_15(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.DataTable);
                Build(context, token);
                return 16;
            }
            if (Match_DocStringSeparator(context, token))
            {
                StartRule(context, RuleType.DocString);
                Build(context, token);
                return 47;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 15;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 15;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 15;
            }

            const string stateComment = "State: 15 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 15;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
        int MatchTokenAt_16(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                Build(context, token);
                return 16;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 15;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 16;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 16;
            }

            const string stateComment = "State: 16 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 16;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0
        int MatchTokenAt_17(Token token, ParserContext context)
        {
            if (Match_TagLine(context, token))
            {
                Build(context, token);
                return 17;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Tags);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 17;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 17;
            }

            const string stateComment = "State: 17 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#TagLine", "#ExamplesLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 17;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0
        int MatchTokenAt_18(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 18;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 20;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.ExamplesTable);
                Build(context, token);
                return 21;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 19;
            }

            const string stateComment = "State: 18 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 18;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_19(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 20;
            }
            if (Match_TableRow(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.ExamplesTable);
                Build(context, token);
                return 21;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 19;
            }

            const string stateComment = "State: 19 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 19;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_20(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 20;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.ExamplesTable);
                Build(context, token);
                return 21;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 20;
            }

            const string stateComment = "State: 20 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 20;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0
        int MatchTokenAt_21(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                Build(context, token);
                return 21;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 21;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 21;
            }

            const string stateComment = "State: 21 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 21;
        }
        
        // GherkinDocument:0>Feature:3>Rule:0>RuleHeader:0>Tags:0>#TagLine:0
        int MatchTokenAt_22(Token token, ParserContext context)
        {
            if (Match_TagLine(context, token))
            {
                Build(context, token);
                return 22;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Tags);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 22;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 22;
            }

            const string stateComment = "State: 22 - GherkinDocument:0>Feature:3>Rule:0>RuleHeader:0>Tags:0>#TagLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#TagLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 22;
        }
        
        // GherkinDocument:0>Feature:3>Rule:0>RuleHeader:1>#RuleLine:0
        int MatchTokenAt_23(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 25;
            }
            if (Match_BackgroundLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Background);
                Build(context, token);
                return 26;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 24;
            }

            const string stateComment = "State: 23 - GherkinDocument:0>Feature:3>Rule:0>RuleHeader:1>#RuleLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 23;
        }
        
        // GherkinDocument:0>Feature:3>Rule:0>RuleHeader:2>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_24(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 25;
            }
            if (Match_BackgroundLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Background);
                Build(context, token);
                return 26;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 24;
            }

            const string stateComment = "State: 24 - GherkinDocument:0>Feature:3>Rule:0>RuleHeader:2>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 24;
        }
        
        // GherkinDocument:0>Feature:3>Rule:0>RuleHeader:2>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_25(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 25;
            }
            if (Match_BackgroundLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Background);
                Build(context, token);
                return 26;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.RuleHeader);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 25;
            }

            const string stateComment = "State: 25 - GherkinDocument:0>Feature:3>Rule:0>RuleHeader:2>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#BackgroundLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 25;
        }
        
        // GherkinDocument:0>Feature:3>Rule:1>Background:0>#BackgroundLine:0
        int MatchTokenAt_26(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 26;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 28;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 29;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 27;
            }

            const string stateComment = "State: 26 - GherkinDocument:0>Feature:3>Rule:1>Background:0>#BackgroundLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 26;
        }
        
        // GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_27(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 28;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 29;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 27;
            }

            const string stateComment = "State: 27 - GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 27;
        }
        
        // GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_28(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 28;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 29;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 28;
            }

            const string stateComment = "State: 28 - GherkinDocument:0>Feature:3>Rule:1>Background:1>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 28;
        }
        
        // GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:0>#StepLine:0
        int MatchTokenAt_29(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.DataTable);
                Build(context, token);
                return 30;
            }
            if (Match_DocStringSeparator(context, token))
            {
                StartRule(context, RuleType.DocString);
                Build(context, token);
                return 45;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 29;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 29;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 29;
            }

            const string stateComment = "State: 29 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:0>#StepLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 29;
        }
        
        // GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
        int MatchTokenAt_30(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                Build(context, token);
                return 30;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 29;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 30;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 30;
            }

            const string stateComment = "State: 30 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 30;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:0>Tags:0>#TagLine:0
        int MatchTokenAt_31(Token token, ParserContext context)
        {
            if (Match_TagLine(context, token))
            {
                Build(context, token);
                return 31;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Tags);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 31;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 31;
            }

            const string stateComment = "State: 31 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:0>Tags:0>#TagLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#TagLine", "#ScenarioLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 31;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0
        int MatchTokenAt_32(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 32;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 34;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 35;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 33;
            }

            const string stateComment = "State: 32 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:0>#ScenarioLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 32;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_33(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 34;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 35;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 33;
            }

            const string stateComment = "State: 33 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 33;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_34(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 34;
            }
            if (Match_StepLine(context, token))
            {
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 35;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 34;
            }

            const string stateComment = "State: 34 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:1>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 34;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0
        int MatchTokenAt_35(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.DataTable);
                Build(context, token);
                return 36;
            }
            if (Match_DocStringSeparator(context, token))
            {
                StartRule(context, RuleType.DocString);
                Build(context, token);
                return 43;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 35;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 35;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 35;
            }

            const string stateComment = "State: 35 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:0>#StepLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#DocStringSeparator", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 35;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0
        int MatchTokenAt_36(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                Build(context, token);
                return 36;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 35;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DataTable);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 36;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 36;
            }

            const string stateComment = "State: 36 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:0>DataTable:0>#TableRow:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 36;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0
        int MatchTokenAt_37(Token token, ParserContext context)
        {
            if (Match_TagLine(context, token))
            {
                Build(context, token);
                return 37;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Tags);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 37;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 37;
            }

            const string stateComment = "State: 37 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:0>Tags:0>#TagLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#TagLine", "#ExamplesLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 37;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0
        int MatchTokenAt_38(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 38;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 40;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.ExamplesTable);
                Build(context, token);
                return 41;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                StartRule(context, RuleType.Description);
                Build(context, token);
                return 39;
            }

            const string stateComment = "State: 38 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:0>#ExamplesLine:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Empty", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 38;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0
        int MatchTokenAt_39(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                EndRule(context, RuleType.Description);
                Build(context, token);
                return 40;
            }
            if (Match_TableRow(context, token))
            {
                EndRule(context, RuleType.Description);
                StartRule(context, RuleType.ExamplesTable);
                Build(context, token);
                return 41;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Description);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 39;
            }

            const string stateComment = "State: 39 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:1>Description:0>#Other:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 39;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0
        int MatchTokenAt_40(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 40;
            }
            if (Match_TableRow(context, token))
            {
                StartRule(context, RuleType.ExamplesTable);
                Build(context, token);
                return 41;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 40;
            }

            const string stateComment = "State: 40 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:1>DescriptionHelper:2>#Comment:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#Comment", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 40;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0
        int MatchTokenAt_41(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_TableRow(context, token))
            {
                Build(context, token);
                return 41;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.ExamplesTable);
                EndRule(context, RuleType.Examples);
                EndRule(context, RuleType.ExamplesDefinition);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 41;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 41;
            }

            const string stateComment = "State: 41 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:3>ExamplesDefinition:1>Examples:2>ExamplesTable:0>#TableRow:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#TableRow", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 41;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
        int MatchTokenAt_43(Token token, ParserContext context)
        {
            if (Match_DocStringSeparator(context, token))
            {
                Build(context, token);
                return 44;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 43;
            }

            const string stateComment = "State: 43 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#DocStringSeparator", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 43;
        }
        
        // GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
        int MatchTokenAt_44(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 35;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 37;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 38;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 44;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 44;
            }

            const string stateComment = "State: 44 - GherkinDocument:0>Feature:3>Rule:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 44;
        }
        
        // GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
        int MatchTokenAt_45(Token token, ParserContext context)
        {
            if (Match_DocStringSeparator(context, token))
            {
                Build(context, token);
                return 46;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 45;
            }

            const string stateComment = "State: 45 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#DocStringSeparator", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 45;
        }
        
        // GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
        int MatchTokenAt_46(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 29;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 31;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 32;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Rule);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 46;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 46;
            }

            const string stateComment = "State: 46 - GherkinDocument:0>Feature:3>Rule:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 46;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
        int MatchTokenAt_47(Token token, ParserContext context)
        {
            if (Match_DocStringSeparator(context, token))
            {
                Build(context, token);
                return 48;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 47;
            }

            const string stateComment = "State: 47 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#DocStringSeparator", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 47;
        }
        
        // GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
        int MatchTokenAt_48(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 15;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_1(context, token))
                {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 17;
                }
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ExamplesLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.ExamplesDefinition);
                StartRule(context, RuleType.Examples);
                Build(context, token);
                return 18;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Scenario);
                EndRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 48;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 48;
            }

            const string stateComment = "State: 48 - GherkinDocument:0>Feature:2>ScenarioDefinition:1>Scenario:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#StepLine", "#TagLine", "#ExamplesLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 48;
        }
        
        // GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0
        int MatchTokenAt_49(Token token, ParserContext context)
        {
            if (Match_DocStringSeparator(context, token))
            {
                Build(context, token);
                return 50;
            }
            if (Match_Other(context, token))
            {
                Build(context, token);
                return 49;
            }

            const string stateComment = "State: 49 - GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:0>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#DocStringSeparator", "#Other"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 49;
        }
        
        // GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0
        int MatchTokenAt_50(Token token, ParserContext context)
        {
            if (Match_EOF(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                EndRule(context, RuleType.Feature);
                Build(context, token);
                return 42;
            }
            if (Match_StepLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                StartRule(context, RuleType.Step);
                Build(context, token);
                return 9;
            }
            if (Match_TagLine(context, token))
            {
                if (LookAhead_0(context, token))
                {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 11;
                }
            }
            if (Match_TagLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                StartRule(context, RuleType.Tags);
                Build(context, token);
                return 22;
            }
            if (Match_ScenarioLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.ScenarioDefinition);
                StartRule(context, RuleType.Scenario);
                Build(context, token);
                return 12;
            }
            if (Match_RuleLine(context, token))
            {
                EndRule(context, RuleType.DocString);
                EndRule(context, RuleType.Step);
                EndRule(context, RuleType.Background);
                StartRule(context, RuleType.Rule);
                StartRule(context, RuleType.RuleHeader);
                Build(context, token);
                return 23;
            }
            if (Match_Comment(context, token))
            {
                Build(context, token);
                return 50;
            }
            if (Match_Empty(context, token))
            {
                Build(context, token);
                return 50;
            }

            const string stateComment = "State: 50 - GherkinDocument:0>Feature:1>Background:2>Step:1>StepArg:0>__alt0:1>DocString:2>#DocStringSeparator:0";
            token.Detach();
            var expectedTokens = new string[] {"#EOF", "#StepLine", "#TagLine", "#ScenarioLine", "#RuleLine", "#Comment", "#Empty"};
            var error = token.IsEOF ? (ParserException)new UnexpectedEOFException(token, expectedTokens, stateComment) 
                : new UnexpectedTokenException(token, expectedTokens, stateComment);
            if (StopAtFirstError)
                throw error;
            
            AddError(context, error);
            return 50;
        }
        

        bool LookAhead_0(ParserContext context, Token currentToken)
        {
            currentToken.Detach();
            Token token;
            var queue = new Queue<Token>();
            bool match = false;
            do
            {
                token = ReadToken(context);
                token.Detach();
                queue.Enqueue(token);

                if (false
                    || Match_ScenarioLine(context, token)
)
                {
                    match = true;
                    break;
                }
            } while (false
                || Match_Empty(context, token)
                || Match_Comment(context, token)
                || Match_TagLine(context, token)
);
            foreach(var t in queue)
                context.TokenQueue.Enqueue(t);
            return match;
        }
        
        bool LookAhead_1(ParserContext context, Token currentToken)
        {
            currentToken.Detach();
            Token token;
            var queue = new Queue<Token>();
            bool match = false;
            do
            {
                token = ReadToken(context);
                token.Detach();
                queue.Enqueue(token);

                if (false
                    || Match_ExamplesLine(context, token)
)
                {
                    match = true;
                    break;
                }
            } while (false
                || Match_Empty(context, token)
                || Match_Comment(context, token)
                || Match_TagLine(context, token)
);
            foreach(var t in queue)
                context.TokenQueue.Enqueue(t);
            return match;
        }
            }

    public partial interface IAstBuilder<T> 
    {
        void Build(Token token);
        void StartRule(RuleType ruleType);
        void EndRule(RuleType ruleType);
        T GetResult();
        void Reset();
    }

    public partial interface ITokenScanner 
    {
        Token Read();
    }

    public partial interface ITokenMatcher
    {
        bool Match_EOF(Token token);
        bool Match_Empty(Token token);
        bool Match_Comment(Token token);
        bool Match_TagLine(Token token);
        bool Match_FeatureLine(Token token);
        bool Match_RuleLine(Token token);
        bool Match_BackgroundLine(Token token);
        bool Match_ScenarioLine(Token token);
        bool Match_ExamplesLine(Token token);
        bool Match_StepLine(Token token);
        bool Match_DocStringSeparator(Token token);
        bool Match_TableRow(Token token);
        bool Match_Language(Token token);
        bool Match_Other(Token token);
        void Reset();
    }
}
#pragma warning restore
#endregion
