1// $ANTLR 3.1.2 BuildOptions\\ProfileGrammar.g3 2009-09-30 13:18:17
2
3// The variable 'variable' is assigned but its value is never used.
4#pragma warning disable 219
5// Unreachable code detected.
6#pragma warning disable 162
7
8
9using System.Collections.Generic;
10using Antlr.Runtime;
11using Stack = System.Collections.Generic.Stack<object>;
12using List = System.Collections.IList;
13using ArrayList = System.Collections.Generic.List<object>;
14
15using Antlr.Runtime.Debug;
16using IOException = System.IO.IOException;
17
18using Antlr.Runtime.Tree;
19using RewriteRuleITokenStream = Antlr.Runtime.Tree.RewriteRuleTokenStream;
20
21[System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.1.2")]
22[System.CLSCompliant(false)]
23public partial class ProfileGrammarParser : DebugParser
24{
25	internal static readonly string[] tokenNames = new string[] {
26		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "CALL", "FUNC", "ID", "INT", "NEWLINE", "WS", "'-'", "'%'", "'('", "')'", "'*'", "'/'", "'+'", "'='"
27	};
28	public const int EOF=-1;
29	public const int T__10=10;
30	public const int T__11=11;
31	public const int T__12=12;
32	public const int T__13=13;
33	public const int T__14=14;
34	public const int T__15=15;
35	public const int T__16=16;
36	public const int T__17=17;
37	public const int CALL=4;
38	public const int FUNC=5;
39	public const int ID=6;
40	public const int INT=7;
41	public const int NEWLINE=8;
42	public const int WS=9;
43
44	// delegates
45	// delegators
46
47	public static readonly string[] ruleNames =
48		new string[]
49		{
50			"invalidRule", "atom", "expr", "formalPar", "func", "multExpr", "prog",
51		"stat"
52		};
53
54		int ruleLevel = 0;
55		public virtual int RuleLevel { get { return ruleLevel; } }
56		public virtual void IncRuleLevel() { ruleLevel++; }
57		public virtual void DecRuleLevel() { ruleLevel--; }
58		public ProfileGrammarParser( ITokenStream input )
59			: this( input, new Profiler(null), new RecognizerSharedState() )
60		{
61		}
62		public ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg, RecognizerSharedState state )
63			: base( input, dbg, state )
64		{
65			Profiler p = (Profiler)dbg;
66			p.setParser(this);
67			InitializeTreeAdaptor();
68			if ( TreeAdaptor == null )
69				TreeAdaptor = new CommonTreeAdaptor();
70			ITreeAdaptor adap = new CommonTreeAdaptor();
71			TreeAdaptor = adap;
72			proxy.TreeAdaptor = adap;
73		}
74
75	public ProfileGrammarParser( ITokenStream input, IDebugEventListener dbg )
76		: base( input, dbg )
77	{
78		Profiler p = (Profiler)dbg;
79		p.setParser(this);InitializeTreeAdaptor();
80		if ( TreeAdaptor == null )
81			TreeAdaptor = new CommonTreeAdaptor();
82
83		ITreeAdaptor adap = new CommonTreeAdaptor();
84		TreeAdaptor = adap;
85
86	}
87	public virtual bool AlreadyParsedRule( IIntStream input, int ruleIndex )
88	{
89		((Profiler)dbg).ExamineRuleMemoization(input, ruleIndex, ProfileGrammarParser.ruleNames[ruleIndex]);
90		return super.AlreadyParsedRule(input, ruleIndex);
91	}
92
93	public virtual void Memoize( IIntStream input, int ruleIndex, int ruleStartIndex )
94	{
95		((Profiler)dbg).Memoize(input, ruleIndex, ruleStartIndex, ProfileGrammarParser.ruleNames[ruleIndex]);
96		super.Memoize(input, ruleIndex, ruleStartIndex);
97	}
98	protected virtual bool EvalPredicate( bool result, string predicate )
99	{
100		dbg.SemanticPredicate( result, predicate );
101		return result;
102	}
103
104	// Implement this function in your helper file to use a custom tree adaptor
105	partial void InitializeTreeAdaptor();
106	protected DebugTreeAdaptor adaptor;
107
108	public ITreeAdaptor TreeAdaptor
109	{
110		get
111		{
112			return adaptor;
113		}
114		set
115		{
116			this.adaptor = new DebugTreeAdaptor(dbg,adaptor);
117
118		}
119	}
120
121
122	public override string[] TokenNames { get { return ProfileGrammarParser.tokenNames; } }
123	public override string GrammarFileName { get { return "BuildOptions\\ProfileGrammar.g3"; } }
124
125
126	#region Rules
127	public class prog_return : ParserRuleReturnScope
128	{
129		internal CommonTree tree;
130		public override object Tree { get { return tree; } }
131	}
132
133	// $ANTLR start "prog"
134	// BuildOptions\\ProfileGrammar.g3:50:0: prog : ( stat )* ;
135	private ProfileGrammarParser.prog_return prog(  )
136	{
137		ProfileGrammarParser.prog_return retval = new ProfileGrammarParser.prog_return();
138		retval.start = input.LT(1);
139
140		CommonTree root_0 = null;
141
142		ProfileGrammarParser.stat_return stat1 = default(ProfileGrammarParser.stat_return);
143
144
145		try
146		{
147			dbg.EnterRule( GrammarFileName, "prog" );
148			if ( RuleLevel == 0 )
149			{
150				dbg.Commence();
151			}
152			IncRuleLevel();
153			dbg.Location( 50, -1 );
154
155		try
156		{
157			// BuildOptions\\ProfileGrammar.g3:50:7: ( ( stat )* )
158			dbg.EnterAlt( 1 );
159
160			// BuildOptions\\ProfileGrammar.g3:50:7: ( stat )*
161			{
162			root_0 = (CommonTree)adaptor.Nil();
163
164			dbg.Location( 50, 6 );
165			// BuildOptions\\ProfileGrammar.g3:50:7: ( stat )*
166			try
167			{
168				dbg.EnterSubRule( 1 );
169
170			for ( ; ; )
171			{
172				int alt1=2;
173				try
174				{
175					dbg.EnterDecision( 1 );
176
177				int LA1_0 = input.LA(1);
178
179				if ( ((LA1_0>=ID && LA1_0<=NEWLINE)||LA1_0==12) )
180				{
181					alt1=1;
182				}
183
184
185				}
186				finally
187				{
188					dbg.ExitDecision( 1 );
189				}
190
191				switch ( alt1 )
192				{
193				case 1:
194					dbg.EnterAlt( 1 );
195
196					// BuildOptions\\ProfileGrammar.g3:50:9: stat
197					{
198					dbg.Location( 50, 8 );
199					PushFollow(Follow._stat_in_prog53);
200					stat1=stat();
201
202					state._fsp--;
203
204					adaptor.AddChild(root_0, stat1.Tree);
205
206					}
207					break;
208
209				default:
210					goto loop1;
211				}
212			}
213
214			loop1:
215				;
216
217			}
218			finally
219			{
220				dbg.ExitSubRule( 1 );
221			}
222
223
224			}
225
226			retval.stop = input.LT(-1);
227
228			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
229			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
230
231		}
232		catch ( RecognitionException re )
233		{
234			ReportError(re);
235			Recover(input,re);
236		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
237
238		}
239		finally
240		{
241		}
242		dbg.Location(51, 4);
243
244		}
245		finally
246		{
247			dbg.ExitRule( GrammarFileName, "prog" );
248			DecRuleLevel();
249			if ( RuleLevel == 0 )
250			{
251				dbg.Terminate();
252			}
253		}
254
255		return retval;
256	}
257	// $ANTLR end "prog"
258
259	public class stat_return : ParserRuleReturnScope
260	{
261		internal CommonTree tree;
262		public override object Tree { get { return tree; } }
263	}
264
265	// $ANTLR start "stat"
266	// BuildOptions\\ProfileGrammar.g3:53:0: stat : ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | func NEWLINE -> func | NEWLINE ->);
267	private ProfileGrammarParser.stat_return stat(  )
268	{
269		ProfileGrammarParser.stat_return retval = new ProfileGrammarParser.stat_return();
270		retval.start = input.LT(1);
271
272		CommonTree root_0 = null;
273
274		IToken NEWLINE3=null;
275		IToken ID4=null;
276		IToken char_literal5=null;
277		IToken NEWLINE7=null;
278		IToken NEWLINE9=null;
279		IToken NEWLINE10=null;
280		ProfileGrammarParser.expr_return expr2 = default(ProfileGrammarParser.expr_return);
281		ProfileGrammarParser.expr_return expr6 = default(ProfileGrammarParser.expr_return);
282		ProfileGrammarParser.func_return func8 = default(ProfileGrammarParser.func_return);
283
284		CommonTree NEWLINE3_tree=null;
285		CommonTree ID4_tree=null;
286		CommonTree char_literal5_tree=null;
287		CommonTree NEWLINE7_tree=null;
288		CommonTree NEWLINE9_tree=null;
289		CommonTree NEWLINE10_tree=null;
290		RewriteRuleITokenStream stream_NEWLINE=new RewriteRuleITokenStream(adaptor,"token NEWLINE");
291		RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID");
292		RewriteRuleITokenStream stream_17=new RewriteRuleITokenStream(adaptor,"token 17");
293		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
294		RewriteRuleSubtreeStream stream_func=new RewriteRuleSubtreeStream(adaptor,"rule func");
295		try
296		{
297			dbg.EnterRule( GrammarFileName, "stat" );
298			if ( RuleLevel == 0 )
299			{
300				dbg.Commence();
301			}
302			IncRuleLevel();
303			dbg.Location( 53, -1 );
304
305		try
306		{
307			// BuildOptions\\ProfileGrammar.g3:53:9: ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | func NEWLINE -> func | NEWLINE ->)
308			int alt2=4;
309			try
310			{
311				dbg.EnterDecision( 2 );
312
313			try
314			{
315				isCyclicDecision = true;
316				alt2 = dfa2.Predict(input);
317			}
318			catch ( NoViableAltException nvae )
319			{
320				dbg.RecognitionException( nvae );
321				throw nvae;
322			}
323			}
324			finally
325			{
326				dbg.ExitDecision( 2 );
327			}
328
329			switch ( alt2 )
330			{
331			case 1:
332				dbg.EnterAlt( 1 );
333
334				// BuildOptions\\ProfileGrammar.g3:53:9: expr NEWLINE
335				{
336				dbg.Location( 53, 8 );
337				PushFollow(Follow._expr_in_stat70);
338				expr2=expr();
339
340				state._fsp--;
341
342				stream_expr.Add(expr2.Tree);
343				dbg.Location( 53, 13 );
344				NEWLINE3=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat72);
345				stream_NEWLINE.Add(NEWLINE3);
346
347
348
349				{
350				// AST REWRITE
351				// elements: expr
352				// token labels:
353				// rule labels: retval
354				// token list labels:
355				// rule list labels:
356				// wildcard labels:
357				retval.tree = root_0;
358				RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
359
360				root_0 = (CommonTree)adaptor.Nil();
361				// 53:41: -> expr
362				{
363					dbg.Location( 53, 43 );
364					adaptor.AddChild(root_0, stream_expr.NextTree());
365
366				}
367
368				retval.tree = root_0;
369				}
370
371				}
372				break;
373			case 2:
374				dbg.EnterAlt( 2 );
375
376				// BuildOptions\\ProfileGrammar.g3:54:9: ID '=' expr NEWLINE
377				{
378				dbg.Location( 54, 8 );
379				ID4=(IToken)Match(input,ID,Follow._ID_in_stat105);
380				stream_ID.Add(ID4);
381
382				dbg.Location( 54, 11 );
383				char_literal5=(IToken)Match(input,17,Follow._17_in_stat107);
384				stream_17.Add(char_literal5);
385
386				dbg.Location( 54, 15 );
387				PushFollow(Follow._expr_in_stat109);
388				expr6=expr();
389
390				state._fsp--;
391
392				stream_expr.Add(expr6.Tree);
393				dbg.Location( 54, 20 );
394				NEWLINE7=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat111);
395				stream_NEWLINE.Add(NEWLINE7);
396
397
398
399				{
400				// AST REWRITE
401				// elements: 17, ID, expr
402				// token labels:
403				// rule labels: retval
404				// token list labels:
405				// rule list labels:
406				// wildcard labels:
407				retval.tree = root_0;
408				RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
409
410				root_0 = (CommonTree)adaptor.Nil();
411				// 54:41: -> ^( '=' ID expr )
412				{
413					dbg.Location( 54, 43 );
414					// BuildOptions\\ProfileGrammar.g3:54:44: ^( '=' ID expr )
415					{
416					CommonTree root_1 = (CommonTree)adaptor.Nil();
417					dbg.Location( 54, 45 );
418					root_1 = (CommonTree)adaptor.BecomeRoot(stream_17.NextNode(), root_1);
419
420					dbg.Location( 54, 49 );
421					adaptor.AddChild(root_1, stream_ID.NextNode());
422					dbg.Location( 54, 52 );
423					adaptor.AddChild(root_1, stream_expr.NextTree());
424
425					adaptor.AddChild(root_0, root_1);
426					}
427
428				}
429
430				retval.tree = root_0;
431				}
432
433				}
434				break;
435			case 3:
436				dbg.EnterAlt( 3 );
437
438				// BuildOptions\\ProfileGrammar.g3:55:9: func NEWLINE
439				{
440				dbg.Location( 55, 8 );
441				PushFollow(Follow._func_in_stat143);
442				func8=func();
443
444				state._fsp--;
445
446				stream_func.Add(func8.Tree);
447				dbg.Location( 55, 13 );
448				NEWLINE9=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat145);
449				stream_NEWLINE.Add(NEWLINE9);
450
451
452
453				{
454				// AST REWRITE
455				// elements: func
456				// token labels:
457				// rule labels: retval
458				// token list labels:
459				// rule list labels:
460				// wildcard labels:
461				retval.tree = root_0;
462				RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
463
464				root_0 = (CommonTree)adaptor.Nil();
465				// 55:41: -> func
466				{
467					dbg.Location( 55, 43 );
468					adaptor.AddChild(root_0, stream_func.NextTree());
469
470				}
471
472				retval.tree = root_0;
473				}
474
475				}
476				break;
477			case 4:
478				dbg.EnterAlt( 4 );
479
480				// BuildOptions\\ProfileGrammar.g3:56:9: NEWLINE
481				{
482				dbg.Location( 56, 8 );
483				NEWLINE10=(IToken)Match(input,NEWLINE,Follow._NEWLINE_in_stat178);
484				stream_NEWLINE.Add(NEWLINE10);
485
486
487
488				{
489				// AST REWRITE
490				// elements:
491				// token labels:
492				// rule labels: retval
493				// token list labels:
494				// rule list labels:
495				// wildcard labels:
496				retval.tree = root_0;
497				RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
498
499				root_0 = (CommonTree)adaptor.Nil();
500				// 56:41: ->
501				{
502					dbg.Location( 57, 4 );
503					root_0 = null;
504				}
505
506				retval.tree = root_0;
507				}
508
509				}
510				break;
511
512			}
513			retval.stop = input.LT(-1);
514
515			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
516			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
517
518		}
519		catch ( RecognitionException re )
520		{
521			ReportError(re);
522			Recover(input,re);
523		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
524
525		}
526		finally
527		{
528		}
529		dbg.Location(57, 4);
530
531		}
532		finally
533		{
534			dbg.ExitRule( GrammarFileName, "stat" );
535			DecRuleLevel();
536			if ( RuleLevel == 0 )
537			{
538				dbg.Terminate();
539			}
540		}
541
542		return retval;
543	}
544	// $ANTLR end "stat"
545
546	public class func_return : ParserRuleReturnScope
547	{
548		internal CommonTree tree;
549		public override object Tree { get { return tree; } }
550	}
551
552	// $ANTLR start "func"
553	// BuildOptions\\ProfileGrammar.g3:59:0: func : ID '(' formalPar ')' '=' expr -> ^( FUNC ID formalPar expr ) ;
554	private ProfileGrammarParser.func_return func(  )
555	{
556		ProfileGrammarParser.func_return retval = new ProfileGrammarParser.func_return();
557		retval.start = input.LT(1);
558
559		CommonTree root_0 = null;
560
561		IToken ID11=null;
562		IToken char_literal12=null;
563		IToken char_literal14=null;
564		IToken char_literal15=null;
565		ProfileGrammarParser.formalPar_return formalPar13 = default(ProfileGrammarParser.formalPar_return);
566		ProfileGrammarParser.expr_return expr16 = default(ProfileGrammarParser.expr_return);
567
568		CommonTree ID11_tree=null;
569		CommonTree char_literal12_tree=null;
570		CommonTree char_literal14_tree=null;
571		CommonTree char_literal15_tree=null;
572		RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID");
573		RewriteRuleITokenStream stream_12=new RewriteRuleITokenStream(adaptor,"token 12");
574		RewriteRuleITokenStream stream_13=new RewriteRuleITokenStream(adaptor,"token 13");
575		RewriteRuleITokenStream stream_17=new RewriteRuleITokenStream(adaptor,"token 17");
576		RewriteRuleSubtreeStream stream_formalPar=new RewriteRuleSubtreeStream(adaptor,"rule formalPar");
577		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
578		try
579		{
580			dbg.EnterRule( GrammarFileName, "func" );
581			if ( RuleLevel == 0 )
582			{
583				dbg.Commence();
584			}
585			IncRuleLevel();
586			dbg.Location( 59, -1 );
587
588		try
589		{
590			// BuildOptions\\ProfileGrammar.g3:59:9: ( ID '(' formalPar ')' '=' expr -> ^( FUNC ID formalPar expr ) )
591			dbg.EnterAlt( 1 );
592
593			// BuildOptions\\ProfileGrammar.g3:59:9: ID '(' formalPar ')' '=' expr
594			{
595			dbg.Location( 59, 8 );
596			ID11=(IToken)Match(input,ID,Follow._ID_in_func219);
597			stream_ID.Add(ID11);
598
599			dbg.Location( 59, 12 );
600			char_literal12=(IToken)Match(input,12,Follow._12_in_func222);
601			stream_12.Add(char_literal12);
602
603			dbg.Location( 59, 16 );
604			PushFollow(Follow._formalPar_in_func224);
605			formalPar13=formalPar();
606
607			state._fsp--;
608
609			stream_formalPar.Add(formalPar13.Tree);
610			dbg.Location( 59, 26 );
611			char_literal14=(IToken)Match(input,13,Follow._13_in_func226);
612			stream_13.Add(char_literal14);
613
614			dbg.Location( 59, 30 );
615			char_literal15=(IToken)Match(input,17,Follow._17_in_func228);
616			stream_17.Add(char_literal15);
617
618			dbg.Location( 59, 34 );
619			PushFollow(Follow._expr_in_func230);
620			expr16=expr();
621
622			state._fsp--;
623
624			stream_expr.Add(expr16.Tree);
625
626
627			{
628			// AST REWRITE
629			// elements: ID, formalPar, expr
630			// token labels:
631			// rule labels: retval
632			// token list labels:
633			// rule list labels:
634			// wildcard labels:
635			retval.tree = root_0;
636			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
637
638			root_0 = (CommonTree)adaptor.Nil();
639			// 59:41: -> ^( FUNC ID formalPar expr )
640			{
641				dbg.Location( 59, 43 );
642				// BuildOptions\\ProfileGrammar.g3:59:44: ^( FUNC ID formalPar expr )
643				{
644				CommonTree root_1 = (CommonTree)adaptor.Nil();
645				dbg.Location( 59, 45 );
646				root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(FUNC, "FUNC"), root_1);
647
648				dbg.Location( 59, 50 );
649				adaptor.AddChild(root_1, stream_ID.NextNode());
650				dbg.Location( 59, 53 );
651				adaptor.AddChild(root_1, stream_formalPar.NextTree());
652				dbg.Location( 59, 63 );
653				adaptor.AddChild(root_1, stream_expr.NextTree());
654
655				adaptor.AddChild(root_0, root_1);
656				}
657
658			}
659
660			retval.tree = root_0;
661			}
662
663			}
664
665			retval.stop = input.LT(-1);
666
667			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
668			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
669
670		}
671		catch ( RecognitionException re )
672		{
673			ReportError(re);
674			Recover(input,re);
675		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
676
677		}
678		finally
679		{
680
681				  functionDefinitions.Add(((CommonTree)retval.Tree));
682
683		}
684		dbg.Location(60, 4);
685
686		}
687		finally
688		{
689			dbg.ExitRule( GrammarFileName, "func" );
690			DecRuleLevel();
691			if ( RuleLevel == 0 )
692			{
693				dbg.Terminate();
694			}
695		}
696
697		return retval;
698	}
699	// $ANTLR end "func"
700
701	public class formalPar_return : ParserRuleReturnScope
702	{
703		internal CommonTree tree;
704		public override object Tree { get { return tree; } }
705	}
706
707	// $ANTLR start "formalPar"
708	// BuildOptions\\ProfileGrammar.g3:65:0: formalPar : ( ID | INT );
709	private ProfileGrammarParser.formalPar_return formalPar(  )
710	{
711		ProfileGrammarParser.formalPar_return retval = new ProfileGrammarParser.formalPar_return();
712		retval.start = input.LT(1);
713
714		CommonTree root_0 = null;
715
716		IToken set17=null;
717
718		CommonTree set17_tree=null;
719
720		try
721		{
722			dbg.EnterRule( GrammarFileName, "formalPar" );
723			if ( RuleLevel == 0 )
724			{
725				dbg.Commence();
726			}
727			IncRuleLevel();
728			dbg.Location( 65, -1 );
729
730		try
731		{
732			// BuildOptions\\ProfileGrammar.g3:66:9: ( ID | INT )
733			dbg.EnterAlt( 1 );
734
735			// BuildOptions\\ProfileGrammar.g3:
736			{
737			root_0 = (CommonTree)adaptor.Nil();
738
739			dbg.Location( 66, 8 );
740			set17=(IToken)input.LT(1);
741			if ( (input.LA(1)>=ID && input.LA(1)<=INT) )
742			{
743				input.Consume();
744				adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set17));
745				state.errorRecovery=false;
746			}
747			else
748			{
749				MismatchedSetException mse = new MismatchedSetException(null,input);
750				dbg.RecognitionException( mse );
751				throw mse;
752			}
753
754
755			}
756
757			retval.stop = input.LT(-1);
758
759			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
760			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
761
762		}
763		catch ( RecognitionException re )
764		{
765			ReportError(re);
766			Recover(input,re);
767		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
768
769		}
770		finally
771		{
772		}
773		dbg.Location(68, 1);
774
775		}
776		finally
777		{
778			dbg.ExitRule( GrammarFileName, "formalPar" );
779			DecRuleLevel();
780			if ( RuleLevel == 0 )
781			{
782				dbg.Terminate();
783			}
784		}
785
786		return retval;
787	}
788	// $ANTLR end "formalPar"
789
790	public class expr_return : ParserRuleReturnScope
791	{
792		internal CommonTree tree;
793		public override object Tree { get { return tree; } }
794	}
795
796	// $ANTLR start "expr"
797	// BuildOptions\\ProfileGrammar.g3:73:0: expr : multExpr ( ( '+' | '-' ) multExpr )* ;
798	private ProfileGrammarParser.expr_return expr(  )
799	{
800		ProfileGrammarParser.expr_return retval = new ProfileGrammarParser.expr_return();
801		retval.start = input.LT(1);
802
803		CommonTree root_0 = null;
804
805		IToken char_literal19=null;
806		IToken char_literal20=null;
807		ProfileGrammarParser.multExpr_return multExpr18 = default(ProfileGrammarParser.multExpr_return);
808		ProfileGrammarParser.multExpr_return multExpr21 = default(ProfileGrammarParser.multExpr_return);
809
810		CommonTree char_literal19_tree=null;
811		CommonTree char_literal20_tree=null;
812
813		try
814		{
815			dbg.EnterRule( GrammarFileName, "expr" );
816			if ( RuleLevel == 0 )
817			{
818				dbg.Commence();
819			}
820			IncRuleLevel();
821			dbg.Location( 73, -1 );
822
823		try
824		{
825			// BuildOptions\\ProfileGrammar.g3:73:9: ( multExpr ( ( '+' | '-' ) multExpr )* )
826			dbg.EnterAlt( 1 );
827
828			// BuildOptions\\ProfileGrammar.g3:73:9: multExpr ( ( '+' | '-' ) multExpr )*
829			{
830			root_0 = (CommonTree)adaptor.Nil();
831
832			dbg.Location( 73, 8 );
833			PushFollow(Follow._multExpr_in_expr288);
834			multExpr18=multExpr();
835
836			state._fsp--;
837
838			adaptor.AddChild(root_0, multExpr18.Tree);
839			dbg.Location( 73, 17 );
840			// BuildOptions\\ProfileGrammar.g3:73:18: ( ( '+' | '-' ) multExpr )*
841			try
842			{
843				dbg.EnterSubRule( 4 );
844
845			for ( ; ; )
846			{
847				int alt4=2;
848				try
849				{
850					dbg.EnterDecision( 4 );
851
852				int LA4_0 = input.LA(1);
853
854				if ( (LA4_0==10||LA4_0==16) )
855				{
856					alt4=1;
857				}
858
859
860				}
861				finally
862				{
863					dbg.ExitDecision( 4 );
864				}
865
866				switch ( alt4 )
867				{
868				case 1:
869					dbg.EnterAlt( 1 );
870
871					// BuildOptions\\ProfileGrammar.g3:73:19: ( '+' | '-' ) multExpr
872					{
873					dbg.Location( 73, 18 );
874					// BuildOptions\\ProfileGrammar.g3:73:19: ( '+' | '-' )
875					int alt3=2;
876					try
877					{
878						dbg.EnterSubRule( 3 );
879					try
880					{
881						dbg.EnterDecision( 3 );
882
883					int LA3_0 = input.LA(1);
884
885					if ( (LA3_0==16) )
886					{
887						alt3=1;
888					}
889					else if ( (LA3_0==10) )
890					{
891						alt3=2;
892					}
893					else
894					{
895						NoViableAltException nvae = new NoViableAltException("", 3, 0, input);
896
897						dbg.RecognitionException( nvae );
898						throw nvae;
899					}
900					}
901					finally
902					{
903						dbg.ExitDecision( 3 );
904					}
905
906					switch ( alt3 )
907					{
908					case 1:
909						dbg.EnterAlt( 1 );
910
911						// BuildOptions\\ProfileGrammar.g3:73:20: '+'
912						{
913						dbg.Location( 73, 22 );
914						char_literal19=(IToken)Match(input,16,Follow._16_in_expr292);
915						char_literal19_tree = (CommonTree)adaptor.Create(char_literal19);
916						root_0 = (CommonTree)adaptor.BecomeRoot(char_literal19_tree, root_0);
917
918
919						}
920						break;
921					case 2:
922						dbg.EnterAlt( 2 );
923
924						// BuildOptions\\ProfileGrammar.g3:73:25: '-'
925						{
926						dbg.Location( 73, 27 );
927						char_literal20=(IToken)Match(input,10,Follow._10_in_expr295);
928						char_literal20_tree = (CommonTree)adaptor.Create(char_literal20);
929						root_0 = (CommonTree)adaptor.BecomeRoot(char_literal20_tree, root_0);
930
931
932						}
933						break;
934
935					}
936					}
937					finally
938					{
939						dbg.ExitSubRule( 3 );
940					}
941
942					dbg.Location( 73, 30 );
943					PushFollow(Follow._multExpr_in_expr299);
944					multExpr21=multExpr();
945
946					state._fsp--;
947
948					adaptor.AddChild(root_0, multExpr21.Tree);
949
950					}
951					break;
952
953				default:
954					goto loop4;
955				}
956			}
957
958			loop4:
959				;
960
961			}
962			finally
963			{
964				dbg.ExitSubRule( 4 );
965			}
966
967
968			}
969
970			retval.stop = input.LT(-1);
971
972			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
973			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
974
975		}
976		catch ( RecognitionException re )
977		{
978			ReportError(re);
979			Recover(input,re);
980		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
981
982		}
983		finally
984		{
985		}
986		dbg.Location(74, 4);
987
988		}
989		finally
990		{
991			dbg.ExitRule( GrammarFileName, "expr" );
992			DecRuleLevel();
993			if ( RuleLevel == 0 )
994			{
995				dbg.Terminate();
996			}
997		}
998
999		return retval;
1000	}
1001	// $ANTLR end "expr"
1002
1003	public class multExpr_return : ParserRuleReturnScope
1004	{
1005		internal CommonTree tree;
1006		public override object Tree { get { return tree; } }
1007	}
1008
1009	// $ANTLR start "multExpr"
1010	// BuildOptions\\ProfileGrammar.g3:76:0: multExpr : atom ( ( '*' | '/' | '%' ) atom )* ;
1011	private ProfileGrammarParser.multExpr_return multExpr(  )
1012	{
1013		ProfileGrammarParser.multExpr_return retval = new ProfileGrammarParser.multExpr_return();
1014		retval.start = input.LT(1);
1015
1016		CommonTree root_0 = null;
1017
1018		IToken set23=null;
1019		ProfileGrammarParser.atom_return atom22 = default(ProfileGrammarParser.atom_return);
1020		ProfileGrammarParser.atom_return atom24 = default(ProfileGrammarParser.atom_return);
1021
1022		CommonTree set23_tree=null;
1023
1024		try
1025		{
1026			dbg.EnterRule( GrammarFileName, "multExpr" );
1027			if ( RuleLevel == 0 )
1028			{
1029				dbg.Commence();
1030			}
1031			IncRuleLevel();
1032			dbg.Location( 76, -1 );
1033
1034		try
1035		{
1036			// BuildOptions\\ProfileGrammar.g3:77:9: ( atom ( ( '*' | '/' | '%' ) atom )* )
1037			dbg.EnterAlt( 1 );
1038
1039			// BuildOptions\\ProfileGrammar.g3:77:9: atom ( ( '*' | '/' | '%' ) atom )*
1040			{
1041			root_0 = (CommonTree)adaptor.Nil();
1042
1043			dbg.Location( 77, 8 );
1044			PushFollow(Follow._atom_in_multExpr320);
1045			atom22=atom();
1046
1047			state._fsp--;
1048
1049			adaptor.AddChild(root_0, atom22.Tree);
1050			dbg.Location( 77, 13 );
1051			// BuildOptions\\ProfileGrammar.g3:77:14: ( ( '*' | '/' | '%' ) atom )*
1052			try
1053			{
1054				dbg.EnterSubRule( 5 );
1055
1056			for ( ; ; )
1057			{
1058				int alt5=2;
1059				try
1060				{
1061					dbg.EnterDecision( 5 );
1062
1063				int LA5_0 = input.LA(1);
1064
1065				if ( (LA5_0==11||(LA5_0>=14 && LA5_0<=15)) )
1066				{
1067					alt5=1;
1068				}
1069
1070
1071				}
1072				finally
1073				{
1074					dbg.ExitDecision( 5 );
1075				}
1076
1077				switch ( alt5 )
1078				{
1079				case 1:
1080					dbg.EnterAlt( 1 );
1081
1082					// BuildOptions\\ProfileGrammar.g3:77:15: ( '*' | '/' | '%' ) atom
1083					{
1084					dbg.Location( 77, 27 );
1085					set23=(IToken)input.LT(1);
1086					set23=(IToken)input.LT(1);
1087					if ( input.LA(1)==11||(input.LA(1)>=14 && input.LA(1)<=15) )
1088					{
1089						input.Consume();
1090						root_0 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set23), root_0);
1091						state.errorRecovery=false;
1092					}
1093					else
1094					{
1095						MismatchedSetException mse = new MismatchedSetException(null,input);
1096						dbg.RecognitionException( mse );
1097						throw mse;
1098					}
1099
1100					dbg.Location( 77, 29 );
1101					PushFollow(Follow._atom_in_multExpr332);
1102					atom24=atom();
1103
1104					state._fsp--;
1105
1106					adaptor.AddChild(root_0, atom24.Tree);
1107
1108					}
1109					break;
1110
1111				default:
1112					goto loop5;
1113				}
1114			}
1115
1116			loop5:
1117				;
1118
1119			}
1120			finally
1121			{
1122				dbg.ExitSubRule( 5 );
1123			}
1124
1125
1126			}
1127
1128			retval.stop = input.LT(-1);
1129
1130			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
1131			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
1132
1133		}
1134		catch ( RecognitionException re )
1135		{
1136			ReportError(re);
1137			Recover(input,re);
1138		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
1139
1140		}
1141		finally
1142		{
1143		}
1144		dbg.Location(78, 4);
1145
1146		}
1147		finally
1148		{
1149			dbg.ExitRule( GrammarFileName, "multExpr" );
1150			DecRuleLevel();
1151			if ( RuleLevel == 0 )
1152			{
1153				dbg.Terminate();
1154			}
1155		}
1156
1157		return retval;
1158	}
1159	// $ANTLR end "multExpr"
1160
1161	public class atom_return : ParserRuleReturnScope
1162	{
1163		internal CommonTree tree;
1164		public override object Tree { get { return tree; } }
1165	}
1166
1167	// $ANTLR start "atom"
1168	// BuildOptions\\ProfileGrammar.g3:80:0: atom : ( INT | ID | '(' expr ')' -> expr | ID '(' expr ')' -> ^( CALL ID expr ) );
1169	private ProfileGrammarParser.atom_return atom(  )
1170	{
1171		ProfileGrammarParser.atom_return retval = new ProfileGrammarParser.atom_return();
1172		retval.start = input.LT(1);
1173
1174		CommonTree root_0 = null;
1175
1176		IToken INT25=null;
1177		IToken ID26=null;
1178		IToken char_literal27=null;
1179		IToken char_literal29=null;
1180		IToken ID30=null;
1181		IToken char_literal31=null;
1182		IToken char_literal33=null;
1183		ProfileGrammarParser.expr_return expr28 = default(ProfileGrammarParser.expr_return);
1184		ProfileGrammarParser.expr_return expr32 = default(ProfileGrammarParser.expr_return);
1185
1186		CommonTree INT25_tree=null;
1187		CommonTree ID26_tree=null;
1188		CommonTree char_literal27_tree=null;
1189		CommonTree char_literal29_tree=null;
1190		CommonTree ID30_tree=null;
1191		CommonTree char_literal31_tree=null;
1192		CommonTree char_literal33_tree=null;
1193		RewriteRuleITokenStream stream_12=new RewriteRuleITokenStream(adaptor,"token 12");
1194		RewriteRuleITokenStream stream_13=new RewriteRuleITokenStream(adaptor,"token 13");
1195		RewriteRuleITokenStream stream_ID=new RewriteRuleITokenStream(adaptor,"token ID");
1196		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
1197		try
1198		{
1199			dbg.EnterRule( GrammarFileName, "atom" );
1200			if ( RuleLevel == 0 )
1201			{
1202				dbg.Commence();
1203			}
1204			IncRuleLevel();
1205			dbg.Location( 80, -1 );
1206
1207		try
1208		{
1209			// BuildOptions\\ProfileGrammar.g3:80:9: ( INT | ID | '(' expr ')' -> expr | ID '(' expr ')' -> ^( CALL ID expr ) )
1210			int alt6=4;
1211			try
1212			{
1213				dbg.EnterDecision( 6 );
1214
1215			switch ( input.LA(1) )
1216			{
1217			case INT:
1218				{
1219				alt6=1;
1220				}
1221				break;
1222			case ID:
1223				{
1224				int LA6_2 = input.LA(2);
1225
1226				if ( (LA6_2==12) )
1227				{
1228					alt6=4;
1229				}
1230				else if ( (LA6_2==NEWLINE||(LA6_2>=10 && LA6_2<=11)||(LA6_2>=13 && LA6_2<=16)) )
1231				{
1232					alt6=2;
1233				}
1234				else
1235				{
1236					NoViableAltException nvae = new NoViableAltException("", 6, 2, input);
1237
1238					dbg.RecognitionException( nvae );
1239					throw nvae;
1240				}
1241				}
1242				break;
1243			case 12:
1244				{
1245				alt6=3;
1246				}
1247				break;
1248			default:
1249				{
1250					NoViableAltException nvae = new NoViableAltException("", 6, 0, input);
1251
1252					dbg.RecognitionException( nvae );
1253					throw nvae;
1254				}
1255			}
1256
1257			}
1258			finally
1259			{
1260				dbg.ExitDecision( 6 );
1261			}
1262
1263			switch ( alt6 )
1264			{
1265			case 1:
1266				dbg.EnterAlt( 1 );
1267
1268				// BuildOptions\\ProfileGrammar.g3:80:9: INT
1269				{
1270				root_0 = (CommonTree)adaptor.Nil();
1271
1272				dbg.Location( 80, 8 );
1273				INT25=(IToken)Match(input,INT,Follow._INT_in_atom348);
1274				INT25_tree = (CommonTree)adaptor.Create(INT25);
1275				adaptor.AddChild(root_0, INT25_tree);
1276
1277
1278				}
1279				break;
1280			case 2:
1281				dbg.EnterAlt( 2 );
1282
1283				// BuildOptions\\ProfileGrammar.g3:81:9: ID
1284				{
1285				root_0 = (CommonTree)adaptor.Nil();
1286
1287				dbg.Location( 81, 8 );
1288				ID26=(IToken)Match(input,ID,Follow._ID_in_atom358);
1289				ID26_tree = (CommonTree)adaptor.Create(ID26);
1290				adaptor.AddChild(root_0, ID26_tree);
1291
1292
1293				}
1294				break;
1295			case 3:
1296				dbg.EnterAlt( 3 );
1297
1298				// BuildOptions\\ProfileGrammar.g3:82:9: '(' expr ')'
1299				{
1300				dbg.Location( 82, 8 );
1301				char_literal27=(IToken)Match(input,12,Follow._12_in_atom368);
1302				stream_12.Add(char_literal27);
1303
1304				dbg.Location( 82, 12 );
1305				PushFollow(Follow._expr_in_atom370);
1306				expr28=expr();
1307
1308				state._fsp--;
1309
1310				stream_expr.Add(expr28.Tree);
1311				dbg.Location( 82, 17 );
1312				char_literal29=(IToken)Match(input,13,Follow._13_in_atom372);
1313				stream_13.Add(char_literal29);
1314
1315
1316
1317				{
1318				// AST REWRITE
1319				// elements: expr
1320				// token labels:
1321				// rule labels: retval
1322				// token list labels:
1323				// rule list labels:
1324				// wildcard labels:
1325				retval.tree = root_0;
1326				RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1327
1328				root_0 = (CommonTree)adaptor.Nil();
1329				// 82:25: -> expr
1330				{
1331					dbg.Location( 82, 27 );
1332					adaptor.AddChild(root_0, stream_expr.NextTree());
1333
1334				}
1335
1336				retval.tree = root_0;
1337				}
1338
1339				}
1340				break;
1341			case 4:
1342				dbg.EnterAlt( 4 );
1343
1344				// BuildOptions\\ProfileGrammar.g3:83:9: ID '(' expr ')'
1345				{
1346				dbg.Location( 83, 8 );
1347				ID30=(IToken)Match(input,ID,Follow._ID_in_atom389);
1348				stream_ID.Add(ID30);
1349
1350				dbg.Location( 83, 11 );
1351				char_literal31=(IToken)Match(input,12,Follow._12_in_atom391);
1352				stream_12.Add(char_literal31);
1353
1354				dbg.Location( 83, 15 );
1355				PushFollow(Follow._expr_in_atom393);
1356				expr32=expr();
1357
1358				state._fsp--;
1359
1360				stream_expr.Add(expr32.Tree);
1361				dbg.Location( 83, 20 );
1362				char_literal33=(IToken)Match(input,13,Follow._13_in_atom395);
1363				stream_13.Add(char_literal33);
1364
1365
1366
1367				{
1368				// AST REWRITE
1369				// elements: ID, expr
1370				// token labels:
1371				// rule labels: retval
1372				// token list labels:
1373				// rule list labels:
1374				// wildcard labels:
1375				retval.tree = root_0;
1376				RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
1377
1378				root_0 = (CommonTree)adaptor.Nil();
1379				// 83:25: -> ^( CALL ID expr )
1380				{
1381					dbg.Location( 83, 27 );
1382					// BuildOptions\\ProfileGrammar.g3:83:28: ^( CALL ID expr )
1383					{
1384					CommonTree root_1 = (CommonTree)adaptor.Nil();
1385					dbg.Location( 83, 29 );
1386					root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CALL, "CALL"), root_1);
1387
1388					dbg.Location( 83, 34 );
1389					adaptor.AddChild(root_1, stream_ID.NextNode());
1390					dbg.Location( 83, 37 );
1391					adaptor.AddChild(root_1, stream_expr.NextTree());
1392
1393					adaptor.AddChild(root_0, root_1);
1394					}
1395
1396				}
1397
1398				retval.tree = root_0;
1399				}
1400
1401				}
1402				break;
1403
1404			}
1405			retval.stop = input.LT(-1);
1406
1407			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
1408			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
1409
1410		}
1411		catch ( RecognitionException re )
1412		{
1413			ReportError(re);
1414			Recover(input,re);
1415		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
1416
1417		}
1418		finally
1419		{
1420		}
1421		dbg.Location(84, 4);
1422
1423		}
1424		finally
1425		{
1426			dbg.ExitRule( GrammarFileName, "atom" );
1427			DecRuleLevel();
1428			if ( RuleLevel == 0 )
1429			{
1430				dbg.Terminate();
1431			}
1432		}
1433
1434		return retval;
1435	}
1436	// $ANTLR end "atom"
1437	#endregion Rules
1438
1439
1440	#region DFA
1441	DFA2 dfa2;
1442
1443	protected override void InitDFAs()
1444	{
1445		base.InitDFAs();
1446		dfa2 = new DFA2( this );
1447	}
1448
1449	class DFA2 : DFA
1450	{
1451
1452		const string DFA2_eotS =
1453			"\xA\xFFFF";
1454		const string DFA2_eofS =
1455			"\xA\xFFFF";
1456		const string DFA2_minS =
1457			"\x1\x6\x1\xFFFF\x1\x8\x1\xFFFF\x1\x6\x1\xFFFF\x2\xA\x1\x8\x1\xFFFF";
1458		const string DFA2_maxS =
1459			"\x1\xC\x1\xFFFF\x1\x11\x1\xFFFF\x1\xC\x1\xFFFF\x2\x10\x1\x11\x1\xFFFF";
1460		const string DFA2_acceptS =
1461			"\x1\xFFFF\x1\x1\x1\xFFFF\x1\x4\x1\xFFFF\x1\x2\x3\xFFFF\x1\x3";
1462		const string DFA2_specialS =
1463			"\xA\xFFFF}>";
1464		static readonly string[] DFA2_transitionS =
1465			{
1466				"\x1\x2\x1\x1\x1\x3\x3\xFFFF\x1\x1",
1467				"",
1468				"\x1\x1\x1\xFFFF\x2\x1\x1\x4\x1\xFFFF\x3\x1\x1\x5",
1469				"",
1470				"\x1\x7\x1\x6\x4\xFFFF\x1\x1",
1471				"",
1472				"\x2\x1\x1\xFFFF\x1\x8\x3\x1",
1473				"\x3\x1\x1\x8\x3\x1",
1474				"\x1\x1\x1\xFFFF\x2\x1\x2\xFFFF\x3\x1\x1\x9",
1475				""
1476			};
1477
1478		static readonly short[] DFA2_eot = DFA.UnpackEncodedString(DFA2_eotS);
1479		static readonly short[] DFA2_eof = DFA.UnpackEncodedString(DFA2_eofS);
1480		static readonly char[] DFA2_min = DFA.UnpackEncodedStringToUnsignedChars(DFA2_minS);
1481		static readonly char[] DFA2_max = DFA.UnpackEncodedStringToUnsignedChars(DFA2_maxS);
1482		static readonly short[] DFA2_accept = DFA.UnpackEncodedString(DFA2_acceptS);
1483		static readonly short[] DFA2_special = DFA.UnpackEncodedString(DFA2_specialS);
1484		static readonly short[][] DFA2_transition;
1485
1486		static DFA2()
1487		{
1488			int numStates = DFA2_transitionS.Length;
1489			DFA2_transition = new short[numStates][];
1490			for ( int i=0; i < numStates; i++ )
1491			{
1492				DFA2_transition[i] = DFA.UnpackEncodedString(DFA2_transitionS[i]);
1493			}
1494		}
1495
1496		public DFA2( BaseRecognizer recognizer )
1497		{
1498			this.recognizer = recognizer;
1499			this.decisionNumber = 2;
1500			this.eot = DFA2_eot;
1501			this.eof = DFA2_eof;
1502			this.min = DFA2_min;
1503			this.max = DFA2_max;
1504			this.accept = DFA2_accept;
1505			this.special = DFA2_special;
1506			this.transition = DFA2_transition;
1507		}
1508		public override string GetDescription()
1509		{
1510			return "53:0: stat : ( expr NEWLINE -> expr | ID '=' expr NEWLINE -> ^( '=' ID expr ) | func NEWLINE -> func | NEWLINE ->);";
1511		}
1512		public override void Error( NoViableAltException nvae )
1513		{
1514			((DebugParser)recognizer).dbg.RecognitionException( nvae );
1515		}
1516	}
1517
1518
1519	#endregion DFA
1520
1521	#region Follow sets
1522	private static class Follow
1523	{
1524		public static readonly BitSet _stat_in_prog53 = new BitSet(new ulong[]{0x11C2UL});
1525		public static readonly BitSet _expr_in_stat70 = new BitSet(new ulong[]{0x100UL});
1526		public static readonly BitSet _NEWLINE_in_stat72 = new BitSet(new ulong[]{0x2UL});
1527		public static readonly BitSet _ID_in_stat105 = new BitSet(new ulong[]{0x20000UL});
1528		public static readonly BitSet _17_in_stat107 = new BitSet(new ulong[]{0x10C0UL});
1529		public static readonly BitSet _expr_in_stat109 = new BitSet(new ulong[]{0x100UL});
1530		public static readonly BitSet _NEWLINE_in_stat111 = new BitSet(new ulong[]{0x2UL});
1531		public static readonly BitSet _func_in_stat143 = new BitSet(new ulong[]{0x100UL});
1532		public static readonly BitSet _NEWLINE_in_stat145 = new BitSet(new ulong[]{0x2UL});
1533		public static readonly BitSet _NEWLINE_in_stat178 = new BitSet(new ulong[]{0x2UL});
1534		public static readonly BitSet _ID_in_func219 = new BitSet(new ulong[]{0x1000UL});
1535		public static readonly BitSet _12_in_func222 = new BitSet(new ulong[]{0xC0UL});
1536		public static readonly BitSet _formalPar_in_func224 = new BitSet(new ulong[]{0x2000UL});
1537		public static readonly BitSet _13_in_func226 = new BitSet(new ulong[]{0x20000UL});
1538		public static readonly BitSet _17_in_func228 = new BitSet(new ulong[]{0x10C0UL});
1539		public static readonly BitSet _expr_in_func230 = new BitSet(new ulong[]{0x2UL});
1540		public static readonly BitSet _set_in_formalPar267 = new BitSet(new ulong[]{0x2UL});
1541		public static readonly BitSet _multExpr_in_expr288 = new BitSet(new ulong[]{0x10402UL});
1542		public static readonly BitSet _16_in_expr292 = new BitSet(new ulong[]{0x10C0UL});
1543		public static readonly BitSet _10_in_expr295 = new BitSet(new ulong[]{0x10C0UL});
1544		public static readonly BitSet _multExpr_in_expr299 = new BitSet(new ulong[]{0x10402UL});
1545		public static readonly BitSet _atom_in_multExpr320 = new BitSet(new ulong[]{0xC802UL});
1546		public static readonly BitSet _set_in_multExpr323 = new BitSet(new ulong[]{0x10C0UL});
1547		public static readonly BitSet _atom_in_multExpr332 = new BitSet(new ulong[]{0xC802UL});
1548		public static readonly BitSet _INT_in_atom348 = new BitSet(new ulong[]{0x2UL});
1549		public static readonly BitSet _ID_in_atom358 = new BitSet(new ulong[]{0x2UL});
1550		public static readonly BitSet _12_in_atom368 = new BitSet(new ulong[]{0x10C0UL});
1551		public static readonly BitSet _expr_in_atom370 = new BitSet(new ulong[]{0x2000UL});
1552		public static readonly BitSet _13_in_atom372 = new BitSet(new ulong[]{0x2UL});
1553		public static readonly BitSet _ID_in_atom389 = new BitSet(new ulong[]{0x1000UL});
1554		public static readonly BitSet _12_in_atom391 = new BitSet(new ulong[]{0x10C0UL});
1555		public static readonly BitSet _expr_in_atom393 = new BitSet(new ulong[]{0x2000UL});
1556		public static readonly BitSet _13_in_atom395 = new BitSet(new ulong[]{0x2UL});
1557
1558	}
1559	#endregion Follow sets
1560}
1561