text:
using System;
using System.Collections.Generic;
namespace BerpGherkinParser
{
	public enum TokenType
	{
		None,
EOF,
Empty,
Comment,
TagLine,
Feature,
Background,
Scenario,
ScenarioOutline,
Examples,
Step,
MultiLineArgument,
TableRow,
Other,
	}

	public enum RuleType
	{
		None,
_EOF, // #EOF
_Empty, // #Empty
_Comment, // #Comment
_TagLine, // #TagLine
_Feature, // #Feature
_Background, // #Background
_Scenario, // #Scenario
_ScenarioOutline, // #ScenarioOutline
_Examples, // #Examples
_Step, // #Step
_MultiLineArgument, // #MultiLineArgument
_TableRow, // #TableRow
_Other, // #Other
Feature_File, // Feature_File! := Feature_Def Background? Scenario_Base*
Feature_Def, // Feature_Def! := #TagLine* #Feature Feature_Description
Background, // Background! := #Background Background_Description Scenario_Step*
Scenario_Base, // Scenario_Base! := #TagLine* Scenario_Base_Body
Scenario_Base_Body, // Scenario_Base_Body := (Scenario | ScenarioOutline)
Scenario, // Scenario! := #Scenario Scenario_Description Scenario_Step*
ScenarioOutline, // ScenarioOutline! := #ScenarioOutline ScenarioOutline_Description ScenarioOutline_Step* Examples+
Examples, // Examples! := #TagLine[#Empty|#Comment|#TagLine->#Examples]* #Examples Examples_Description Examples_Table
Examples_Table, // Examples_Table! := #TableRow+
Scenario_Step, // Scenario_Step := Step
ScenarioOutline_Step, // ScenarioOutline_Step := Step
Step, // Step! := #Step Step_Arg?
Step_Arg, // Step_Arg := (Table_And_Multiline_Arg | Multiline_And_Table_Arg)
Table_And_Multiline_Arg, // Table_And_Multiline_Arg := Table_Arg Multiline_Arg?
Multiline_And_Table_Arg, // Multiline_And_Table_Arg := Multiline_Arg Table_Arg?
Table_Arg, // Table_Arg! := #TableRow+
Multiline_Arg, // Multiline_Arg! := #MultiLineArgument Multiline_Arg_Line* #MultiLineArgument
Multiline_Arg_Line, // Multiline_Arg_Line := (#Empty | #Other)
Feature_Description, // Feature_Description := Description_Helper
Background_Description, // Background_Description := Description_Helper
Scenario_Description, // Scenario_Description := Description_Helper
ScenarioOutline_Description, // ScenarioOutline_Description := Description_Helper
Examples_Description, // Examples_Description := Description_Helper
Description_Helper, // Description_Helper := Description? #Comment*
Description, // Description! := Description_Line+
Description_Line, // Description_Line := (#Empty | #Other)
	}

    public partial class ParserError
    {
        public string StateComment { get; private set; }

        public Token ReceivedToken { get; private set; }
        public string[] ExpectedTokenTypes { get; private set; }

        public ParserError(Token receivedToken, string[] expectedTokenTypes, string stateComment)
        {
            this.ReceivedToken = receivedToken;
            this.ExpectedTokenTypes = expectedTokenTypes;
            this.StateComment = stateComment;
        }
    }

    public partial class ParserException : Exception
    {
        private ParserError[] errors = new ParserError[0];

        public ParserError[] Errors { get { return errors; } }

        public ParserException() { }
        public ParserException(string message) : base(message) { }
        public ParserException(string message, Exception inner) : base(message, inner) { }

        public ParserException(ParserMessageProvider messageProvider, params ParserError[] errors)
			: base(messageProvider.GetDefaultExceptionMessage(errors))
        {
            if (errors != null)
                this.errors = errors;
        }
    }

    public class Parser
    {
		public bool StopAtFirstError { get; set;}
		public ParserMessageProvider ParserMessageProvider { get; private set; }

		class ParserContext
		{
			public TokenScanner TokenScanner { get; set; }
			public TokenMatcher TokenMatcher { get; set; }
			public AstBuilder Builder { get; set; }
			public Queue<Token> TokenQueue { get; set; }
			public List<ParserError> Errors { get; set; }
		}

		public Parser() : this(new ParserMessageProvider())
		{
		}

		public object Parse(TokenScanner tokenScanner)
		{
			return Parse(tokenScanner, new TokenMatcher(), new AstBuilder());
		}

		public Parser(ParserMessageProvider parserMessageProvider)
		{
			this.ParserMessageProvider = parserMessageProvider;
		}

        public object Parse(TokenScanner tokenScanner, TokenMatcher tokenMatcher, AstBuilder astBuilder)
		{
			var context = new ParserContext
			{
				TokenScanner = tokenScanner,
				TokenMatcher = tokenMatcher,
				Builder = astBuilder,
				TokenQueue = new Queue<Token>(),
				Errors = new List<ParserError>()
			};

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

			if (context.Errors.Count > 0)
			{
				throw new ParserException(ParserMessageProvider, context.Errors.ToArray());
			}

			if (state != 32)
			{
				throw new InvalidOperationException("One of the grammar rules expected #EOF explicitly.");
			}

			EndRule(context, RuleType.Feature_File);
			return GetResult(context);
		}

		void Build(ParserContext context, Token token)
		{
			context.Builder.Build(token);
		}

		void StartRule(ParserContext context, RuleType ruleType)
		{
			context.Builder.StartRule(ruleType);
		}

		void EndRule(ParserContext context, RuleType ruleType)
		{
			context.Builder.EndRule(ruleType);
		}

		object GetResult(ParserContext context)
		{
			return context.Builder.GetResult();
		}

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

		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 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;
				default:
					throw new InvalidOperationException("Unknown state: " + state);
			}
			return newState;
		}

		// Start
		int MatchTokenAt_0(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				StartRule(context, RuleType.Feature_Def);
				Build(context, token);
				return 1;
			}
			if (	context.TokenMatcher.Match_Feature(token)
)
			{
				StartRule(context, RuleType.Feature_Def);
				Build(context, token);
				return 2;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 0;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 0;
			}
				var error = new ParserError(token, new string[] {"#TagLine", "#Feature", "#Comment", "#Empty"}, "State: 0 - Start");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 0;

		}

		// Feature_File:0>Feature_Def:0>#TagLine:0
		int MatchTokenAt_1(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				Build(context, token);
				return 1;
			}
			if (	context.TokenMatcher.Match_Feature(token)
)
			{
				Build(context, token);
				return 2;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 1;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 1;
			}
				var error = new ParserError(token, new string[] {"#TagLine", "#Feature", "#Comment", "#Empty"}, "State: 1 - Feature_File:0>Feature_Def:0>#TagLine:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 1;

		}

		// Feature_File:0>Feature_Def:1>#Feature:0
		int MatchTokenAt_2(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 3;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 4;
			}
			if (	context.TokenMatcher.Match_Background(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Background);
				Build(context, token);
				return 5;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 3;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Empty", "#Comment", "#Background", "#TagLine", "#Scenario", "#ScenarioOutline", "#Other"}, "State: 2 - Feature_File:0>Feature_Def:1>#Feature:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 2;

		}

		// Feature_File:0>Feature_Def:2>Feature_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0
		int MatchTokenAt_3(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Feature_Def);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 3;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				EndRule(context, RuleType.Description);
				Build(context, token);
				return 4;
			}
			if (	context.TokenMatcher.Match_Background(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Background);
				Build(context, token);
				return 5;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 3;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Empty", "#Comment", "#Background", "#TagLine", "#Scenario", "#ScenarioOutline", "#Other"}, "State: 3 - Feature_File:0>Feature_Def:2>Feature_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 3;

		}

		// Feature_File:0>Feature_Def:2>Feature_Description:0>Description_Helper:1>#Comment:0
		int MatchTokenAt_4(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 4;
			}
			if (	context.TokenMatcher.Match_Background(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Background);
				Build(context, token);
				return 5;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Feature_Def);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 4;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Comment", "#Background", "#TagLine", "#Scenario", "#ScenarioOutline", "#Empty"}, "State: 4 - Feature_File:0>Feature_Def:2>Feature_Description:0>Description_Helper:1>#Comment:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 4;

		}

		// Feature_File:1>Background:0>#Background:0
		int MatchTokenAt_5(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 6;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 7;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 6;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Empty", "#Comment", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Other"}, "State: 5 - Feature_File:1>Background:0>#Background:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 5;

		}

		// Feature_File:1>Background:1>Background_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0
		int MatchTokenAt_6(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 6;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				EndRule(context, RuleType.Description);
				Build(context, token);
				return 7;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Description);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 6;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Empty", "#Comment", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Other"}, "State: 6 - Feature_File:1>Background:1>Background_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 6;

		}

		// Feature_File:1>Background:1>Background_Description:0>Description_Helper:1>#Comment:0
		int MatchTokenAt_7(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 7;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 7;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Comment", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Empty"}, "State: 7 - Feature_File:1>Background:1>Background_Description:0>Description_Helper:1>#Comment:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 7;

		}

		// Feature_File:1>Background:2>Scenario_Step:0>Step:0>#Step:0
		int MatchTokenAt_8(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				StartRule(context, RuleType.Table_Arg);
				Build(context, token);
				return 9;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				StartRule(context, RuleType.Multiline_Arg);
				Build(context, token);
				return 39;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 8;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#MultiLineArgument", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 8 - Feature_File:1>Background:2>Scenario_Step:0>Step:0>#Step:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 8;

		}

		// Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:0>Table_Arg:0>#TableRow:0
		int MatchTokenAt_9(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				Build(context, token);
				return 9;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				StartRule(context, RuleType.Multiline_Arg);
				Build(context, token);
				return 10;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 9;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 9;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#MultiLineArgument", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 9 - Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:0>Table_Arg:0>#TableRow:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 9;

		}

		// Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:0>#MultiLineArgument:0
		int MatchTokenAt_10(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 10;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				Build(context, token);
				return 11;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 10;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#MultiLineArgument", "#Other"}, "State: 10 - Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:0>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 10;

		}

		// Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:2>#MultiLineArgument:0
		int MatchTokenAt_11(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 11;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 11;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 11 - Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:2>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 11;

		}

		// Feature_File:2>Scenario_Base:0>#TagLine:0
		int MatchTokenAt_12(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 12;
			}
				var error = new ParserError(token, new string[] {"#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 12 - Feature_File:2>Scenario_Base:0>#TagLine:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 12;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:0>#Scenario:0
		int MatchTokenAt_13(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 14;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 15;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 14;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Empty", "#Comment", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Other"}, "State: 13 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:0>#Scenario:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 13;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0
		int MatchTokenAt_14(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 14;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				EndRule(context, RuleType.Description);
				Build(context, token);
				return 15;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Description);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Description);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 14;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Empty", "#Comment", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Other"}, "State: 14 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 14;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>#Comment:0
		int MatchTokenAt_15(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 15;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 15;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Comment", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Empty"}, "State: 15 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:1>Scenario_Description:0>Description_Helper:1>#Comment:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 15;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#Step:0
		int MatchTokenAt_16(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				StartRule(context, RuleType.Table_Arg);
				Build(context, token);
				return 17;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				StartRule(context, RuleType.Multiline_Arg);
				Build(context, token);
				return 36;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 16;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#MultiLineArgument", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 16 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:0>#Step:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 16;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:0>Table_Arg:0>#TableRow:0
		int MatchTokenAt_17(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				Build(context, token);
				return 17;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				StartRule(context, RuleType.Multiline_Arg);
				Build(context, token);
				return 18;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 17;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 17;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#MultiLineArgument", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 17 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:0>Table_Arg:0>#TableRow:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 17;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:0>#MultiLineArgument:0
		int MatchTokenAt_18(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 18;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				Build(context, token);
				return 19;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 18;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#MultiLineArgument", "#Other"}, "State: 18 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:0>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 18;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:2>#MultiLineArgument:0
		int MatchTokenAt_19(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 19;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 19;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 19 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:2>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 19;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:0>#ScenarioOutline:0
		int MatchTokenAt_20(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 21;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 22;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 21;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#Comment", "#Step", "#TagLine", "#Examples", "#Other"}, "State: 20 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:0>#ScenarioOutline:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 20;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0
		int MatchTokenAt_21(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 21;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				EndRule(context, RuleType.Description);
				Build(context, token);
				return 22;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Description);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Description);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				EndRule(context, RuleType.Description);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 21;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#Comment", "#Step", "#TagLine", "#Examples", "#Other"}, "State: 21 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 21;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>#Comment:0
		int MatchTokenAt_22(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 22;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 22;
			}
				var error = new ParserError(token, new string[] {"#Comment", "#Step", "#TagLine", "#Examples", "#Empty"}, "State: 22 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:1>ScenarioOutline_Description:0>Description_Helper:1>#Comment:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 22;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#Step:0
		int MatchTokenAt_23(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				StartRule(context, RuleType.Table_Arg);
				Build(context, token);
				return 24;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				StartRule(context, RuleType.Multiline_Arg);
				Build(context, token);
				return 33;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 23;
			}
				var error = new ParserError(token, new string[] {"#TableRow", "#MultiLineArgument", "#Step", "#TagLine", "#Examples", "#Comment", "#Empty"}, "State: 23 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:0>#Step:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 23;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:0>Table_Arg:0>#TableRow:0
		int MatchTokenAt_24(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				Build(context, token);
				return 24;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				StartRule(context, RuleType.Multiline_Arg);
				Build(context, token);
				return 25;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 24;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 24;
			}
				var error = new ParserError(token, new string[] {"#TableRow", "#MultiLineArgument", "#Step", "#TagLine", "#Examples", "#Comment", "#Empty"}, "State: 24 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:0>Table_Arg:0>#TableRow:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 24;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:0>#MultiLineArgument:0
		int MatchTokenAt_25(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 25;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				Build(context, token);
				return 26;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 25;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#MultiLineArgument", "#Other"}, "State: 25 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:0>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 25;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:2>#MultiLineArgument:0
		int MatchTokenAt_26(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 26;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 26;
			}
				var error = new ParserError(token, new string[] {"#Step", "#TagLine", "#Examples", "#Comment", "#Empty"}, "State: 26 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:0>Table_And_Multiline_Arg:1>Multiline_Arg:2>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 26;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:0>#TagLine:0
		int MatchTokenAt_27(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 27;
			}
				var error = new ParserError(token, new string[] {"#TagLine", "#Examples", "#Comment", "#Empty"}, "State: 27 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:0>#TagLine:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 27;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:1>#Examples:0
		int MatchTokenAt_28(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 29;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 30;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				StartRule(context, RuleType.Examples_Table);
				Build(context, token);
				return 31;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				StartRule(context, RuleType.Description);
				Build(context, token);
				return 29;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#Comment", "#TableRow", "#Other"}, "State: 28 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:1>#Examples:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 28;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0
		int MatchTokenAt_29(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 29;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				EndRule(context, RuleType.Description);
				Build(context, token);
				return 30;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				EndRule(context, RuleType.Description);
				StartRule(context, RuleType.Examples_Table);
				Build(context, token);
				return 31;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 29;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#Comment", "#TableRow", "#Other"}, "State: 29 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:0>Description:0>Description_Line:0>__alt3:0>#Empty:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 29;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>#Comment:0
		int MatchTokenAt_30(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 30;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				StartRule(context, RuleType.Examples_Table);
				Build(context, token);
				return 31;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 30;
			}
				var error = new ParserError(token, new string[] {"#Comment", "#TableRow", "#Empty"}, "State: 30 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:2>Examples_Description:0>Description_Helper:1>#Comment:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 30;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0
		int MatchTokenAt_31(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Examples_Table);
				EndRule(context, RuleType.Examples);
				EndRule(context, RuleType.ScenarioOutline);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				Build(context, token);
				return 31;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				if (LookAhead_0(context, token))
				{
				EndRule(context, RuleType.Examples_Table);
				EndRule(context, RuleType.Examples);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
				}
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Examples_Table);
				EndRule(context, RuleType.Examples);
				EndRule(context, RuleType.ScenarioOutline);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				EndRule(context, RuleType.Examples_Table);
				EndRule(context, RuleType.Examples);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Examples_Table);
				EndRule(context, RuleType.Examples);
				EndRule(context, RuleType.ScenarioOutline);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Examples_Table);
				EndRule(context, RuleType.Examples);
				EndRule(context, RuleType.ScenarioOutline);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 31;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 31;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#TagLine", "#Examples", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 31 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:3>Examples:3>Examples_Table:0>#TableRow:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 31;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:0>#MultiLineArgument:0
		int MatchTokenAt_33(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 33;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				Build(context, token);
				return 34;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 33;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#MultiLineArgument", "#Other"}, "State: 33 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:0>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 33;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:2>#MultiLineArgument:0
		int MatchTokenAt_34(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				StartRule(context, RuleType.Table_Arg);
				Build(context, token);
				return 35;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 34;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 34;
			}
				var error = new ParserError(token, new string[] {"#TableRow", "#Step", "#TagLine", "#Examples", "#Comment", "#Empty"}, "State: 34 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:2>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 34;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:1>Table_Arg:0>#TableRow:0
		int MatchTokenAt_35(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				Build(context, token);
				return 35;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 23;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 27;
			}
			if (	context.TokenMatcher.Match_Examples(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Examples);
				Build(context, token);
				return 28;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 35;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 35;
			}
				var error = new ParserError(token, new string[] {"#TableRow", "#Step", "#TagLine", "#Examples", "#Comment", "#Empty"}, "State: 35 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:1>ScenarioOutline:2>ScenarioOutline_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:1>Table_Arg:0>#TableRow:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 35;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:0>#MultiLineArgument:0
		int MatchTokenAt_36(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 36;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				Build(context, token);
				return 37;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 36;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#MultiLineArgument", "#Other"}, "State: 36 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:0>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 36;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:2>#MultiLineArgument:0
		int MatchTokenAt_37(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				StartRule(context, RuleType.Table_Arg);
				Build(context, token);
				return 38;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 37;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 37;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 37 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:2>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 37;

		}

		// Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:1>Table_Arg:0>#TableRow:0
		int MatchTokenAt_38(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				Build(context, token);
				return 38;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 16;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Scenario);
				EndRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 38;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 38;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 38 - Feature_File:2>Scenario_Base:1>Scenario_Base_Body:0>__alt0:0>Scenario:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:1>Table_Arg:0>#TableRow:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 38;

		}

		// Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:0>#MultiLineArgument:0
		int MatchTokenAt_39(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 39;
			}
			if (	context.TokenMatcher.Match_MultiLineArgument(token)
)
			{
				Build(context, token);
				return 40;
			}
			if (	context.TokenMatcher.Match_Other(token)
)
			{
				Build(context, token);
				return 39;
			}
				var error = new ParserError(token, new string[] {"#Empty", "#MultiLineArgument", "#Other"}, "State: 39 - Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:0>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 39;

		}

		// Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:2>#MultiLineArgument:0
		int MatchTokenAt_40(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				StartRule(context, RuleType.Table_Arg);
				Build(context, token);
				return 41;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Multiline_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 40;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 40;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 40 - Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:0>Multiline_Arg:2>#MultiLineArgument:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 40;

		}

		// Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:1>Table_Arg:0>#TableRow:0
		int MatchTokenAt_41(Token token, ParserContext context)
		{
			if (	context.TokenMatcher.Match_EOF(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				Build(context, token);
				return 32;
			}
			if (	context.TokenMatcher.Match_TableRow(token)
)
			{
				Build(context, token);
				return 41;
			}
			if (	context.TokenMatcher.Match_Step(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				StartRule(context, RuleType.Step);
				Build(context, token);
				return 8;
			}
			if (	context.TokenMatcher.Match_TagLine(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				Build(context, token);
				return 12;
			}
			if (	context.TokenMatcher.Match_Scenario(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.Scenario);
				Build(context, token);
				return 13;
			}
			if (	context.TokenMatcher.Match_ScenarioOutline(token)
)
			{
				EndRule(context, RuleType.Table_Arg);
				EndRule(context, RuleType.Step);
				EndRule(context, RuleType.Background);
				StartRule(context, RuleType.Scenario_Base);
				StartRule(context, RuleType.ScenarioOutline);
				Build(context, token);
				return 20;
			}
			if (	context.TokenMatcher.Match_Comment(token)
)
			{
				Build(context, token);
				return 41;
			}
			if (	context.TokenMatcher.Match_Empty(token)
)
			{
				Build(context, token);
				return 41;
			}
				var error = new ParserError(token, new string[] {"#EOF", "#TableRow", "#Step", "#TagLine", "#Scenario", "#ScenarioOutline", "#Comment", "#Empty"}, "State: 41 - Feature_File:1>Background:2>Scenario_Step:0>Step:1>Step_Arg:0>__alt1:1>Multiline_And_Table_Arg:1>Table_Arg:0>#TableRow:0");
	if (StopAtFirstError)
		throw new ParserException(ParserMessageProvider, error);
	context.Errors.Add(error);
	return 41;

		}

		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
					|| 	context.TokenMatcher.Match_Examples(token)

				)
		        {
					match = true;
					break;
		        }
		    } while (false
				|| 	context.TokenMatcher.Match_Empty(token)

				|| 	context.TokenMatcher.Match_Comment(token)

				|| 	context.TokenMatcher.Match_TagLine(token)

			);
			foreach(var t in queue)
				context.TokenQueue.Enqueue(t);
			return match;
		}

	}
}

redpajama_set_name: RedPajamaGithub


Tire Pressure Monitoring Systems (TPMS) are mandated in many countries due to their impact to inform drivers on vehicle safety and fuel efficiency. It has been shown that under-inflated tires can lead to less control of the vehicle on the road and higher probability of vehicle rollover. Additionally, under inflated tires can drastically reduce the fuel efficiency of the vehicle leading to higher levels of emissions. As the world market leader in TPMS pressure sensors, SMI has a variety of solutions that can enable accurate pressure readings in this harsh environment.
Legislation in USA (2007) requires all new cars to be equipped with TPMS.
2013 – Europe started with 100% compliance in 2014.
2014 – South Korea confirmed legislation.
2017 – Japan intends to legislate.
2018 – China intends to legislate.
2019 – India intends to legislate.


text:
(function() {

    var Transition = function(options) {
        options || (options = {});
        var names = options.pages || [];

        // Create the registry of pages
        this.pages = {}; // name: index
        this.order = []; // [index] = name
        this.$pages = []; // [index] = $(#name)

        // TODO Instead of a pointer, maintain a history?
        this.pointer = 0;

        _.each(names, this.addName, this);
        // TODO Allow speed to be set as an option
        // Unfortunately, speed is set by a CSS style, which will need to
        // be modified on each element
    };

    // Attach Transition to the window, but through the namespace 'kb'
    var root = this;
    root.kb = root.kb || {};
    root.kb.Transition = Transition;

    _.extend(Transition.prototype, Backbone.Events, {
        addName: function(name, index) {
            // TODO Should be an integer
            index = _.isNumber(index) ? index : this.order.length;
            // TODO allow either ids or jQuery object with an id
            var $el = $('#' + name);
            this._add(name, index, $el);
        },
        // TODO Standardize the interfaces for adding names / HTML / jQuery
        addElem: function(name, el, index) {
            // TODO Should be an integer
            index = _.isNumber(index) ? index : this.order.length;
            this._add(name, index, $(el));
        },
        _add: function(name, index, $el) {
            // If an item already exists at the given index, make room for the
            // new item by incrementing the rest of the array
            // TODO What about intentional replacement?
            // TODO Confirm $el exists
            // TODO Check for duplicate names
            if (index in this.order) {
                this.order.splice(index, 0, name);
                this.$pages.splice(index, 0, $el);

                // Re-index all the page names, this will include the new name
                // index may be sparse!
                for (var i = 0, len = this.order.length; i < len; i++) {
                    var name = this.order[i];
                    if (name) this.pages[name] = i;
                }
            } else {
                this.order[index] = name;
                this.$pages[index] = $el;
                this.pages[name] = index;
            }
        },
        // The transition events will fire when the animation ends
        // TODO Narrow the prefixes by sniffing
        transitionEvents: 'transitionend webkitTransitionEnd oTransitionEnd MSTransitionEnd',
        slideTo: function(page) {
            var lastIndex = this.pointer;
            // Requested page - TODO confirm it exists
            var nextIndex = this.pages[page];

            // If the requested page is the current page, do nothing
            if (nextIndex == lastIndex) return;

            // Get the current page (which will become last) using the pointer
            var lastName = this.order[lastIndex];
            var nextName = this.order[nextIndex];

            // Get the jQuery last and next pages
            var last = this.$pages[lastIndex];
            var next = this.$pages[nextIndex];

            // Turn off any transitionEnds attached to the next element
            // Without this off(), if a user clicks too fast, the page may
            // be hidden
            // TODO Trigger a slideEnd if there was a transition in progress
            next.off(this.transitionEvents, transitionEnd);

            // Hide all elements that are no last or next
            // TODO There should be an easier way to tell if there are active
            // transitions and how to cleanly tear them down
            for (index in this.$pages) {
                var $page = this.$pages[index];
                if ($page != last || $page != next) $page.hide();
            }

            // Update the pointer / history
            this.pointer = nextIndex;

            var lastLeft = (nextIndex < lastIndex) ? 100 : -100;
            var nextLeft = (nextIndex < lastIndex) ? -100 : 100;

            // Set the initial position of pages
            this.reset(last, 0, 1, next, nextLeft, 1);

            var self = this;

            var transitionEnd;
            transitionEnd = function() {
                // Remove the listener
                last.off(this.transitionEvents, transitionEnd);

                last.hide();

                // Fire an event for slide end
                self.trigger('slideEnd:' + nextName, lastName, last, nextName, next);
            }

            // We use "one", but still remove the event handler because
            // this callback will fire once for *each* of the prefixed
            // transitionend event names (for instance, chrome fires both
            // a "transitionend" and "webkitTransitionEnd")
            last.one(this.transitionEvents, transitionEnd);

            // Start the new transition
            // this is waiting to run the self.move() to allow the self.reset() to
            // finish disabling the fx class and setting up for animation

            setTimeout(function() {
                self.move(last, lastLeft, 1, next, 0, 1);
                self.trigger('slideStart:' + lastName, lastName, last, nextName, next);
            }, 50);

        },
        // TODO Allow prefixes to be configured with an option
        // TODO Tie these together with the transitionend events
        // A blank prefix results in "transform" and is used by modern IE
        _prefixes: ['', '-webkit-', '-moz-'],
        _buildTranslate: function(left) {
            return ('translate3d(' + left + '%, 0px, 0px)');
        },
        reset: function(last, lastLeft, lastOpacity, next, nextLeft, nextOpacity) {
            var nextTranslate = this._buildTranslate(nextLeft);
            var nextCSS = {
                'opacity': nextOpacity,
                'z-index': 1,
            };

            var lastTranslate = this._buildTranslate(lastLeft);
            var lastCSS = {
                'opacity': lastOpacity,
                'z-index': 2,
            };
            // TODO Generalize?
            for (var i = 0, len = this._prefixes.length; i < len; i++) {
                nextCSS[this._prefixes[i] + 'transform'] = nextTranslate;
                lastCSS[this._prefixes[i] + 'transform'] = lastTranslate;
            }

            next.removeClass('fx').css(nextCSS).show();
            last.removeClass('fx').css(lastCSS).show();
        },
        move: function(last, lastLeft, lastOpacity, next, nextLeft, nextOpacity) {
            var nextTranslate = this._buildTranslate(nextLeft);
            var nextCSS = {
                'opacity': nextOpacity,
                'z-index': 2,
            };

            var lastTranslate = this._buildTranslate(lastLeft);
            var lastCSS = {
                'opacity': lastOpacity,
                'z-index': 1,
            };
            // TODO Generalize?
            for (var i = 0, len = this._prefixes.length; i < len; i++) {
                nextCSS[this._prefixes[i] + 'transform'] = nextTranslate;
                lastCSS[this._prefixes[i] + 'transform'] = lastTranslate;
            }

            next.addClass('fx').css(nextCSS).show();
            last.addClass('fx').css(lastCSS).show();
        },
    });

    // TODO Temporarily place the Transition on the root namespace
    // In the future, only the kb namespace will work
    window.Transition = Transition;

}).call(this);


A number of our club members and guests meet regularly at Withlacoochee River Park during New Moon weekends. Everyone interested in viewing the night sky is welcome to these events. The schedule is displayed on our Club Calendar.
You may join us for just an evening, stay overnight, or camp for the weekend. There is plenty of room for RVs and tents with 30-Amp and 20-Amp outlets, and water. An RV dump station is located at the entry/exit of the field.
The park closes at dusk, so you must arrive before then. We will have the gate-code so you may depart whenever you are ready. However, we cannot give out the gate-code to anyone who is not already inside the park.
Reservations are not necessary. Please print and display our Friends-Of-The-Park Pass on your dashboard.
No registration is required as the first club member on site registers for the group and is responsible for the collection of the camping fees. Camping fees are $10/night w/electric for club members, $15/night for non-members, or $5/night without electric for both.
There are no costs if you are not staying overnight. However, we do accept donations to help our club meet its educational goals. We are an IRS 501(c)(3) not-for-profit organization so your donation may be tax deductible.
Restrooms, with showers, are located approximately 300 yards from the viewing field. The code for the restrooms is the same as the gate code and is only given out to folks that are on the viewing field and RV campground.
You must arrive prior to dusk because the gates lock and your head lights will interrupt those already set up for viewing.
Friends-Of-The-Park Pass must be displayed on your dashboard.
Camp fires are not allowed on the viewing field.
Park facing northeast if you plan to leave during the night.
You may email Jack Fritz for more information.
From Tampa take I-75 North to State Rd. 52. Take 52 East all the way through Dade City until it dead ends at the railroad station on the 301 Bypass. (Note: State Rd. 52 will make 2 right hand turns at traffic lights along the way, one after St. Leo and one when entering Dade City). Be sure to go all the way to the dead end at the old railroad station. Do not turn on 301, go all the way to the dead end. Turn left on 301 Bypass and go about ¾ mile until you see a Pizza Hut in the distance. Just before you get to the Pizza Hut, turn right on River Road, across the railroad tracks. You will see a sign saying "County Park 4.7 Miles." It's a very winding, paved road, take your time.
When you get to the fork in the road, you will take the road to the right (Auton Rd.). (There's a sign saying "County Park" directing you to the right) Go about 150 feet to the park entrance on the left (Withlacoochee Blvd.). Enter the park and go about ½ mile until you see a sign that says, "Big Ma's Way", and turn right onto the field.
You can also go North on 301 from Tampa and take the bypass when you get to Dade City.
St. Petersburg Astronomy Club, Inc. is an IRS 501(c)(3) not-for-profit educational organization.


text:
Q: Proving an equality with a function is applicable to any natural number $f_{n}$ is a sequence of natural numbers defined by a relation:
$f_{0} = 0$
$f_{1} = 1$
$f_{2} = 2$
$f_{n+3} = f_{n} - 2f_{n+2} + 3$
There is also a function $g$ defined by a primitive recursion with a substitution in parameters:
$g(0, a, b, c) = c$
$g(n + 1, a, b, c) = g(n, b, c, a − 2c + 3)$
I have to prove that this is applicable for every natural number $n$:
$f_{n+2} = g(n, 0, 1, 2)$
I have seriously no idea what to do about that. Any hints/ideas? Sorry for bad English, that is not my first language.

A: Firstly, looking at the problem, it's about natural numbers, right? So the typical technique to try is induction.
However, I get stuck. In the inductive step, applying the recursive definition $g(n + 1, a, b, c) = g(n, b, c, a - 2c + 3)$ gives $g(n, 0, 1, 2) = g(1, 2, -1)$ which is leading to nowhere. So let's change our strategy and try to solve a more general problem!

Define $$h(n, a, b, c) = \begin{cases} a \text{ if } n = 0 \\ b \text{ if } n = 1 \\ c \text{ if } n = 2 \\ h(k, a, b, c) - 2 h(k + 2, a, b, c) + 3 \\ \text{ if } n = k + 2 > 2\end{cases}$$
Notice $f_n$ is the same function as $n \mapsto h(n, 0, 1, 2)$, you can think of this as partial application if you know functional programming. Therefore, it suffices to prove $$h(n + 2, a, b, c) = g(n, a, b, c) \ \forall n \in \mathbb{N}, a, b, c \in \mathbb{Z}$$
We will prove this by induction. For the base case, $h(2, a, b, c) = c = g(0, a, b, c)$ by definition. For the inductive step, assume that there's some $n \in \mathbb{N}$ such that $$h(n + 2, a, b, c) = g(n, a, b, c) \ \forall a, b, c \in \mathbb{Z}$$
Now $$\begin{align}g(n + 1, a, b, c) &= g(n, b, c, a - 2c + 3) \\ &= h(n + 2, b, c, a - 2c + 3)\end{align}$$ by definition and inductive hypothesis. Note that to complete the proof, we are only left to show $$h(n + 2, b, c, a - 2c + 3) = h(n + 3, a, b, c) \\ \forall n \in \mathbb{N}, a, b, c \in \mathbb{Z}$$ which can again be shown by induction. I will leave you to check the details. Please ask if you get stuck. So this completes the proof.

redpajama_set_name: RedPajamaStackExchange


text:
Failed Candidate Stacey Abrams Defends Identity Politics: 'It's How We Won'
Failed Candidate Stacey Abrams Defends Identity Politics: 'It's How We Won'
The Democrat who lost Georgia's governor race in the fall of 2018 is still claiming victory to this day
By The Political Insider Staff
Image Credit: Shutterstock & Alex Wong/Getty Images
Georgia's Stacey Abrams, who lost her governor's race last fall but keeps insisting she somehow "won," is now claiming victory due to identity politics.
Addressing the Center for American Progress's Ideas Conference, Abrams said, "The notion of identity politics has been peddled for the past 10 years and it's been used as a dog whistle to say we shouldn't pay too much attention to the voices coming into progress."
Related: Abrams Is Still Considering Challenging Trump in 2020
"I would argue that identity politics is exactly who we are and exactly how we won," she added.
Stacey Abrams: "Identity politics is exactly who we are and it's exactly how we won." https://t.co/85uq8kxTIi pic.twitter.com/3U3ohfKnu3
— The Hill (@thehill) May 23, 2019
Remember, this is the same Stacey Abrams who once said it was "disturbing" and "distressing" that candidate Donald Trump might reject the results of the 2016 presidential election if it did not go his way.
It's funny how when the other party does something, it's horrendous — but when one's own does it, everything is fine.
Despite losing her race by 55,000 votes — not a small number in a state race — Abrams continues to insist she actually won in one form or another.
When a reporter asked her in March if she ever planned to concede her election, she said "No" — which Hillary Clinton and the Democrats called a "direct threat to democracy" when speculating that Trump could do the same.
Donald Trump refused to say that he'd respect the results of this election.
That's a direct threat to our democracy.
Abrams' comments remind us that the Democrats are now completely beholden to identity politics. For them, what you are — your race, gender, religion — becomes more important than who you are.
Most Americans are not on board with such a radical view.
Does Abrams ever stop and think that her party's embrace of such radicalism is the reason she lost?
Whether Stacey Abrams runs for office again is anyone's guess, but whatever the outcome, we know she will proclaim herself the winner — over and over and over again.
This piece originally appeared in The Political Insider and is used by permission.
Read more at ThePoliticalInsider.com:
Kellyanne Conway Snaps at Pelosi After Speaker Says She Doesn't Talk to President's Staff
Bombshell Transcripts: Obama AG Loretta Lynch Claims James Comey Lied Under Oath
ESPN President Admits Political Commentary Killed Network with Viewers, Vows Change
The Political Insider Staff
The Political Insider publishes the authentic conservative voices of political insiders and award-winning contributors who believe in personal responsibility, limited government, free markets, individual liberty, traditional American values, and a strong national defense. Each one is committed to combating the overwhelming liberal bias in today's media to give you, the reader, the unedited facts on real issues.
Can Gays be a part of the Conservative Movement?
Rocket Strikes U.S. Embassy in Baghdad

redpajama_set_name: RedPajamaCommonCrawl


text:
ERRATA – GURPS Timeline – Updated June 11, 1999
Copyright © by Steve Jackson Games Incorporated.
P. 9. Replace the second full paragraph with:
A Neanderthal time agent has ST+2 and DX-1. He cannot master any spoken or written language with a skill greater than 10. A Neanderthal begins to age at 40, and aging accelerates at 50 and 60. It costs 0 points to play a Neanderthal, unless the GM requires an Unusual Background to be taken for the race's psionic abilities. See GURPS Dinosaurs or GURPS Ice Age for more information about the Neanderthal race.
Delete the first sentence of the fourth full paragraph.
P. 22. In the first paragraph, the reference should be to the sun passing to the ship's right (which is north, as the fleet was travelling westwards) during the day, rather than to its rising and setting.
P. 41. In 607, the Horyuji temple was completed by Empress Suiko. Emperor Yomei died in 587.
P. 49. Heian Japan was founded in 794, not 793.
P. 51. Delete the entry under 858. Emperor Montoku died in 858 and was succeeded by Seiwa.
P. 78. In the second full paragraph, Torquemada died in 1498.
P. 81. In 1582, Pope Gregory dropped 10 days from the calendar, so that October 4 was directly followed by October 15.
P. 122. In 1972, Arab terrorists kill 11 Israeli athletes at the Munich Olympics.
Also under 1972, change "The Star of Sierra Leone (969.8 carats), the largest diamond known, is discovered." to "The Star of Sierra Leone (a 969.8-carat diamond) is discovered." It is not as large as the Cullinan diamond (p. 112).


We offer authentic cuban Mini White Canister Of 50 2014 cigars.
A distinctive format designed to meet with the most modern and dynamic consumption trends. Short 20-30 min smoke, ideal for a break time moment. Special Canister format.