private AstNode CreateNode(ActionRecord reduceAction, SourceSpan sourceSpan, AstNodeList childNodes)
{
IGrammarTerm nonTeminal = reduceAction.NonTerminal;
AstNode result;
AstNodeArgs args = new AstNodeArgs(nonTeminal, sourceSpan, childNodes);
Type ntNodeType = nonTeminal.NodeType ?? typeof(AstNode);
bool isList = nonTeminal.IsSet(TermOptions.IsList);
if (isList && childNodes.Count > 1 && childNodes[0].Term == nonTeminal)
{
result = childNodes[0];
AstNode newChild = childNodes[childNodes.Count - 1];
newChild.Parent = result;
result.ChildNodes.Add(newChild);
return(result);
}
if (nonTeminal.IsSet(TermOptions.IsStarList) && childNodes.Count == 1)
{
childNodes = childNodes[0].ChildNodes;
}
if (!isList && !nonTeminal.IsSet(TermOptions.IsPunctuation) && childNodes.Count == 1)
{
Type childNodeType = childNodes[0].Term.NodeType ?? typeof(AstNode);
if (childNodeType == ntNodeType || childNodeType.IsSubclassOf(ntNodeType))
{
return(childNodes[0]);
}
}
result = null;
if (ntNodeType == typeof(AstNode))
{
result = new AstNode(args);
}
else
{
ConstructorInfo ctor = ntNodeType.GetConstructor(new Type[] { typeof(AstNodeArgs) });
if (ctor == null)
{
throw new Exception("Failed to located constructor: " + ntNodeType.ToString() + "(AstNodeArgs args)");
}
result = (AstNode)ctor.Invoke(new object[] { args });
}
return(result);
}
private AstNode Parse(CompilerContext context, IEnumerable <TokenAst> tokenStream)
{
_context = context;
Reset();
_input = tokenStream.GetEnumerator();
NextToken();
while (true)
{
if (_currentState == FinalState)
{
AstNode result = _stack[0].Node;
_stack.Reset();
return(result);
}
if (_currentToken.Terminal.Category == TokenCategory.Error)
{
ReportScannerError();
return(null);
}
ActionRecord action = GetCurrentAction();
if (action == null)
{
ReportParserError();
return(null);
}
switch (action.ActionType)
{
case ParserActionType.Operator:
if (GetActionTypeForOperation(_currentToken) == ParserActionType.Shift)
{
goto case ParserActionType.Shift;
}
else
{
goto case ParserActionType.Reduce;
}
case ParserActionType.Shift:
ExecuteShiftAction(action);
break;
case ParserActionType.Reduce:
ExecuteReduceAction(action);
break;
}
}
}
private void ExecuteReduceAction(ActionRecord action)
{
ParserState oldState = _currentState;
int popCnt = action.PopCount;
AstNodeList childNodes = new AstNodeList();
for (int i = 0; i < action.PopCount; i++)
{
AstNode child = _stack[_stack.Count - popCnt + i].Node;
if (!child.Term.IsSet(TermOptions.IsPunctuation))
{
childNodes.Add(child);
}
}
SourceSpan newNodeSpan;
if (popCnt == 0)
{
newNodeSpan = new SourceSpan(_currentToken.Location, 0);
}
else
{
SourceLocation firstPopLoc = _stack[_stack.Count - popCnt].Node.Location;
int lastPopEndPos = _stack[_stack.Count - 1].Node.Span.EndPos;
newNodeSpan = new SourceSpan(firstPopLoc, lastPopEndPos - firstPopLoc.Position);
_currentState = _stack[_stack.Count - popCnt].State;
_stack.Pop(popCnt);
}
AstNode node = CreateNode(action, newNodeSpan, childNodes);
_stack.Push(node, _currentState);
ActionRecord gotoAction;
if (_currentState.Actions.TryGetValue(action.NonTerminal.Key, out gotoAction))
{
_currentState = gotoAction.NewState;
}
else
{
throw new CompilerException(string.Format("Cannot find transition for input {0}; state: {1}, popped state: {2}",
action.NonTerminal, oldState, _currentState));
}
}
private ActionRecord GetCurrentAction()
{
ActionRecord action = null;
if (_currentToken.MatchByValue)
{
if (_currentState.Actions.TryGetValue(_currentToken.Text, out action))
{
return(action);
}
}
if (_currentToken.MatchByType && _currentState.Actions.TryGetValue(_currentToken.Terminal.Key, out action))
{
return(action);
}
return(null);
}
private void ExecuteShiftAction(ActionRecord action)
{
_stack.Push(_currentToken, _currentState);
_currentState = action.NewState;
NextToken();
}
public LRParser()
{
ParserState state_0 = new ParserState(0);
ParserState state_1 = new ParserState(1);
ParserState state_2 = new ParserState(2);
ParserState state_3 = new ParserState(3);
ParserState state_4 = new ParserState(4);
ParserState state_5 = new ParserState(5);
ParserState state_6 = new ParserState(6);
ParserState state_7 = new ParserState(7);
ParserState state_8 = new ParserState(8);
ParserState state_9 = new ParserState(9);
ParserState state_10 = new ParserState(10);
ParserState state_11 = new ParserState(11);
ParserState state_12 = new ParserState(12);
ParserState state_13 = new ParserState(13);
ParserState state_14 = new ParserState(14);
ParserState state_15 = new ParserState(15);
ParserState state_16 = new ParserState(16);
ParserState state_17 = new ParserState(17);
ParserState state_18 = new ParserState(18);
ParserState state_19 = new ParserState(19);
ParserState state_20 = new ParserState(20);
ParserState state_21 = new ParserState(21);
ParserState state_22 = new ParserState(22);
ParserState state_23 = new ParserState(23);
ParserState state_24 = new ParserState(24);
ParserState state_25 = new ParserState(25);
ParserState state_26 = new ParserState(26);
ParserState state_27 = new ParserState(27);
ParserState state_28 = new ParserState(28);
ParserState state_29 = new ParserState(29);
ParserState state_30 = new ParserState(30);
ParserState state_31 = new ParserState(31);
ParserState state_32 = new ParserState(32);
ParserState state_33 = new ParserState(33);
ParserState state_34 = new ParserState(34);
ParserState state_35 = new ParserState(35);
ParserState state_36 = new ParserState(36);
ParserState state_37 = new ParserState(37);
ParserState state_38 = new ParserState(38);
ParserState state_39 = new ParserState(39);
ParserState state_40 = new ParserState(40);
ParserState state_41 = new ParserState(41);
ParserState state_42 = new ParserState(42);
ParserState state_43 = new ParserState(43);
ParserState state_44 = new ParserState(44);
ParserState state_45 = new ParserState(45);
ParserState state_46 = new ParserState(46);
ParserState state_47 = new ParserState(47);
ParserState state_48 = new ParserState(48);
ParserState state_49 = new ParserState(49);
ParserState state_50 = new ParserState(50);
ParserState state_51 = new ParserState(51);
ParserState state_52 = new ParserState(52);
ParserState state_53 = new ParserState(53);
ParserState state_54 = new ParserState(54);
ParserState state_55 = new ParserState(55);
ParserState state_56 = new ParserState(56);
ParserState state_57 = new ParserState(57);
ParserState state_58 = new ParserState(58);
ParserState state_59 = new ParserState(59);
ParserState state_60 = new ParserState(60);
ParserState state_61 = new ParserState(61);
ParserState state_62 = new ParserState(62);
ParserState state_63 = new ParserState(63);
ParserState state_64 = new ParserState(64);
ParserState state_65 = new ParserState(65);
ParserState state_66 = new ParserState(66);
ParserState state_67 = new ParserState(67);
ParserState state_68 = new ParserState(68);
ParserState state_69 = new ParserState(69);
ParserState state_70 = new ParserState(70);
ParserState state_71 = new ParserState(71);
ParserState state_72 = new ParserState(72);
ParserState state_73 = new ParserState(73);
ParserState state_74 = new ParserState(74);
ParserState state_75 = new ParserState(75);
ParserState state_76 = new ParserState(76);
ParserState state_77 = new ParserState(77);
ParserState state_78 = new ParserState(78);
ParserState state_79 = new ParserState(79);
ParserState state_80 = new ParserState(80);
ParserState state_81 = new ParserState(81);
ParserState state_82 = new ParserState(82);
ParserState state_83 = new ParserState(83);
ParserState state_84 = new ParserState(84);
ParserState state_85 = new ParserState(85);
ParserState state_86 = new ParserState(86);
ParserState state_87 = new ParserState(87);
ParserState state_88 = new ParserState(88);
ParserState state_89 = new ParserState(89);
ParserState state_90 = new ParserState(90);
ParserState state_91 = new ParserState(91);
ParserState state_92 = new ParserState(92);
ParserState state_93 = new ParserState(93);
ParserState state_94 = new ParserState(94);
ParserState state_95 = new ParserState(95);
ParserState state_96 = new ParserState(96);
ParserState state_97 = new ParserState(97);
ParserState state_98 = new ParserState(98);
ParserState state_99 = new ParserState(99);
ParserState state_100 = new ParserState(100);
ParserState state_101 = new ParserState(101);
ParserState state_102 = new ParserState(102);
ParserState state_103 = new ParserState(103);
ParserState state_104 = new ParserState(104);
ParserState state_105 = new ParserState(105);
ParserState state_106 = new ParserState(106);
ParserState state_107 = new ParserState(107);
ParserState state_108 = new ParserState(108);
ParserState state_109 = new ParserState(109);
ParserState state_110 = new ParserState(110);
ParserState state_111 = new ParserState(111);
ParserState state_112 = new ParserState(112);
ParserState state_113 = new ParserState(113);
ParserState state_114 = new ParserState(114);
ParserState state_115 = new ParserState(115);
ParserState state_116 = new ParserState(116);
ParserState state_117 = new ParserState(117);
ParserState state_118 = new ParserState(118);
ParserState state_119 = new ParserState(119);
ParserState state_120 = new ParserState(120);
ParserState state_121 = new ParserState(121);
ParserState state_122 = new ParserState(122);
ParserState state_123 = new ParserState(123);
ParserState state_124 = new ParserState(124);
ParserState state_125 = new ParserState(125);
ParserState state_126 = new ParserState(126);
ParserState state_127 = new ParserState(127);
ParserState state_128 = new ParserState(128);
ParserState state_129 = new ParserState(129);
ParserState state_130 = new ParserState(130);
ParserState state_131 = new ParserState(131);
ParserState state_132 = new ParserState(132);
ParserState state_133 = new ParserState(133);
ParserState state_134 = new ParserState(134);
ParserState state_135 = new ParserState(135);
ParserState state_136 = new ParserState(136);
ParserState state_137 = new ParserState(137);
ParserState state_138 = new ParserState(138);
ParserState state_139 = new ParserState(139);
ParserState state_140 = new ParserState(140);
ParserState state_141 = new ParserState(141);
ParserState state_142 = new ParserState(142);
ParserState state_143 = new ParserState(143);
ParserState state_144 = new ParserState(144);
ParserState state_145 = new ParserState(145);
ParserState state_146 = new ParserState(146);
ParserState state_147 = new ParserState(147);
ParserState state_148 = new ParserState(148);
ParserState state_149 = new ParserState(149);
ParserState state_150 = new ParserState(150);
ParserState state_151 = new ParserState(151);
ParserState state_152 = new ParserState(152);
ParserState state_153 = new ParserState(153);
ParserState state_154 = new ParserState(154);
ParserState state_155 = new ParserState(155);
ParserState state_156 = new ParserState(156);
ParserState state_157 = new ParserState(157);
ParserState state_158 = new ParserState(158);
ParserState state_159 = new ParserState(159);
ParserState state_160 = new ParserState(160);
ParserState state_161 = new ParserState(161);
ParserState state_162 = new ParserState(162);
ParserState state_163 = new ParserState(163);
ParserState state_164 = new ParserState(164);
ParserState state_165 = new ParserState(165);
ParserState state_166 = new ParserState(166);
ParserState state_167 = new ParserState(167);
ParserState state_168 = new ParserState(168);
ParserState state_169 = new ParserState(169);
ParserState state_170 = new ParserState(170);
ParserState state_171 = new ParserState(171);
ParserState state_172 = new ParserState(172);
ParserState state_173 = new ParserState(173);
ParserState state_174 = new ParserState(174);
ParserState state_175 = new ParserState(175);
ParserState state_176 = new ParserState(176);
ParserState state_177 = new ParserState(177);
ParserState state_178 = new ParserState(178);
ParserState state_179 = new ParserState(179);
ParserState state_180 = new ParserState(180);
ParserState state_181 = new ParserState(181);
ParserState state_182 = new ParserState(182);
ParserState state_183 = new ParserState(183);
ParserState state_184 = new ParserState(184);
ParserState state_185 = new ParserState(185);
ParserState state_186 = new ParserState(186);
ParserState state_187 = new ParserState(187);
ParserState state_188 = new ParserState(188);
ParserState state_189 = new ParserState(189);
ParserState state_190 = new ParserState(190);
ParserState state_191 = new ParserState(191);
ParserState state_192 = new ParserState(192);
ParserState state_193 = new ParserState(193);
ParserState state_194 = new ParserState(194);
ParserState state_195 = new ParserState(195);
ParserState state_196 = new ParserState(196);
ParserState state_197 = new ParserState(197);
ParserState state_198 = new ParserState(198);
ParserState state_199 = new ParserState(199);
ParserState state_200 = new ParserState(200);
ParserState state_201 = new ParserState(201);
ParserState state_202 = new ParserState(202);
ParserState state_203 = new ParserState(203);
ParserState state_204 = new ParserState(204);
ParserState state_205 = new ParserState(205);
ParserState state_206 = new ParserState(206);
ParserState state_207 = new ParserState(207);
ParserState state_208 = new ParserState(208);
ParserState state_209 = new ParserState(209);
ParserState state_210 = new ParserState(210);
ParserState state_211 = new ParserState(211);
ParserState state_212 = new ParserState(212);
ParserState state_213 = new ParserState(213);
ParserState state_214 = new ParserState(214);
ParserState state_215 = new ParserState(215);
ParserState state_216 = new ParserState(216);
ParserState state_217 = new ParserState(217);
ParserState state_218 = new ParserState(218);
ParserState state_219 = new ParserState(219);
ParserState state_220 = new ParserState(220);
ParserState state_221 = new ParserState(221);
ParserState state_222 = new ParserState(222);
ParserState state_223 = new ParserState(223);
ParserState state_224 = new ParserState(224);
ParserState state_225 = new ParserState(225);
ParserState state_226 = new ParserState(226);
ParserState state_227 = new ParserState(227);
ParserState state_228 = new ParserState(228);
ParserState state_229 = new ParserState(229);
ParserState state_230 = new ParserState(230);
ParserState state_231 = new ParserState(231);
ParserState state_232 = new ParserState(232);
ParserState state_233 = new ParserState(233);
ParserState state_234 = new ParserState(234);
ParserState state_235 = new ParserState(235);
ParserState state_236 = new ParserState(236);
ParserState state_237 = new ParserState(237);
ParserState state_238 = new ParserState(238);
ParserState state_239 = new ParserState(239);
ParserState state_240 = new ParserState(240);
ParserState state_241 = new ParserState(241);
ParserState state_242 = new ParserState(242);
ParserState state_243 = new ParserState(243);
ParserState state_244 = new ParserState(244);
ParserState state_245 = new ParserState(245);
ParserState state_246 = new ParserState(246);
ParserState state_247 = new ParserState(247);
ParserState state_248 = new ParserState(248);
ParserState state_249 = new ParserState(249);
ParserState state_250 = new ParserState(250);
ParserState state_251 = new ParserState(251);
ParserState state_252 = new ParserState(252);
ParserState state_253 = new ParserState(253);
ParserState state_254 = new ParserState(254);
ParserState state_255 = new ParserState(255);
ParserState state_256 = new ParserState(256);
ParserState state_257 = new ParserState(257);
ParserState state_258 = new ParserState(258);
ParserState state_259 = new ParserState(259);
ParserState state_260 = new ParserState(260);
ParserState state_261 = new ParserState(261);
ParserState state_262 = new ParserState(262);
ParserState state_263 = new ParserState(263);
ParserState state_264 = new ParserState(264);
ParserState state_265 = new ParserState(265);
ParserState state_266 = new ParserState(266);
ParserState state_267 = new ParserState(267);
ParserState state_268 = new ParserState(268);
ParserState state_269 = new ParserState(269);
NonTerminal Terms_48 = new NonTerminal("Elements", typeof(Scripting.SSharp.Parser.Ast.ScriptElements), "Elements\b", TermOptions.IsList, 48);
NonTerminal Terms_59 = new NonTerminal("Prog'", typeof(AstNode), "Prog'\b", TermOptions.None, 59);
NonTerminal Terms_46 = new NonTerminal("Prog", typeof(Scripting.SSharp.Parser.Ast.ScriptProg), "Prog\b", TermOptions.None, 46);
NonTerminal Terms_47 = new NonTerminal("Element", typeof(Scripting.SSharp.Parser.Ast.ScriptAst), "Element\b", TermOptions.None, 47);
NonTerminal Terms_30 = new NonTerminal("Statement", typeof(Scripting.SSharp.Parser.Ast.ScriptStatement), "Statement\b", TermOptions.None, 30);
NonTerminal Terms_45 = new NonTerminal("Statements(Compound)", typeof(Scripting.SSharp.Parser.Ast.ScriptCompoundStatement), "Statements(Compound)\b", TermOptions.IsList, 45);
NonTerminal Terms_0 = new NonTerminal("Expr", typeof(Scripting.SSharp.Parser.Ast.ScriptExpr), "Expr\b", TermOptions.None, 0);
NonTerminal Terms_1 = new NonTerminal("ConstExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptConstExpr), "ConstExpr\b", TermOptions.None, 1);
NonTerminal Terms_2 = new NonTerminal("BinExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptBinExpr), "BinExpr\b", TermOptions.None, 2);
NonTerminal Terms_55 = new NonTerminal("*", typeof(AstNode), "*\b", TermOptions.IsList, 55);
NonTerminal Terms_16 = new NonTerminal("LUnOp", typeof(AstNode), "LUnOp\b", TermOptions.None, 16);
NonTerminal Terms_72 = new NonTerminal("NT3", typeof(AstNode), "\b", TermOptions.None, 72);
NonTerminal Terms_51 = new NonTerminal("ParamaterList", typeof(Scripting.SSharp.Parser.Ast.ScriptFuncParameters), "ParamaterList\b", TermOptions.IsStarList, 51);
NonTerminal Terms_35 = new NonTerminal("OptionalExpression", typeof(Scripting.SSharp.Parser.Ast.ScriptExpr), "OptionalExpression\b", TermOptions.None, 35);
NonTerminal Terms_43 = new NonTerminal("ExprStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptStatement), "ExprStatement\b", TermOptions.None, 43);
NonTerminal Terms_15 = new NonTerminal("BinOp", typeof(AstNode), "BinOp\b", TermOptions.None, 15);
NonTerminal Terms_42 = new NonTerminal("FlowControl", typeof(Scripting.SSharp.Parser.Ast.ScriptFlowControlStatement), "FlowControl\b", TermOptions.None, 42);
NonTerminal Terms_4 = new NonTerminal("AssignExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptAssignExpr), "AssignExpr\b", TermOptions.None, 4);
NonTerminal Terms_3 = new NonTerminal("UnaryExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptUnaryExpr), "UnaryExpr\b", TermOptions.None, 3);
NonTerminal Terms_26 = new NonTerminal("QualifiedName", typeof(Scripting.SSharp.Parser.Ast.ScriptQualifiedName), "QualifiedName\b", TermOptions.None, 26);
NonTerminal Terms_24 = new NonTerminal("NewStmt", typeof(Scripting.SSharp.Parser.Ast.ScriptNewStmt), "NewStmt\b", TermOptions.None, 24);
NonTerminal Terms_60 = new NonTerminal("GenericsPostfix?", typeof(AstNode), "\b", TermOptions.None, 60);
NonTerminal Terms_21 = new NonTerminal("MObjectPart", typeof(Scripting.SSharp.Parser.Ast.ScriptAst), "MObjectPart\b", TermOptions.IsList, 21);
NonTerminal Terms_23 = new NonTerminal("ExprList", typeof(Scripting.SSharp.Parser.Ast.ScriptExprList), "ExprList\b", TermOptions.IsList, 23);
NonTerminal Terms_9 = new NonTerminal("RefExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptRefExpr), "RefExpr\b", TermOptions.None, 9);
NonTerminal Terms_10 = new NonTerminal("VarExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptVarExpr), "VarExpr\b", TermOptions.None, 10);
NonTerminal Terms_58 = new NonTerminal("idn+", typeof(AstNode), "idn+\b", TermOptions.IsList, 58);
NonTerminal Terms_73 = new NonTerminal("?", typeof(AstNode), "\b", TermOptions.None, 73);
NonTerminal Terms_32 = new NonTerminal("WhileStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptWhileStatement), "WhileStatement\b", TermOptions.None, 32);
NonTerminal Terms_44 = new NonTerminal("BlockStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptStatement), "BlockStatement\b", TermOptions.None, 44);
NonTerminal Terms_6 = new NonTerminal("IsExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptIsExpr), "IsExpr\b", TermOptions.None, 6);
NonTerminal Terms_56 = new NonTerminal("*", typeof(AstNode), "*\b", TermOptions.IsList, 56);
NonTerminal Terms_63 = new NonTerminal("NT1", typeof(AstNode), "\b", TermOptions.None, 63);
NonTerminal Terms_64 = new NonTerminal("ExprList?", typeof(AstNode), "\b", TermOptions.None, 64);
NonTerminal Terms_12 = new NonTerminal("TypeConstructor", typeof(Scripting.SSharp.Parser.Ast.ScriptTypeConstructor), "TypeConstructor\b", TermOptions.None, 12);
NonTerminal Terms_25 = new NonTerminal("NewArrStmt", typeof(Scripting.SSharp.Parser.Ast.ScriptNewArrStmt), "NewArrStmt\b", TermOptions.None, 25);
NonTerminal Terms_11 = new NonTerminal("TypeExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptTypeExpr), "TypeExpr\b", TermOptions.None, 11);
NonTerminal Terms_18 = new NonTerminal("ArrayConstructor", typeof(Scripting.SSharp.Parser.Ast.ScriptArrayConstructor), "ArrayConstructor\b", TermOptions.None, 18);
NonTerminal Terms_19 = new NonTerminal("MObjectConstructor", typeof(Scripting.SSharp.Parser.Ast.ScriptMObject), "MObjectConstructor\b", TermOptions.None, 19);
NonTerminal Terms_71 = new NonTerminal("Expr?", typeof(AstNode), "\b", TermOptions.None, 71);
NonTerminal Terms_7 = new NonTerminal("MetaExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptMetaExpr), "MetaExpr\b", TermOptions.None, 7);
NonTerminal Terms_66 = new NonTerminal("GlobalList?", typeof(AstNode), "\b", TermOptions.None, 66);
NonTerminal Terms_31 = new NonTerminal("IfStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptIfStatement), "IfStatement\b", TermOptions.None, 31);
NonTerminal Terms_29 = new NonTerminal("Condition", typeof(Scripting.SSharp.Parser.Ast.ScriptCondition), "Condition\b", TermOptions.None, 29);
NonTerminal Terms_22 = new NonTerminal("TypeList", typeof(Scripting.SSharp.Parser.Ast.ScriptTypeExprList), "TypeList\b", TermOptions.IsList, 22);
NonTerminal Terms_62 = new NonTerminal("GenericsPostfix?", typeof(AstNode), "\b", TermOptions.None, 62);
NonTerminal Terms_20 = new NonTerminal("MObjectPart", typeof(Scripting.SSharp.Parser.Ast.ScriptMObjectPart), "MObjectPart\b", TermOptions.None, 20);
NonTerminal Terms_5 = new NonTerminal("TypeConvertExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptTypeConvertExpr), "TypeConvertExpr\b", TermOptions.None, 5);
NonTerminal Terms_67 = new NonTerminal("FuncContract?", typeof(AstNode), "\b", TermOptions.None, 67);
NonTerminal Terms_75 = new NonTerminal("GlobalList?", typeof(AstNode), "\b", TermOptions.None, 75);
NonTerminal Terms_40 = new NonTerminal("UsingStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptUsingStatement), "UsingStatement\b", TermOptions.None, 40);
NonTerminal Terms_57 = new NonTerminal("SwitchCaseStatement*", typeof(AstNode), "SwitchCaseStatement*\b", TermOptions.IsList, 57);
NonTerminal Terms_65 = new NonTerminal("NT2", typeof(AstNode), "\b", TermOptions.None, 65);
NonTerminal Terms_27 = new NonTerminal("GenericsPostfix", typeof(Scripting.SSharp.Parser.Ast.ScriptGenericsPostfix), "GenericsPostfix\b", TermOptions.None, 27);
NonTerminal Terms_14 = new NonTerminal("ArrayResolution", typeof(Scripting.SSharp.Parser.Ast.ScriptArrayResolution), "ArrayResolution\b", TermOptions.None, 14);
NonTerminal Terms_13 = new NonTerminal("FunctionCall", typeof(Scripting.SSharp.Parser.Ast.ScriptFunctionCall), "FunctionCall\b", TermOptions.None, 13);
NonTerminal Terms_61 = new NonTerminal("NT0", typeof(AstNode), "\b", TermOptions.None, 61);
NonTerminal Terms_76 = new NonTerminal("FuncContract?", typeof(AstNode), "\b", TermOptions.None, 76);
NonTerminal Terms_74 = new NonTerminal("SwitchDefaultStatement?", typeof(AstNode), "\b", TermOptions.None, 74);
NonTerminal Terms_8 = new NonTerminal("FuncDefExpr", typeof(Scripting.SSharp.Parser.Ast.ScriptFunctionDefinition), "FuncDefExpr\b", TermOptions.None, 8);
NonTerminal Terms_34 = new NonTerminal("ForEachStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptForEachStatement), "ForEachStatement\b", TermOptions.None, 34);
NonTerminal Terms_36 = new NonTerminal("SwitchStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptSwitchRootStatement), "SwitchStatement\b", TermOptions.None, 36);
NonTerminal Terms_37 = new NonTerminal("SwitchStatements", typeof(Scripting.SSharp.Parser.Ast.ScriptSwitchStatement), "SwitchStatements\b", TermOptions.None, 37);
NonTerminal Terms_68 = new NonTerminal("ExprList?", typeof(AstNode), "\b", TermOptions.None, 68);
NonTerminal Terms_28 = new NonTerminal("GlobalList", typeof(Scripting.SSharp.Parser.Ast.ScriptGlobalList), "GlobalList\b", TermOptions.None, 28);
NonTerminal Terms_49 = new NonTerminal("FuncDef", typeof(Scripting.SSharp.Parser.Ast.ScriptFunctionDefinition), "FuncDef\b", TermOptions.None, 49);
NonTerminal Terms_33 = new NonTerminal("ForStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptForStatement), "ForStatement\b", TermOptions.None, 33);
NonTerminal Terms_39 = new NonTerminal("SwitchDefaultStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptSwitchDefaultStatement), "SwitchDefaultStatement\b", TermOptions.None, 39);
NonTerminal Terms_41 = new NonTerminal("TryCatchFinallyStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptTryCatchFinallyStatement), "TryCatchFinallyStatement\b", TermOptions.None, 41);
NonTerminal Terms_69 = new NonTerminal("ExprList?", typeof(AstNode), "\b", TermOptions.None, 69);
NonTerminal Terms_52 = new NonTerminal("Pre Conditions", typeof(Scripting.SSharp.Parser.Ast.ScriptFuncContractPre), "Pre Conditions\b", TermOptions.None, 52);
NonTerminal Terms_38 = new NonTerminal("SwitchCaseStatement", typeof(Scripting.SSharp.Parser.Ast.ScriptSwitchCaseStatement), "SwitchCaseStatement\b", TermOptions.None, 38);
NonTerminal Terms_70 = new NonTerminal("ExprList?", typeof(AstNode), "\b", TermOptions.None, 70);
NonTerminal Terms_53 = new NonTerminal("Post Conditions", typeof(Scripting.SSharp.Parser.Ast.ScriptFuncContractPost), "Post Conditions\b", TermOptions.None, 53);
NonTerminal Terms_50 = new NonTerminal("FuncContract", typeof(Scripting.SSharp.Parser.Ast.ScriptFuncContract), "FuncContract\b", TermOptions.None, 50);
NonTerminal Terms_54 = new NonTerminal("Invariant Conditions", typeof(Scripting.SSharp.Parser.Ast.ScriptFuncContractInv), "Invariant Conditions\b", TermOptions.None, 54);
ActionsRecord fd;
fd = state_0.Actions;
ActionRecord ar_0 = new ActionRecord(ParserActionType.Shift, state_1, null, 0);
fd.Add("Prog'\b", ar_0);
fd.Add("Prog\b", ar_0);
ActionRecord ar_1 = new ActionRecord(ParserActionType.Shift, state_2, null, 0);
fd.Add("Elements\b", ar_1);
ActionRecord ar_2 = new ActionRecord(ParserActionType.Reduce, null, Terms_48, 0);
fd.Add("EOF\b", ar_2);
fd.Add(";", ar_2);
fd.Add("function", ar_2);
fd.Add("if", ar_2);
fd.Add("{", ar_2);
fd.Add("while", ar_2);
fd.Add("for", ar_2);
fd.Add("foreach", ar_2);
fd.Add("using", ar_2);
fd.Add("switch", ar_2);
fd.Add("try", ar_2);
fd.Add("break", ar_2);
fd.Add("continue", ar_2);
fd.Add("return", ar_2);
fd.Add("throw", ar_2);
fd.Add("true", ar_2);
fd.Add("false", ar_2);
fd.Add("null", ar_2);
fd.Add("string\b", ar_2);
fd.Add("number\b", ar_2);
fd.Add("idn\b", ar_2);
fd.Add("var", ar_2);
fd.Add("new", ar_2);
fd.Add("[", ar_2);
fd.Add("(", ar_2);
fd.Add("<!", ar_2);
fd.Add("~", ar_2);
fd.Add("-", ar_2);
fd.Add("!", ar_2);
fd.Add("$", ar_2);
fd.Add("ref", ar_2);
fd.Add("out", ar_2);
fd = state_1.Actions;
ActionRecord ar_3 = new ActionRecord(ParserActionType.Reduce, null, Terms_59, 1);
fd.Add("EOF\b", ar_3);
fd = state_2.Actions;
ActionRecord ar_4 = new ActionRecord(ParserActionType.Shift, state_3, null, 0);
fd.Add("EOF\b", ar_4);
ActionRecord ar_5 = new ActionRecord(ParserActionType.Shift, state_4, null, 0);
fd.Add("Element\b", ar_5);
ActionRecord ar_6 = new ActionRecord(ParserActionType.Shift, state_5, null, 0);
fd.Add("Statement\b", ar_6);
ActionRecord ar_7 = new ActionRecord(ParserActionType.Shift, state_6, null, 0);
fd.Add("FuncDef\b", ar_7);
ActionRecord ar_8 = new ActionRecord(ParserActionType.Shift, state_7, null, 0);
fd.Add(";", ar_8);
ActionRecord ar_9 = new ActionRecord(ParserActionType.Shift, state_8, null, 0);
fd.Add("IfStatement\b", ar_9);
ActionRecord ar_10 = new ActionRecord(ParserActionType.Shift, state_9, null, 0);
fd.Add("WhileStatement\b", ar_10);
ActionRecord ar_11 = new ActionRecord(ParserActionType.Shift, state_10, null, 0);
fd.Add("ForStatement\b", ar_11);
ActionRecord ar_12 = new ActionRecord(ParserActionType.Shift, state_11, null, 0);
fd.Add("ForEachStatement\b", ar_12);
ActionRecord ar_13 = new ActionRecord(ParserActionType.Shift, state_12, null, 0);
fd.Add("UsingStatement\b", ar_13);
ActionRecord ar_14 = new ActionRecord(ParserActionType.Shift, state_13, null, 0);
fd.Add("SwitchStatement\b", ar_14);
ActionRecord ar_15 = new ActionRecord(ParserActionType.Shift, state_14, null, 0);
fd.Add("BlockStatement\b", ar_15);
ActionRecord ar_16 = new ActionRecord(ParserActionType.Shift, state_15, null, 0);
fd.Add("TryCatchFinallyStatement\b", ar_16);
ActionRecord ar_17 = new ActionRecord(ParserActionType.Shift, state_16, null, 0);
fd.Add("ExprStatement\b", ar_17);
ActionRecord ar_18 = new ActionRecord(ParserActionType.Shift, state_17, null, 0);
fd.Add("FlowControl\b", ar_18);
ActionRecord ar_19 = new ActionRecord(ParserActionType.Shift, state_18, null, 0);
fd.Add("function", ar_19);
ActionRecord ar_20 = new ActionRecord(ParserActionType.Shift, state_19, null, 0);
fd.Add("if", ar_20);
ActionRecord ar_21 = new ActionRecord(ParserActionType.Shift, state_20, null, 0);
fd.Add("while", ar_21);
ActionRecord ar_22 = new ActionRecord(ParserActionType.Shift, state_21, null, 0);
fd.Add("for", ar_22);
ActionRecord ar_23 = new ActionRecord(ParserActionType.Shift, state_22, null, 0);
fd.Add("foreach", ar_23);
ActionRecord ar_24 = new ActionRecord(ParserActionType.Shift, state_23, null, 0);
fd.Add("using", ar_24);
ActionRecord ar_25 = new ActionRecord(ParserActionType.Shift, state_24, null, 0);
fd.Add("switch", ar_25);
ActionRecord ar_26 = new ActionRecord(ParserActionType.Shift, state_25, null, 0);
fd.Add("{", ar_26);
ActionRecord ar_27 = new ActionRecord(ParserActionType.Shift, state_26, null, 0);
fd.Add("try", ar_27);
ActionRecord ar_28 = new ActionRecord(ParserActionType.Shift, state_27, null, 0);
fd.Add("Expr\b", ar_28);
ActionRecord ar_29 = new ActionRecord(ParserActionType.Shift, state_28, null, 0);
fd.Add("break", ar_29);
ActionRecord ar_30 = new ActionRecord(ParserActionType.Shift, state_29, null, 0);
fd.Add("continue", ar_30);
ActionRecord ar_31 = new ActionRecord(ParserActionType.Shift, state_30, null, 0);
fd.Add("return", ar_31);
ActionRecord ar_32 = new ActionRecord(ParserActionType.Shift, state_31, null, 0);
fd.Add("throw", ar_32);
ActionRecord ar_33 = new ActionRecord(ParserActionType.Shift, state_32, null, 0);
fd.Add("ConstExpr\b", ar_33);
ActionRecord ar_34 = new ActionRecord(ParserActionType.Shift, state_33, null, 0);
fd.Add("BinExpr\b", ar_34);
ActionRecord ar_35 = new ActionRecord(ParserActionType.Shift, state_34, null, 0);
fd.Add("UnaryExpr\b", ar_35);
ActionRecord ar_36 = new ActionRecord(ParserActionType.Shift, state_35, null, 0);
fd.Add("QualifiedName\b", ar_36);
ActionRecord ar_37 = new ActionRecord(ParserActionType.Shift, state_36, null, 0);
fd.Add("AssignExpr\b", ar_37);
ActionRecord ar_38 = new ActionRecord(ParserActionType.Shift, state_37, null, 0);
fd.Add("NewStmt\b", ar_38);
ActionRecord ar_39 = new ActionRecord(ParserActionType.Shift, state_38, null, 0);
fd.Add("FuncDefExpr\b", ar_39);
ActionRecord ar_40 = new ActionRecord(ParserActionType.Shift, state_39, null, 0);
fd.Add("NewArrStmt\b", ar_40);
ActionRecord ar_41 = new ActionRecord(ParserActionType.Shift, state_40, null, 0);
fd.Add("ArrayConstructor\b", ar_41);
ActionRecord ar_42 = new ActionRecord(ParserActionType.Shift, state_41, null, 0);
fd.Add("MObjectConstructor\b", ar_42);
ActionRecord ar_43 = new ActionRecord(ParserActionType.Shift, state_42, null, 0);
fd.Add("TypeConvertExpr\b", ar_43);
ActionRecord ar_44 = new ActionRecord(ParserActionType.Shift, state_43, null, 0);
fd.Add("MetaExpr\b", ar_44);
ActionRecord ar_45 = new ActionRecord(ParserActionType.Shift, state_44, null, 0);
fd.Add("RefExpr\b", ar_45);
ActionRecord ar_46 = new ActionRecord(ParserActionType.Shift, state_45, null, 0);
fd.Add("VarExpr\b", ar_46);
ActionRecord ar_47 = new ActionRecord(ParserActionType.Shift, state_46, null, 0);
fd.Add("true", ar_47);
ActionRecord ar_48 = new ActionRecord(ParserActionType.Shift, state_47, null, 0);
fd.Add("false", ar_48);
ActionRecord ar_49 = new ActionRecord(ParserActionType.Shift, state_48, null, 0);
fd.Add("null", ar_49);
ActionRecord ar_50 = new ActionRecord(ParserActionType.Shift, state_49, null, 0);
fd.Add("string\b", ar_50);
ActionRecord ar_51 = new ActionRecord(ParserActionType.Shift, state_50, null, 0);
fd.Add("number\b", ar_51);
ActionRecord ar_52 = new ActionRecord(ParserActionType.Shift, state_51, null, 0);
fd.Add("IsExpr\b", ar_52);
ActionRecord ar_53 = new ActionRecord(ParserActionType.Shift, state_52, null, 0);
fd.Add("LUnOp\b", ar_53);
ActionRecord ar_54 = new ActionRecord(ParserActionType.Shift, state_53, null, 0);
fd.Add("idn\b", ar_54);
ActionRecord ar_55 = new ActionRecord(ParserActionType.Shift, state_54, null, 0);
fd.Add("new", ar_55);
ActionRecord ar_56 = new ActionRecord(ParserActionType.Shift, state_55, null, 0);
fd.Add("[", ar_56);
ActionRecord ar_57 = new ActionRecord(ParserActionType.Shift, state_56, null, 0);
fd.Add("(", ar_57);
ActionRecord ar_58 = new ActionRecord(ParserActionType.Shift, state_57, null, 0);
fd.Add("<!", ar_58);
ActionRecord ar_59 = new ActionRecord(ParserActionType.Shift, state_58, null, 0);
fd.Add("\b", ar_59);
ActionRecord ar_60 = new ActionRecord(ParserActionType.Shift, state_59, null, 0);
fd.Add("var", ar_60);
ActionRecord ar_61 = new ActionRecord(ParserActionType.Shift, state_60, null, 0);
fd.Add("~", ar_61);
ActionRecord ar_62 = new ActionRecord(ParserActionType.Shift, state_61, null, 0);
fd.Add("-", ar_62);
ActionRecord ar_63 = new ActionRecord(ParserActionType.Shift, state_62, null, 0);
fd.Add("!", ar_63);
ActionRecord ar_64 = new ActionRecord(ParserActionType.Shift, state_63, null, 0);
fd.Add("$", ar_64);
ActionRecord ar_65 = new ActionRecord(ParserActionType.Shift, state_64, null, 0);
fd.Add("ref", ar_65);
ActionRecord ar_66 = new ActionRecord(ParserActionType.Shift, state_65, null, 0);
fd.Add("out", ar_66);
fd = state_3.Actions;
ActionRecord ar_67 = new ActionRecord(ParserActionType.Reduce, null, Terms_46, 2);
fd.Add("EOF\b", ar_67);
fd = state_4.Actions;
ActionRecord ar_68 = new ActionRecord(ParserActionType.Reduce, null, Terms_48, 2);
fd.Add("EOF\b", ar_68);
fd.Add(";", ar_68);
fd.Add("function", ar_68);
fd.Add("if", ar_68);
fd.Add("{", ar_68);
fd.Add("while", ar_68);
fd.Add("for", ar_68);
fd.Add("foreach", ar_68);
fd.Add("using", ar_68);
fd.Add("switch", ar_68);
fd.Add("try", ar_68);
fd.Add("break", ar_68);
fd.Add("continue", ar_68);
fd.Add("return", ar_68);
fd.Add("throw", ar_68);
fd.Add("true", ar_68);
fd.Add("false", ar_68);
fd.Add("null", ar_68);
fd.Add("string\b", ar_68);
fd.Add("number\b", ar_68);
fd.Add("idn\b", ar_68);
fd.Add("var", ar_68);
fd.Add("new", ar_68);
fd.Add("[", ar_68);
fd.Add("(", ar_68);
fd.Add("<!", ar_68);
fd.Add("~", ar_68);
fd.Add("-", ar_68);
fd.Add("!", ar_68);
fd.Add("$", ar_68);
fd.Add("ref", ar_68);
fd.Add("out", ar_68);
fd.Add("!>", ar_68);
fd = state_5.Actions;
ActionRecord ar_69 = new ActionRecord(ParserActionType.Reduce, null, Terms_47, 1);
fd.Add("EOF\b", ar_69);
fd.Add(";", ar_69);
fd.Add("function", ar_69);
fd.Add("if", ar_69);
fd.Add("{", ar_69);
fd.Add("while", ar_69);
fd.Add("for", ar_69);
fd.Add("foreach", ar_69);
fd.Add("using", ar_69);
fd.Add("switch", ar_69);
fd.Add("try", ar_69);
fd.Add("break", ar_69);
fd.Add("continue", ar_69);
fd.Add("return", ar_69);
fd.Add("throw", ar_69);
fd.Add("true", ar_69);
fd.Add("false", ar_69);
fd.Add("null", ar_69);
fd.Add("string\b", ar_69);
fd.Add("number\b", ar_69);
fd.Add("idn\b", ar_69);
fd.Add("var", ar_69);
fd.Add("new", ar_69);
fd.Add("[", ar_69);
fd.Add("(", ar_69);
fd.Add("<!", ar_69);
fd.Add("~", ar_69);
fd.Add("-", ar_69);
fd.Add("!", ar_69);
fd.Add("$", ar_69);
fd.Add("ref", ar_69);
fd.Add("out", ar_69);
fd.Add("!>", ar_69);
fd = state_6.Actions;
fd.Add("EOF\b", ar_69);
fd.Add(";", ar_69);
fd.Add("function", ar_69);
fd.Add("if", ar_69);
fd.Add("{", ar_69);
fd.Add("while", ar_69);
fd.Add("for", ar_69);
fd.Add("foreach", ar_69);
fd.Add("using", ar_69);
fd.Add("switch", ar_69);
fd.Add("try", ar_69);
fd.Add("break", ar_69);
fd.Add("continue", ar_69);
fd.Add("return", ar_69);
fd.Add("throw", ar_69);
fd.Add("true", ar_69);
fd.Add("false", ar_69);
fd.Add("null", ar_69);
fd.Add("string\b", ar_69);
fd.Add("number\b", ar_69);
fd.Add("idn\b", ar_69);
fd.Add("var", ar_69);
fd.Add("new", ar_69);
fd.Add("[", ar_69);
fd.Add("(", ar_69);
fd.Add("<!", ar_69);
fd.Add("~", ar_69);
fd.Add("-", ar_69);
fd.Add("!", ar_69);
fd.Add("$", ar_69);
fd.Add("ref", ar_69);
fd.Add("out", ar_69);
fd.Add("!>", ar_69);
fd = state_7.Actions;
ActionRecord ar_70 = new ActionRecord(ParserActionType.Reduce, null, Terms_30, 1);
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_8.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_9.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_10.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_11.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_12.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_13.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_14.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_15.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_16.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_17.Actions;
fd.Add("EOF\b", ar_70);
fd.Add(";", ar_70);
fd.Add("function", ar_70);
fd.Add("if", ar_70);
fd.Add("{", ar_70);
fd.Add("while", ar_70);
fd.Add("for", ar_70);
fd.Add("foreach", ar_70);
fd.Add("using", ar_70);
fd.Add("switch", ar_70);
fd.Add("try", ar_70);
fd.Add("break", ar_70);
fd.Add("continue", ar_70);
fd.Add("return", ar_70);
fd.Add("throw", ar_70);
fd.Add("true", ar_70);
fd.Add("false", ar_70);
fd.Add("null", ar_70);
fd.Add("string\b", ar_70);
fd.Add("number\b", ar_70);
fd.Add("idn\b", ar_70);
fd.Add("var", ar_70);
fd.Add("new", ar_70);
fd.Add("[", ar_70);
fd.Add("(", ar_70);
fd.Add("<!", ar_70);
fd.Add("~", ar_70);
fd.Add("-", ar_70);
fd.Add("!", ar_70);
fd.Add("$", ar_70);
fd.Add("ref", ar_70);
fd.Add("out", ar_70);
fd.Add("else", ar_70);
fd.Add("}", ar_70);
fd.Add("!>", ar_70);
fd.Add("default", ar_70);
fd.Add("case", ar_70);
fd = state_18.Actions;
ActionRecord ar_71 = new ActionRecord(ParserActionType.Shift, state_66, null, 0);
fd.Add("(", ar_71);
ActionRecord ar_72 = new ActionRecord(ParserActionType.Shift, state_67, null, 0);
fd.Add("idn\b", ar_72);
fd = state_19.Actions;
ActionRecord ar_73 = new ActionRecord(ParserActionType.Shift, state_68, null, 0);
fd.Add("Condition\b", ar_73);
ActionRecord ar_74 = new ActionRecord(ParserActionType.Shift, state_69, null, 0);
fd.Add("(", ar_74);
fd = state_20.Actions;
ActionRecord ar_75 = new ActionRecord(ParserActionType.Shift, state_70, null, 0);
fd.Add("Condition\b", ar_75);
fd.Add("(", ar_74);
fd = state_21.Actions;
ActionRecord ar_76 = new ActionRecord(ParserActionType.Shift, state_71, null, 0);
fd.Add("(", ar_76);
fd = state_22.Actions;
ActionRecord ar_77 = new ActionRecord(ParserActionType.Shift, state_72, null, 0);
fd.Add("(", ar_77);
fd = state_23.Actions;
ActionRecord ar_78 = new ActionRecord(ParserActionType.Shift, state_73, null, 0);
fd.Add("(", ar_78);
fd = state_24.Actions;
ActionRecord ar_79 = new ActionRecord(ParserActionType.Shift, state_74, null, 0);
fd.Add("(", ar_79);
fd = state_25.Actions;
ActionRecord ar_80 = new ActionRecord(ParserActionType.Shift, state_75, null, 0);
fd.Add("Statements(Compound)\b", ar_80);
ActionRecord ar_81 = new ActionRecord(ParserActionType.Reduce, null, Terms_45, 0);
fd.Add("}", ar_81);
fd.Add(";", ar_81);
fd.Add("if", ar_81);
fd.Add("{", ar_81);
fd.Add("while", ar_81);
fd.Add("for", ar_81);
fd.Add("foreach", ar_81);
fd.Add("using", ar_81);
fd.Add("switch", ar_81);
fd.Add("try", ar_81);
fd.Add("break", ar_81);
fd.Add("continue", ar_81);
fd.Add("return", ar_81);
fd.Add("throw", ar_81);
fd.Add("true", ar_81);
fd.Add("false", ar_81);
fd.Add("null", ar_81);
fd.Add("string\b", ar_81);
fd.Add("number\b", ar_81);
fd.Add("idn\b", ar_81);
fd.Add("var", ar_81);
fd.Add("new", ar_81);
fd.Add("function", ar_81);
fd.Add("[", ar_81);
fd.Add("(", ar_81);
fd.Add("<!", ar_81);
fd.Add("~", ar_81);
fd.Add("-", ar_81);
fd.Add("!", ar_81);
fd.Add("$", ar_81);
fd.Add("ref", ar_81);
fd.Add("out", ar_81);
fd = state_26.Actions;
ActionRecord ar_82 = new ActionRecord(ParserActionType.Shift, state_76, null, 0);
fd.Add("BlockStatement\b", ar_82);
fd.Add("{", ar_26);
fd = state_27.Actions;
ActionRecord ar_83 = new ActionRecord(ParserActionType.Shift, state_77, null, 0);
fd.Add("BinOp\b", ar_83);
ActionRecord ar_84 = new ActionRecord(ParserActionType.Shift, state_78, null, 0);
fd.Add("is", ar_84);
ActionRecord ar_85 = new ActionRecord(ParserActionType.Shift, state_79, null, 0);
fd.Add(";", ar_85);
ActionRecord ar_86 = new ActionRecord(ParserActionType.Shift, state_80, null, 0);
fd.Add("+", ar_86);
ActionRecord ar_87 = new ActionRecord(ParserActionType.Shift, state_81, null, 0);
fd.Add("-", ar_87);
ActionRecord ar_88 = new ActionRecord(ParserActionType.Shift, state_82, null, 0);
fd.Add("*", ar_88);
ActionRecord ar_89 = new ActionRecord(ParserActionType.Shift, state_83, null, 0);
fd.Add("/", ar_89);
ActionRecord ar_90 = new ActionRecord(ParserActionType.Shift, state_84, null, 0);
fd.Add("%", ar_90);
ActionRecord ar_91 = new ActionRecord(ParserActionType.Shift, state_85, null, 0);
fd.Add("^", ar_91);
ActionRecord ar_92 = new ActionRecord(ParserActionType.Shift, state_86, null, 0);
fd.Add("&", ar_92);
ActionRecord ar_93 = new ActionRecord(ParserActionType.Shift, state_87, null, 0);
fd.Add("|", ar_93);
ActionRecord ar_94 = new ActionRecord(ParserActionType.Shift, state_88, null, 0);
fd.Add("&&", ar_94);
ActionRecord ar_95 = new ActionRecord(ParserActionType.Shift, state_89, null, 0);
fd.Add("||", ar_95);
ActionRecord ar_96 = new ActionRecord(ParserActionType.Shift, state_90, null, 0);
fd.Add("==", ar_96);
ActionRecord ar_97 = new ActionRecord(ParserActionType.Shift, state_91, null, 0);
fd.Add("!=", ar_97);
ActionRecord ar_98 = new ActionRecord(ParserActionType.Shift, state_92, null, 0);
fd.Add(">", ar_98);
ActionRecord ar_99 = new ActionRecord(ParserActionType.Shift, state_93, null, 0);
fd.Add("<", ar_99);
ActionRecord ar_100 = new ActionRecord(ParserActionType.Shift, state_94, null, 0);
fd.Add(">=", ar_100);
ActionRecord ar_101 = new ActionRecord(ParserActionType.Shift, state_95, null, 0);
fd.Add("<=", ar_101);
fd = state_28.Actions;
ActionRecord ar_102 = new ActionRecord(ParserActionType.Shift, state_96, null, 0);
fd.Add(";", ar_102);
fd = state_29.Actions;
ActionRecord ar_103 = new ActionRecord(ParserActionType.Shift, state_97, null, 0);
fd.Add(";", ar_103);
fd = state_30.Actions;
ActionRecord ar_104 = new ActionRecord(ParserActionType.Shift, state_98, null, 0);
fd.Add("Expr\b", ar_104);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
ActionRecord ar_105 = new ActionRecord(ParserActionType.Shift, state_99, null, 0);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_31.Actions;
ActionRecord ar_106 = new ActionRecord(ParserActionType.Shift, state_100, null, 0);
fd.Add("Expr\b", ar_106);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_32.Actions;
ActionRecord ar_107 = new ActionRecord(ParserActionType.Reduce, null, Terms_0, 1);
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_33.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_34.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_35.Actions;
ActionRecord ar_108 = new ActionRecord(ParserActionType.Shift, state_101, null, 0);
fd.Add(".", ar_108);
ActionRecord ar_109 = new ActionRecord(ParserActionType.Shift, state_102, null, 0);
fd.Add("=", ar_109);
ActionRecord ar_110 = new ActionRecord(ParserActionType.Shift, state_103, null, 0);
fd.Add("++", ar_110);
ActionRecord ar_111 = new ActionRecord(ParserActionType.Shift, state_104, null, 0);
fd.Add("--", ar_111);
ActionRecord ar_112 = new ActionRecord(ParserActionType.Shift, state_105, null, 0);
fd.Add(":=", ar_112);
ActionRecord ar_113 = new ActionRecord(ParserActionType.Shift, state_106, null, 0);
fd.Add("+=", ar_113);
ActionRecord ar_114 = new ActionRecord(ParserActionType.Shift, state_107, null, 0);
fd.Add("-=", ar_114);
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_36.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_37.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_38.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_39.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_40.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_41.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_42.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_43.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_44.Actions;
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_45.Actions;
ActionRecord ar_115 = new ActionRecord(ParserActionType.Shift, state_108, null, 0);
fd.Add("=", ar_115);
fd.Add(";", ar_107);
fd.Add("+", ar_107);
fd.Add("-", ar_107);
fd.Add("*", ar_107);
fd.Add("/", ar_107);
fd.Add("%", ar_107);
fd.Add("^", ar_107);
fd.Add("&", ar_107);
fd.Add("|", ar_107);
fd.Add("&&", ar_107);
fd.Add("||", ar_107);
fd.Add("==", ar_107);
fd.Add("!=", ar_107);
fd.Add(">", ar_107);
fd.Add("<", ar_107);
fd.Add(">=", ar_107);
fd.Add("<=", ar_107);
fd.Add("is", ar_107);
fd.Add("]", ar_107);
fd.Add(",", ar_107);
fd.Add(")", ar_107);
fd.Add(":", ar_107);
fd = state_46.Actions;
ActionRecord ar_116 = new ActionRecord(ParserActionType.Reduce, null, Terms_1, 1);
fd.Add(";", ar_116);
fd.Add("+", ar_116);
fd.Add("-", ar_116);
fd.Add("*", ar_116);
fd.Add("/", ar_116);
fd.Add("%", ar_116);
fd.Add("^", ar_116);
fd.Add("&", ar_116);
fd.Add("|", ar_116);
fd.Add("&&", ar_116);
fd.Add("||", ar_116);
fd.Add("==", ar_116);
fd.Add("!=", ar_116);
fd.Add(">", ar_116);
fd.Add("<", ar_116);
fd.Add(">=", ar_116);
fd.Add("<=", ar_116);
fd.Add("is", ar_116);
fd.Add("]", ar_116);
fd.Add(",", ar_116);
fd.Add(")", ar_116);
fd.Add(":", ar_116);
fd = state_47.Actions;
fd.Add(";", ar_116);
fd.Add("+", ar_116);
fd.Add("-", ar_116);
fd.Add("*", ar_116);
fd.Add("/", ar_116);
fd.Add("%", ar_116);
fd.Add("^", ar_116);
fd.Add("&", ar_116);
fd.Add("|", ar_116);
fd.Add("&&", ar_116);
fd.Add("||", ar_116);
fd.Add("==", ar_116);
fd.Add("!=", ar_116);
fd.Add(">", ar_116);
fd.Add("<", ar_116);
fd.Add(">=", ar_116);
fd.Add("<=", ar_116);
fd.Add("is", ar_116);
fd.Add("]", ar_116);
fd.Add(",", ar_116);
fd.Add(")", ar_116);
fd.Add(":", ar_116);
fd = state_48.Actions;
fd.Add(";", ar_116);
fd.Add("+", ar_116);
fd.Add("-", ar_116);
fd.Add("*", ar_116);
fd.Add("/", ar_116);
fd.Add("%", ar_116);
fd.Add("^", ar_116);
fd.Add("&", ar_116);
fd.Add("|", ar_116);
fd.Add("&&", ar_116);
fd.Add("||", ar_116);
fd.Add("==", ar_116);
fd.Add("!=", ar_116);
fd.Add(">", ar_116);
fd.Add("<", ar_116);
fd.Add(">=", ar_116);
fd.Add("<=", ar_116);
fd.Add("is", ar_116);
fd.Add("]", ar_116);
fd.Add(",", ar_116);
fd.Add(")", ar_116);
fd.Add(":", ar_116);
fd = state_49.Actions;
fd.Add(";", ar_116);
fd.Add("+", ar_116);
fd.Add("-", ar_116);
fd.Add("*", ar_116);
fd.Add("/", ar_116);
fd.Add("%", ar_116);
fd.Add("^", ar_116);
fd.Add("&", ar_116);
fd.Add("|", ar_116);
fd.Add("&&", ar_116);
fd.Add("||", ar_116);
fd.Add("==", ar_116);
fd.Add("!=", ar_116);
fd.Add(">", ar_116);
fd.Add("<", ar_116);
fd.Add(">=", ar_116);
fd.Add("<=", ar_116);
fd.Add("is", ar_116);
fd.Add("]", ar_116);
fd.Add(",", ar_116);
fd.Add(")", ar_116);
fd.Add(":", ar_116);
fd = state_50.Actions;
fd.Add(";", ar_116);
fd.Add("+", ar_116);
fd.Add("-", ar_116);
fd.Add("*", ar_116);
fd.Add("/", ar_116);
fd.Add("%", ar_116);
fd.Add("^", ar_116);
fd.Add("&", ar_116);
fd.Add("|", ar_116);
fd.Add("&&", ar_116);
fd.Add("||", ar_116);
fd.Add("==", ar_116);
fd.Add("!=", ar_116);
fd.Add(">", ar_116);
fd.Add("<", ar_116);
fd.Add(">=", ar_116);
fd.Add("<=", ar_116);
fd.Add("is", ar_116);
fd.Add("]", ar_116);
fd.Add(",", ar_116);
fd.Add(")", ar_116);
fd.Add(":", ar_116);
fd = state_51.Actions;
ActionRecord ar_117 = new ActionRecord(ParserActionType.Reduce, null, Terms_2, 1);
fd.Add(";", ar_117);
fd.Add("+", ar_117);
fd.Add("-", ar_117);
fd.Add("*", ar_117);
fd.Add("/", ar_117);
fd.Add("%", ar_117);
fd.Add("^", ar_117);
fd.Add("&", ar_117);
fd.Add("|", ar_117);
fd.Add("&&", ar_117);
fd.Add("||", ar_117);
fd.Add("==", ar_117);
fd.Add("!=", ar_117);
fd.Add(">", ar_117);
fd.Add("<", ar_117);
fd.Add(">=", ar_117);
fd.Add("<=", ar_117);
fd.Add("is", ar_117);
fd.Add("]", ar_117);
fd.Add(",", ar_117);
fd.Add(")", ar_117);
fd.Add(":", ar_117);
fd = state_52.Actions;
ActionRecord ar_118 = new ActionRecord(ParserActionType.Shift, state_109, null, 0);
fd.Add("Expr\b", ar_118);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_53.Actions;
ActionRecord ar_119 = new ActionRecord(ParserActionType.Shift, state_110, null, 0);
fd.Add("*\b", ar_119);
ActionRecord ar_120 = new ActionRecord(ParserActionType.Reduce, null, Terms_55, 0);
fd.Add("<|", ar_120);
fd.Add("[", ar_120);
fd.Add("(", ar_120);
fd.Add(".", ar_120);
fd.Add("=", ar_120);
fd.Add("++", ar_120);
fd.Add("--", ar_120);
fd.Add(":=", ar_120);
fd.Add("+=", ar_120);
fd.Add("-=", ar_120);
fd.Add(";", ar_120);
fd.Add("+", ar_120);
fd.Add("-", ar_120);
fd.Add("*", ar_120);
fd.Add("/", ar_120);
fd.Add("%", ar_120);
fd.Add("^", ar_120);
fd.Add("&", ar_120);
fd.Add("|", ar_120);
fd.Add("&&", ar_120);
fd.Add("||", ar_120);
fd.Add("==", ar_120);
fd.Add("!=", ar_120);
fd.Add(">", ar_120);
fd.Add("<", ar_120);
fd.Add(">=", ar_120);
fd.Add("<=", ar_120);
fd.Add("is", ar_120);
fd.Add(")", ar_120);
fd.Add("]", ar_120);
fd.Add(",", ar_120);
fd.Add(":", ar_120);
fd = state_54.Actions;
ActionRecord ar_121 = new ActionRecord(ParserActionType.Shift, state_111, null, 0);
fd.Add("TypeConstructor\b", ar_121);
ActionRecord ar_122 = new ActionRecord(ParserActionType.Shift, state_112, null, 0);
fd.Add("TypeExpr\b", ar_122);
ActionRecord ar_123 = new ActionRecord(ParserActionType.Shift, state_113, null, 0);
fd.Add("idn\b", ar_123);
fd = state_55.Actions;
ActionRecord ar_124 = new ActionRecord(ParserActionType.Shift, state_114, null, 0);
fd.Add("ExprList\b", ar_124);
ActionRecord ar_125 = new ActionRecord(ParserActionType.Shift, state_115, null, 0);
fd.Add("MObjectPart\b", ar_125);
ActionRecord ar_126 = new ActionRecord(ParserActionType.Shift, state_116, null, 0);
fd.Add("Expr\b", ar_126);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
ActionRecord ar_127 = new ActionRecord(ParserActionType.Shift, state_117, null, 0);
fd.Add("idn\b", ar_127);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_56.Actions;
ActionRecord ar_128 = new ActionRecord(ParserActionType.Shift, state_118, null, 0);
fd.Add("Expr\b", ar_128);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_57.Actions;
ActionRecord ar_129 = new ActionRecord(ParserActionType.Shift, state_119, null, 0);
fd.Add("Elements\b", ar_129);
fd.Add("!>", ar_2);
fd.Add(";", ar_2);
fd.Add("function", ar_2);
fd.Add("if", ar_2);
fd.Add("{", ar_2);
fd.Add("while", ar_2);
fd.Add("for", ar_2);
fd.Add("foreach", ar_2);
fd.Add("using", ar_2);
fd.Add("switch", ar_2);
fd.Add("try", ar_2);
fd.Add("break", ar_2);
fd.Add("continue", ar_2);
fd.Add("return", ar_2);
fd.Add("throw", ar_2);
fd.Add("true", ar_2);
fd.Add("false", ar_2);
fd.Add("null", ar_2);
fd.Add("string\b", ar_2);
fd.Add("number\b", ar_2);
fd.Add("idn\b", ar_2);
fd.Add("var", ar_2);
fd.Add("new", ar_2);
fd.Add("[", ar_2);
fd.Add("(", ar_2);
fd.Add("<!", ar_2);
fd.Add("~", ar_2);
fd.Add("-", ar_2);
fd.Add("!", ar_2);
fd.Add("$", ar_2);
fd.Add("ref", ar_2);
fd.Add("out", ar_2);
fd = state_58.Actions;
ActionRecord ar_130 = new ActionRecord(ParserActionType.Shift, state_120, null, 0);
fd.Add("idn\b", ar_130);
fd = state_59.Actions;
ActionRecord ar_131 = new ActionRecord(ParserActionType.Shift, state_121, null, 0);
fd.Add("idn\b", ar_131);
fd = state_60.Actions;
ActionRecord ar_132 = new ActionRecord(ParserActionType.Reduce, null, Terms_16, 1);
fd.Add("true", ar_132);
fd.Add("false", ar_132);
fd.Add("null", ar_132);
fd.Add("string\b", ar_132);
fd.Add("number\b", ar_132);
fd.Add("idn\b", ar_132);
fd.Add("var", ar_132);
fd.Add("new", ar_132);
fd.Add("function", ar_132);
fd.Add("[", ar_132);
fd.Add("(", ar_132);
fd.Add("<!", ar_132);
fd.Add("~", ar_132);
fd.Add("-", ar_132);
fd.Add("!", ar_132);
fd.Add("$", ar_132);
fd.Add("ref", ar_132);
fd.Add("out", ar_132);
fd = state_61.Actions;
fd.Add("true", ar_132);
fd.Add("false", ar_132);
fd.Add("null", ar_132);
fd.Add("string\b", ar_132);
fd.Add("number\b", ar_132);
fd.Add("idn\b", ar_132);
fd.Add("var", ar_132);
fd.Add("new", ar_132);
fd.Add("function", ar_132);
fd.Add("[", ar_132);
fd.Add("(", ar_132);
fd.Add("<!", ar_132);
fd.Add("~", ar_132);
fd.Add("-", ar_132);
fd.Add("!", ar_132);
fd.Add("$", ar_132);
fd.Add("ref", ar_132);
fd.Add("out", ar_132);
fd = state_62.Actions;
fd.Add("true", ar_132);
fd.Add("false", ar_132);
fd.Add("null", ar_132);
fd.Add("string\b", ar_132);
fd.Add("number\b", ar_132);
fd.Add("idn\b", ar_132);
fd.Add("var", ar_132);
fd.Add("new", ar_132);
fd.Add("function", ar_132);
fd.Add("[", ar_132);
fd.Add("(", ar_132);
fd.Add("<!", ar_132);
fd.Add("~", ar_132);
fd.Add("-", ar_132);
fd.Add("!", ar_132);
fd.Add("$", ar_132);
fd.Add("ref", ar_132);
fd.Add("out", ar_132);
fd = state_63.Actions;
fd.Add("true", ar_132);
fd.Add("false", ar_132);
fd.Add("null", ar_132);
fd.Add("string\b", ar_132);
fd.Add("number\b", ar_132);
fd.Add("idn\b", ar_132);
fd.Add("var", ar_132);
fd.Add("new", ar_132);
fd.Add("function", ar_132);
fd.Add("[", ar_132);
fd.Add("(", ar_132);
fd.Add("<!", ar_132);
fd.Add("~", ar_132);
fd.Add("-", ar_132);
fd.Add("!", ar_132);
fd.Add("$", ar_132);
fd.Add("ref", ar_132);
fd.Add("out", ar_132);
fd = state_64.Actions;
ActionRecord ar_133 = new ActionRecord(ParserActionType.Reduce, null, Terms_72, 1);
fd.Add("idn\b", ar_133);
fd = state_65.Actions;
fd.Add("idn\b", ar_133);
fd = state_66.Actions;
ActionRecord ar_134 = new ActionRecord(ParserActionType.Shift, state_122, null, 0);
fd.Add("ParamaterList\b", ar_134);
ActionRecord ar_135 = new ActionRecord(ParserActionType.Shift, state_123, null, 0);
fd.Add("idn+\b", ar_135);
ActionRecord ar_136 = new ActionRecord(ParserActionType.Shift, state_124, null, 0);
fd.Add("idn\b", ar_136);
ActionRecord ar_137 = new ActionRecord(ParserActionType.Reduce, null, Terms_51, 0);
fd.Add(")", ar_137);
fd = state_67.Actions;
ActionRecord ar_138 = new ActionRecord(ParserActionType.Shift, state_125, null, 0);
fd.Add("(", ar_138);
fd = state_68.Actions;
ActionRecord ar_139 = new ActionRecord(ParserActionType.Shift, state_126, null, 0);
fd.Add("Statement\b", ar_139);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_69.Actions;
ActionRecord ar_140 = new ActionRecord(ParserActionType.Shift, state_127, null, 0);
fd.Add("Expr\b", ar_140);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_70.Actions;
ActionRecord ar_141 = new ActionRecord(ParserActionType.Shift, state_128, null, 0);
fd.Add("Statement\b", ar_141);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_71.Actions;
ActionRecord ar_142 = new ActionRecord(ParserActionType.Shift, state_129, null, 0);
fd.Add("OptionalExpression\b", ar_142);
ActionRecord ar_143 = new ActionRecord(ParserActionType.Shift, state_130, null, 0);
fd.Add("Expr\b", ar_143);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_144 = new ActionRecord(ParserActionType.Reduce, null, Terms_35, 0);
fd.Add(";", ar_144);
fd = state_72.Actions;
ActionRecord ar_145 = new ActionRecord(ParserActionType.Shift, state_131, null, 0);
fd.Add("idn\b", ar_145);
fd = state_73.Actions;
ActionRecord ar_146 = new ActionRecord(ParserActionType.Shift, state_132, null, 0);
fd.Add("Expr\b", ar_146);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_74.Actions;
ActionRecord ar_147 = new ActionRecord(ParserActionType.Shift, state_133, null, 0);
fd.Add("Expr\b", ar_147);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_75.Actions;
ActionRecord ar_148 = new ActionRecord(ParserActionType.Shift, state_134, null, 0);
fd.Add("}", ar_148);
ActionRecord ar_149 = new ActionRecord(ParserActionType.Shift, state_135, null, 0);
fd.Add("Statement\b", ar_149);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_76.Actions;
ActionRecord ar_150 = new ActionRecord(ParserActionType.Shift, state_136, null, 0);
fd.Add("catch", ar_150);
fd = state_77.Actions;
ActionRecord ar_151 = new ActionRecord(ParserActionType.Shift, state_137, null, 0);
fd.Add("Expr\b", ar_151);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_78.Actions;
ActionRecord ar_152 = new ActionRecord(ParserActionType.Shift, state_138, null, 0);
fd.Add("TypeExpr\b", ar_152);
fd.Add("idn\b", ar_123);
fd = state_79.Actions;
ActionRecord ar_153 = new ActionRecord(ParserActionType.Reduce, null, Terms_43, 2);
fd.Add("EOF\b", ar_153);
fd.Add(";", ar_153);
fd.Add("function", ar_153);
fd.Add("if", ar_153);
fd.Add("{", ar_153);
fd.Add("while", ar_153);
fd.Add("for", ar_153);
fd.Add("foreach", ar_153);
fd.Add("using", ar_153);
fd.Add("switch", ar_153);
fd.Add("try", ar_153);
fd.Add("break", ar_153);
fd.Add("continue", ar_153);
fd.Add("return", ar_153);
fd.Add("throw", ar_153);
fd.Add("true", ar_153);
fd.Add("false", ar_153);
fd.Add("null", ar_153);
fd.Add("string\b", ar_153);
fd.Add("number\b", ar_153);
fd.Add("idn\b", ar_153);
fd.Add("var", ar_153);
fd.Add("new", ar_153);
fd.Add("[", ar_153);
fd.Add("(", ar_153);
fd.Add("<!", ar_153);
fd.Add("~", ar_153);
fd.Add("-", ar_153);
fd.Add("!", ar_153);
fd.Add("$", ar_153);
fd.Add("ref", ar_153);
fd.Add("out", ar_153);
fd.Add("else", ar_153);
fd.Add("}", ar_153);
fd.Add("!>", ar_153);
fd.Add("default", ar_153);
fd.Add("case", ar_153);
fd = state_80.Actions;
ActionRecord ar_154 = new ActionRecord(ParserActionType.Reduce, null, Terms_15, 1);
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_81.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_82.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_83.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_84.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_85.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_86.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_87.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_88.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_89.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_90.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_91.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_92.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_93.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_94.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_95.Actions;
fd.Add("true", ar_154);
fd.Add("false", ar_154);
fd.Add("null", ar_154);
fd.Add("string\b", ar_154);
fd.Add("number\b", ar_154);
fd.Add("idn\b", ar_154);
fd.Add("var", ar_154);
fd.Add("new", ar_154);
fd.Add("function", ar_154);
fd.Add("[", ar_154);
fd.Add("(", ar_154);
fd.Add("<!", ar_154);
fd.Add("~", ar_154);
fd.Add("-", ar_154);
fd.Add("!", ar_154);
fd.Add("$", ar_154);
fd.Add("ref", ar_154);
fd.Add("out", ar_154);
fd = state_96.Actions;
ActionRecord ar_155 = new ActionRecord(ParserActionType.Reduce, null, Terms_42, 2);
fd.Add("EOF\b", ar_155);
fd.Add(";", ar_155);
fd.Add("function", ar_155);
fd.Add("if", ar_155);
fd.Add("{", ar_155);
fd.Add("while", ar_155);
fd.Add("for", ar_155);
fd.Add("foreach", ar_155);
fd.Add("using", ar_155);
fd.Add("switch", ar_155);
fd.Add("try", ar_155);
fd.Add("break", ar_155);
fd.Add("continue", ar_155);
fd.Add("return", ar_155);
fd.Add("throw", ar_155);
fd.Add("true", ar_155);
fd.Add("false", ar_155);
fd.Add("null", ar_155);
fd.Add("string\b", ar_155);
fd.Add("number\b", ar_155);
fd.Add("idn\b", ar_155);
fd.Add("var", ar_155);
fd.Add("new", ar_155);
fd.Add("[", ar_155);
fd.Add("(", ar_155);
fd.Add("<!", ar_155);
fd.Add("~", ar_155);
fd.Add("-", ar_155);
fd.Add("!", ar_155);
fd.Add("$", ar_155);
fd.Add("ref", ar_155);
fd.Add("out", ar_155);
fd.Add("else", ar_155);
fd.Add("}", ar_155);
fd.Add("!>", ar_155);
fd.Add("default", ar_155);
fd.Add("case", ar_155);
fd = state_97.Actions;
fd.Add("EOF\b", ar_155);
fd.Add(";", ar_155);
fd.Add("function", ar_155);
fd.Add("if", ar_155);
fd.Add("{", ar_155);
fd.Add("while", ar_155);
fd.Add("for", ar_155);
fd.Add("foreach", ar_155);
fd.Add("using", ar_155);
fd.Add("switch", ar_155);
fd.Add("try", ar_155);
fd.Add("break", ar_155);
fd.Add("continue", ar_155);
fd.Add("return", ar_155);
fd.Add("throw", ar_155);
fd.Add("true", ar_155);
fd.Add("false", ar_155);
fd.Add("null", ar_155);
fd.Add("string\b", ar_155);
fd.Add("number\b", ar_155);
fd.Add("idn\b", ar_155);
fd.Add("var", ar_155);
fd.Add("new", ar_155);
fd.Add("[", ar_155);
fd.Add("(", ar_155);
fd.Add("<!", ar_155);
fd.Add("~", ar_155);
fd.Add("-", ar_155);
fd.Add("!", ar_155);
fd.Add("$", ar_155);
fd.Add("ref", ar_155);
fd.Add("out", ar_155);
fd.Add("else", ar_155);
fd.Add("}", ar_155);
fd.Add("!>", ar_155);
fd.Add("default", ar_155);
fd.Add("case", ar_155);
fd = state_98.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
ActionRecord ar_156 = new ActionRecord(ParserActionType.Shift, state_139, null, 0);
fd.Add(";", ar_156);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_99.Actions;
fd.Add("(", ar_71);
fd = state_100.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
ActionRecord ar_157 = new ActionRecord(ParserActionType.Shift, state_140, null, 0);
fd.Add(";", ar_157);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_101.Actions;
ActionRecord ar_158 = new ActionRecord(ParserActionType.Shift, state_141, null, 0);
fd.Add("idn\b", ar_158);
fd = state_102.Actions;
ActionRecord ar_159 = new ActionRecord(ParserActionType.Shift, state_142, null, 0);
fd.Add("Expr\b", ar_159);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_103.Actions;
ActionRecord ar_160 = new ActionRecord(ParserActionType.Reduce, null, Terms_4, 2);
fd.Add(";", ar_160);
fd.Add("+", ar_160);
fd.Add("-", ar_160);
fd.Add("*", ar_160);
fd.Add("/", ar_160);
fd.Add("%", ar_160);
fd.Add("^", ar_160);
fd.Add("&", ar_160);
fd.Add("|", ar_160);
fd.Add("&&", ar_160);
fd.Add("||", ar_160);
fd.Add("==", ar_160);
fd.Add("!=", ar_160);
fd.Add(">", ar_160);
fd.Add("<", ar_160);
fd.Add(">=", ar_160);
fd.Add("<=", ar_160);
fd.Add("is", ar_160);
fd.Add("]", ar_160);
fd.Add(",", ar_160);
fd.Add(")", ar_160);
fd.Add(":", ar_160);
fd = state_104.Actions;
fd.Add(";", ar_160);
fd.Add("+", ar_160);
fd.Add("-", ar_160);
fd.Add("*", ar_160);
fd.Add("/", ar_160);
fd.Add("%", ar_160);
fd.Add("^", ar_160);
fd.Add("&", ar_160);
fd.Add("|", ar_160);
fd.Add("&&", ar_160);
fd.Add("||", ar_160);
fd.Add("==", ar_160);
fd.Add("!=", ar_160);
fd.Add(">", ar_160);
fd.Add("<", ar_160);
fd.Add(">=", ar_160);
fd.Add("<=", ar_160);
fd.Add("is", ar_160);
fd.Add("]", ar_160);
fd.Add(",", ar_160);
fd.Add(")", ar_160);
fd.Add(":", ar_160);
fd = state_105.Actions;
ActionRecord ar_161 = new ActionRecord(ParserActionType.Shift, state_143, null, 0);
fd.Add("Expr\b", ar_161);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_106.Actions;
ActionRecord ar_162 = new ActionRecord(ParserActionType.Shift, state_144, null, 0);
fd.Add("Expr\b", ar_162);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_107.Actions;
ActionRecord ar_163 = new ActionRecord(ParserActionType.Shift, state_145, null, 0);
fd.Add("Expr\b", ar_163);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_108.Actions;
ActionRecord ar_164 = new ActionRecord(ParserActionType.Shift, state_146, null, 0);
fd.Add("Expr\b", ar_164);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_109.Actions;
fd.Add("BinOp\b", ar_83);
ActionRecord ar_165 = new ActionRecord(ParserActionType.Operator, state_78, Terms_3, 2);
fd.Add("is", ar_165);
ActionRecord ar_166 = new ActionRecord(ParserActionType.Operator, state_80, Terms_3, 2);
fd.Add("+", ar_166);
ActionRecord ar_167 = new ActionRecord(ParserActionType.Operator, state_81, Terms_3, 2);
fd.Add("-", ar_167);
ActionRecord ar_168 = new ActionRecord(ParserActionType.Operator, state_82, Terms_3, 2);
fd.Add("*", ar_168);
ActionRecord ar_169 = new ActionRecord(ParserActionType.Operator, state_83, Terms_3, 2);
fd.Add("/", ar_169);
ActionRecord ar_170 = new ActionRecord(ParserActionType.Operator, state_84, Terms_3, 2);
fd.Add("%", ar_170);
ActionRecord ar_171 = new ActionRecord(ParserActionType.Operator, state_85, Terms_3, 2);
fd.Add("^", ar_171);
ActionRecord ar_172 = new ActionRecord(ParserActionType.Operator, state_86, Terms_3, 2);
fd.Add("&", ar_172);
ActionRecord ar_173 = new ActionRecord(ParserActionType.Operator, state_87, Terms_3, 2);
fd.Add("|", ar_173);
ActionRecord ar_174 = new ActionRecord(ParserActionType.Operator, state_88, Terms_3, 2);
fd.Add("&&", ar_174);
ActionRecord ar_175 = new ActionRecord(ParserActionType.Operator, state_89, Terms_3, 2);
fd.Add("||", ar_175);
ActionRecord ar_176 = new ActionRecord(ParserActionType.Operator, state_90, Terms_3, 2);
fd.Add("==", ar_176);
ActionRecord ar_177 = new ActionRecord(ParserActionType.Operator, state_91, Terms_3, 2);
fd.Add("!=", ar_177);
ActionRecord ar_178 = new ActionRecord(ParserActionType.Operator, state_92, Terms_3, 2);
fd.Add(">", ar_178);
ActionRecord ar_179 = new ActionRecord(ParserActionType.Operator, state_93, Terms_3, 2);
fd.Add("<", ar_179);
ActionRecord ar_180 = new ActionRecord(ParserActionType.Operator, state_94, Terms_3, 2);
fd.Add(">=", ar_180);
ActionRecord ar_181 = new ActionRecord(ParserActionType.Operator, state_95, Terms_3, 2);
fd.Add("<=", ar_181);
ActionRecord ar_182 = new ActionRecord(ParserActionType.Reduce, null, Terms_3, 2);
fd.Add(";", ar_182);
fd.Add("]", ar_182);
fd.Add(",", ar_182);
fd.Add(")", ar_182);
fd.Add(":", ar_182);
fd = state_110.Actions;
ActionRecord ar_183 = new ActionRecord(ParserActionType.Shift, state_147, null, 0);
fd.Add("\b", ar_183);
ActionRecord ar_184 = new ActionRecord(ParserActionType.Shift, state_148, null, 0);
fd.Add("GenericsPostfix\b", ar_184);
ActionRecord ar_185 = new ActionRecord(ParserActionType.Shift, state_149, null, 0);
fd.Add("ArrayResolution\b", ar_185);
ActionRecord ar_186 = new ActionRecord(ParserActionType.Shift, state_150, null, 0);
fd.Add("FunctionCall\b", ar_186);
ActionRecord ar_187 = new ActionRecord(ParserActionType.Shift, state_151, null, 0);
fd.Add("<|", ar_187);
ActionRecord ar_188 = new ActionRecord(ParserActionType.Shift, state_152, null, 0);
fd.Add("[", ar_188);
ActionRecord ar_189 = new ActionRecord(ParserActionType.Shift, state_153, null, 0);
fd.Add("(", ar_189);
ActionRecord ar_190 = new ActionRecord(ParserActionType.Reduce, null, Terms_26, 2);
fd.Add(".", ar_190);
fd.Add("=", ar_190);
fd.Add("++", ar_190);
fd.Add("--", ar_190);
fd.Add(":=", ar_190);
fd.Add("+=", ar_190);
fd.Add("-=", ar_190);
fd.Add(";", ar_190);
fd.Add("+", ar_190);
fd.Add("-", ar_190);
fd.Add("*", ar_190);
fd.Add("/", ar_190);
fd.Add("%", ar_190);
fd.Add("^", ar_190);
fd.Add("&", ar_190);
fd.Add("|", ar_190);
fd.Add("&&", ar_190);
fd.Add("||", ar_190);
fd.Add("==", ar_190);
fd.Add("!=", ar_190);
fd.Add(">", ar_190);
fd.Add("<", ar_190);
fd.Add(">=", ar_190);
fd.Add("<=", ar_190);
fd.Add("is", ar_190);
fd.Add("]", ar_190);
fd.Add(",", ar_190);
fd.Add(")", ar_190);
fd.Add(":", ar_190);
fd = state_111.Actions;
ActionRecord ar_191 = new ActionRecord(ParserActionType.Reduce, null, Terms_24, 2);
fd.Add(";", ar_191);
fd.Add("+", ar_191);
fd.Add("-", ar_191);
fd.Add("*", ar_191);
fd.Add("/", ar_191);
fd.Add("%", ar_191);
fd.Add("^", ar_191);
fd.Add("&", ar_191);
fd.Add("|", ar_191);
fd.Add("&&", ar_191);
fd.Add("||", ar_191);
fd.Add("==", ar_191);
fd.Add("!=", ar_191);
fd.Add(">", ar_191);
fd.Add("<", ar_191);
fd.Add(">=", ar_191);
fd.Add("<=", ar_191);
fd.Add("is", ar_191);
fd.Add("]", ar_191);
fd.Add(",", ar_191);
fd.Add(")", ar_191);
fd.Add(":", ar_191);
fd = state_112.Actions;
ActionRecord ar_192 = new ActionRecord(ParserActionType.Shift, state_154, null, 0);
fd.Add(".", ar_192);
ActionRecord ar_193 = new ActionRecord(ParserActionType.Shift, state_155, null, 0);
fd.Add("FunctionCall\b", ar_193);
ActionRecord ar_194 = new ActionRecord(ParserActionType.Shift, state_156, null, 0);
fd.Add("ArrayResolution\b", ar_194);
fd.Add("(", ar_189);
fd.Add("[", ar_188);
fd = state_113.Actions;
ActionRecord ar_195 = new ActionRecord(ParserActionType.Shift, state_157, null, 0);
fd.Add("\b", ar_195);
ActionRecord ar_196 = new ActionRecord(ParserActionType.Shift, state_158, null, 0);
fd.Add("GenericsPostfix\b", ar_196);
fd.Add("<|", ar_187);
ActionRecord ar_197 = new ActionRecord(ParserActionType.Reduce, null, Terms_60, 0);
fd.Add("[", ar_197);
fd.Add("(", ar_197);
fd.Add(".", ar_197);
fd.Add(";", ar_197);
fd.Add("+", ar_197);
fd.Add("-", ar_197);
fd.Add("*", ar_197);
fd.Add("/", ar_197);
fd.Add("%", ar_197);
fd.Add("^", ar_197);
fd.Add("&", ar_197);
fd.Add("|", ar_197);
fd.Add("&&", ar_197);
fd.Add("||", ar_197);
fd.Add("==", ar_197);
fd.Add("!=", ar_197);
fd.Add(">", ar_197);
fd.Add("<", ar_197);
fd.Add(">=", ar_197);
fd.Add("<=", ar_197);
fd.Add("is", ar_197);
fd.Add("|>", ar_197);
fd.Add(",", ar_197);
fd.Add("]", ar_197);
fd.Add(")", ar_197);
fd.Add(":", ar_197);
fd = state_114.Actions;
ActionRecord ar_198 = new ActionRecord(ParserActionType.Shift, state_159, null, 0);
fd.Add(",", ar_198);
ActionRecord ar_199 = new ActionRecord(ParserActionType.Shift, state_160, null, 0);
fd.Add("]", ar_199);
fd = state_115.Actions;
ActionRecord ar_200 = new ActionRecord(ParserActionType.Shift, state_161, Terms_21, 1);
fd.Add("]", ar_200);
ActionRecord ar_201 = new ActionRecord(ParserActionType.Shift, state_162, Terms_21, 1);
fd.Add(",", ar_201);
fd = state_116.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
ActionRecord ar_202 = new ActionRecord(ParserActionType.Reduce, null, Terms_23, 1);
fd.Add("]", ar_202);
fd.Add(",", ar_202);
fd.Add(")", ar_202);
fd = state_117.Actions;
fd.Add("*\b", ar_119);
ActionRecord ar_203 = new ActionRecord(ParserActionType.Shift, state_163, null, 0);
fd.Add("->", ar_203);
fd.Add("<|", ar_120);
fd.Add("[", ar_120);
fd.Add("(", ar_120);
fd.Add(".", ar_120);
fd.Add("=", ar_120);
fd.Add("++", ar_120);
fd.Add("--", ar_120);
fd.Add(":=", ar_120);
fd.Add("+=", ar_120);
fd.Add("-=", ar_120);
fd.Add("+", ar_120);
fd.Add("-", ar_120);
fd.Add("*", ar_120);
fd.Add("/", ar_120);
fd.Add("%", ar_120);
fd.Add("^", ar_120);
fd.Add("&", ar_120);
fd.Add("|", ar_120);
fd.Add("&&", ar_120);
fd.Add("||", ar_120);
fd.Add("==", ar_120);
fd.Add("!=", ar_120);
fd.Add(">", ar_120);
fd.Add("<", ar_120);
fd.Add(">=", ar_120);
fd.Add("<=", ar_120);
fd.Add("is", ar_120);
fd.Add("]", ar_120);
fd.Add(",", ar_120);
fd = state_118.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
ActionRecord ar_204 = new ActionRecord(ParserActionType.Shift, state_164, null, 0);
fd.Add(")", ar_204);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_119.Actions;
fd.Add("Element\b", ar_5);
ActionRecord ar_205 = new ActionRecord(ParserActionType.Shift, state_165, null, 0);
fd.Add("!>", ar_205);
fd.Add("Statement\b", ar_6);
fd.Add("FuncDef\b", ar_7);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("function", ar_19);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_120.Actions;
ActionRecord ar_206 = new ActionRecord(ParserActionType.Reduce, null, Terms_9, 2);
fd.Add(";", ar_206);
fd.Add("+", ar_206);
fd.Add("-", ar_206);
fd.Add("*", ar_206);
fd.Add("/", ar_206);
fd.Add("%", ar_206);
fd.Add("^", ar_206);
fd.Add("&", ar_206);
fd.Add("|", ar_206);
fd.Add("&&", ar_206);
fd.Add("||", ar_206);
fd.Add("==", ar_206);
fd.Add("!=", ar_206);
fd.Add(">", ar_206);
fd.Add("<", ar_206);
fd.Add(">=", ar_206);
fd.Add("<=", ar_206);
fd.Add("is", ar_206);
fd.Add("]", ar_206);
fd.Add(",", ar_206);
fd.Add(")", ar_206);
fd.Add(":", ar_206);
fd = state_121.Actions;
ActionRecord ar_207 = new ActionRecord(ParserActionType.Reduce, null, Terms_10, 2);
fd.Add("=", ar_207);
fd.Add(";", ar_207);
fd.Add("+", ar_207);
fd.Add("-", ar_207);
fd.Add("*", ar_207);
fd.Add("/", ar_207);
fd.Add("%", ar_207);
fd.Add("^", ar_207);
fd.Add("&", ar_207);
fd.Add("|", ar_207);
fd.Add("&&", ar_207);
fd.Add("||", ar_207);
fd.Add("==", ar_207);
fd.Add("!=", ar_207);
fd.Add(">", ar_207);
fd.Add("<", ar_207);
fd.Add(">=", ar_207);
fd.Add("<=", ar_207);
fd.Add("is", ar_207);
fd.Add("]", ar_207);
fd.Add(",", ar_207);
fd.Add(")", ar_207);
fd.Add(":", ar_207);
fd = state_122.Actions;
ActionRecord ar_208 = new ActionRecord(ParserActionType.Shift, state_166, null, 0);
fd.Add(")", ar_208);
fd = state_123.Actions;
ActionRecord ar_209 = new ActionRecord(ParserActionType.Shift, state_167, null, 0);
fd.Add(",", ar_209);
ActionRecord ar_210 = new ActionRecord(ParserActionType.Reduce, null, Terms_51, 1);
fd.Add(")", ar_210);
fd = state_124.Actions;
ActionRecord ar_211 = new ActionRecord(ParserActionType.Reduce, null, Terms_58, 1);
fd.Add(",", ar_211);
fd.Add(")", ar_211);
fd = state_125.Actions;
ActionRecord ar_212 = new ActionRecord(ParserActionType.Shift, state_168, null, 0);
fd.Add("ParamaterList\b", ar_212);
fd.Add("idn+\b", ar_135);
fd.Add("idn\b", ar_136);
fd.Add(")", ar_137);
fd = state_126.Actions;
ActionRecord ar_213 = new ActionRecord(ParserActionType.Shift, state_169, null, 0);
fd.Add("\b", ar_213);
ActionRecord ar_214 = new ActionRecord(ParserActionType.Shift, state_170, Terms_73, 0);
fd.Add("else", ar_214);
ActionRecord ar_215 = new ActionRecord(ParserActionType.Reduce, null, Terms_73, 0);
fd.Add("EOF\b", ar_215);
fd.Add(";", ar_215);
fd.Add("function", ar_215);
fd.Add("if", ar_215);
fd.Add("{", ar_215);
fd.Add("while", ar_215);
fd.Add("for", ar_215);
fd.Add("foreach", ar_215);
fd.Add("using", ar_215);
fd.Add("switch", ar_215);
fd.Add("try", ar_215);
fd.Add("break", ar_215);
fd.Add("continue", ar_215);
fd.Add("return", ar_215);
fd.Add("throw", ar_215);
fd.Add("true", ar_215);
fd.Add("false", ar_215);
fd.Add("null", ar_215);
fd.Add("string\b", ar_215);
fd.Add("number\b", ar_215);
fd.Add("idn\b", ar_215);
fd.Add("var", ar_215);
fd.Add("new", ar_215);
fd.Add("[", ar_215);
fd.Add("(", ar_215);
fd.Add("<!", ar_215);
fd.Add("~", ar_215);
fd.Add("-", ar_215);
fd.Add("!", ar_215);
fd.Add("$", ar_215);
fd.Add("ref", ar_215);
fd.Add("out", ar_215);
fd.Add("}", ar_215);
fd.Add("!>", ar_215);
fd.Add("default", ar_215);
fd.Add("case", ar_215);
fd = state_127.Actions;
ActionRecord ar_216 = new ActionRecord(ParserActionType.Shift, state_171, null, 0);
fd.Add(")", ar_216);
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_128.Actions;
ActionRecord ar_217 = new ActionRecord(ParserActionType.Reduce, null, Terms_32, 3);
fd.Add("EOF\b", ar_217);
fd.Add(";", ar_217);
fd.Add("function", ar_217);
fd.Add("if", ar_217);
fd.Add("{", ar_217);
fd.Add("while", ar_217);
fd.Add("for", ar_217);
fd.Add("foreach", ar_217);
fd.Add("using", ar_217);
fd.Add("switch", ar_217);
fd.Add("try", ar_217);
fd.Add("break", ar_217);
fd.Add("continue", ar_217);
fd.Add("return", ar_217);
fd.Add("throw", ar_217);
fd.Add("true", ar_217);
fd.Add("false", ar_217);
fd.Add("null", ar_217);
fd.Add("string\b", ar_217);
fd.Add("number\b", ar_217);
fd.Add("idn\b", ar_217);
fd.Add("var", ar_217);
fd.Add("new", ar_217);
fd.Add("[", ar_217);
fd.Add("(", ar_217);
fd.Add("<!", ar_217);
fd.Add("~", ar_217);
fd.Add("-", ar_217);
fd.Add("!", ar_217);
fd.Add("$", ar_217);
fd.Add("ref", ar_217);
fd.Add("out", ar_217);
fd.Add("else", ar_217);
fd.Add("}", ar_217);
fd.Add("!>", ar_217);
fd.Add("default", ar_217);
fd.Add("case", ar_217);
fd = state_129.Actions;
ActionRecord ar_218 = new ActionRecord(ParserActionType.Shift, state_172, null, 0);
fd.Add(";", ar_218);
fd = state_130.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
ActionRecord ar_219 = new ActionRecord(ParserActionType.Reduce, null, Terms_35, 1);
fd.Add(";", ar_219);
fd.Add(")", ar_219);
fd = state_131.Actions;
ActionRecord ar_220 = new ActionRecord(ParserActionType.Shift, state_173, null, 0);
fd.Add("in", ar_220);
fd = state_132.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
ActionRecord ar_221 = new ActionRecord(ParserActionType.Shift, state_174, null, 0);
fd.Add(")", ar_221);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_133.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
ActionRecord ar_222 = new ActionRecord(ParserActionType.Shift, state_175, null, 0);
fd.Add(")", ar_222);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_134.Actions;
ActionRecord ar_223 = new ActionRecord(ParserActionType.Reduce, null, Terms_44, 3);
fd.Add("EOF\b", ar_223);
fd.Add(";", ar_223);
fd.Add("function", ar_223);
fd.Add("if", ar_223);
fd.Add("{", ar_223);
fd.Add("while", ar_223);
fd.Add("for", ar_223);
fd.Add("foreach", ar_223);
fd.Add("using", ar_223);
fd.Add("switch", ar_223);
fd.Add("try", ar_223);
fd.Add("break", ar_223);
fd.Add("continue", ar_223);
fd.Add("return", ar_223);
fd.Add("throw", ar_223);
fd.Add("true", ar_223);
fd.Add("false", ar_223);
fd.Add("null", ar_223);
fd.Add("string\b", ar_223);
fd.Add("number\b", ar_223);
fd.Add("idn\b", ar_223);
fd.Add("var", ar_223);
fd.Add("new", ar_223);
fd.Add("[", ar_223);
fd.Add("(", ar_223);
fd.Add("<!", ar_223);
fd.Add("~", ar_223);
fd.Add("-", ar_223);
fd.Add("!", ar_223);
fd.Add("$", ar_223);
fd.Add("ref", ar_223);
fd.Add("out", ar_223);
fd.Add("catch", ar_223);
fd.Add("else", ar_223);
fd.Add("}", ar_223);
fd.Add("!>", ar_223);
fd.Add("+", ar_223);
fd.Add("*", ar_223);
fd.Add("/", ar_223);
fd.Add("%", ar_223);
fd.Add("^", ar_223);
fd.Add("&", ar_223);
fd.Add("|", ar_223);
fd.Add("&&", ar_223);
fd.Add("||", ar_223);
fd.Add("==", ar_223);
fd.Add("!=", ar_223);
fd.Add(">", ar_223);
fd.Add("<", ar_223);
fd.Add(">=", ar_223);
fd.Add("<=", ar_223);
fd.Add("is", ar_223);
fd.Add("finally", ar_223);
fd.Add("default", ar_223);
fd.Add("case", ar_223);
fd.Add("]", ar_223);
fd.Add(",", ar_223);
fd.Add(")", ar_223);
fd.Add(":", ar_223);
fd = state_135.Actions;
ActionRecord ar_224 = new ActionRecord(ParserActionType.Reduce, null, Terms_45, 2);
fd.Add("}", ar_224);
fd.Add(";", ar_224);
fd.Add("if", ar_224);
fd.Add("{", ar_224);
fd.Add("while", ar_224);
fd.Add("for", ar_224);
fd.Add("foreach", ar_224);
fd.Add("using", ar_224);
fd.Add("switch", ar_224);
fd.Add("try", ar_224);
fd.Add("break", ar_224);
fd.Add("continue", ar_224);
fd.Add("return", ar_224);
fd.Add("throw", ar_224);
fd.Add("true", ar_224);
fd.Add("false", ar_224);
fd.Add("null", ar_224);
fd.Add("string\b", ar_224);
fd.Add("number\b", ar_224);
fd.Add("idn\b", ar_224);
fd.Add("var", ar_224);
fd.Add("new", ar_224);
fd.Add("function", ar_224);
fd.Add("[", ar_224);
fd.Add("(", ar_224);
fd.Add("<!", ar_224);
fd.Add("~", ar_224);
fd.Add("-", ar_224);
fd.Add("!", ar_224);
fd.Add("$", ar_224);
fd.Add("ref", ar_224);
fd.Add("out", ar_224);
fd.Add("default", ar_224);
fd.Add("case", ar_224);
fd = state_136.Actions;
ActionRecord ar_225 = new ActionRecord(ParserActionType.Shift, state_176, null, 0);
fd.Add("(", ar_225);
fd = state_137.Actions;
fd.Add("BinOp\b", ar_83);
ActionRecord ar_226 = new ActionRecord(ParserActionType.Operator, state_78, Terms_2, 3);
fd.Add("is", ar_226);
ActionRecord ar_227 = new ActionRecord(ParserActionType.Operator, state_80, Terms_2, 3);
fd.Add("+", ar_227);
ActionRecord ar_228 = new ActionRecord(ParserActionType.Operator, state_81, Terms_2, 3);
fd.Add("-", ar_228);
ActionRecord ar_229 = new ActionRecord(ParserActionType.Operator, state_82, Terms_2, 3);
fd.Add("*", ar_229);
ActionRecord ar_230 = new ActionRecord(ParserActionType.Operator, state_83, Terms_2, 3);
fd.Add("/", ar_230);
ActionRecord ar_231 = new ActionRecord(ParserActionType.Operator, state_84, Terms_2, 3);
fd.Add("%", ar_231);
ActionRecord ar_232 = new ActionRecord(ParserActionType.Operator, state_85, Terms_2, 3);
fd.Add("^", ar_232);
ActionRecord ar_233 = new ActionRecord(ParserActionType.Operator, state_86, Terms_2, 3);
fd.Add("&", ar_233);
ActionRecord ar_234 = new ActionRecord(ParserActionType.Operator, state_87, Terms_2, 3);
fd.Add("|", ar_234);
ActionRecord ar_235 = new ActionRecord(ParserActionType.Operator, state_88, Terms_2, 3);
fd.Add("&&", ar_235);
ActionRecord ar_236 = new ActionRecord(ParserActionType.Operator, state_89, Terms_2, 3);
fd.Add("||", ar_236);
ActionRecord ar_237 = new ActionRecord(ParserActionType.Operator, state_90, Terms_2, 3);
fd.Add("==", ar_237);
ActionRecord ar_238 = new ActionRecord(ParserActionType.Operator, state_91, Terms_2, 3);
fd.Add("!=", ar_238);
ActionRecord ar_239 = new ActionRecord(ParserActionType.Operator, state_92, Terms_2, 3);
fd.Add(">", ar_239);
ActionRecord ar_240 = new ActionRecord(ParserActionType.Operator, state_93, Terms_2, 3);
fd.Add("<", ar_240);
ActionRecord ar_241 = new ActionRecord(ParserActionType.Operator, state_94, Terms_2, 3);
fd.Add(">=", ar_241);
ActionRecord ar_242 = new ActionRecord(ParserActionType.Operator, state_95, Terms_2, 3);
fd.Add("<=", ar_242);
ActionRecord ar_243 = new ActionRecord(ParserActionType.Reduce, null, Terms_2, 3);
fd.Add(";", ar_243);
fd.Add("]", ar_243);
fd.Add(",", ar_243);
fd.Add(")", ar_243);
fd.Add(":", ar_243);
fd = state_138.Actions;
fd.Add(".", ar_192);
ActionRecord ar_244 = new ActionRecord(ParserActionType.Reduce, null, Terms_6, 3);
fd.Add(";", ar_244);
fd.Add("+", ar_244);
fd.Add("-", ar_244);
fd.Add("*", ar_244);
fd.Add("/", ar_244);
fd.Add("%", ar_244);
fd.Add("^", ar_244);
fd.Add("&", ar_244);
fd.Add("|", ar_244);
fd.Add("&&", ar_244);
fd.Add("||", ar_244);
fd.Add("==", ar_244);
fd.Add("!=", ar_244);
fd.Add(">", ar_244);
fd.Add("<", ar_244);
fd.Add(">=", ar_244);
fd.Add("<=", ar_244);
fd.Add("is", ar_244);
fd.Add("]", ar_244);
fd.Add(",", ar_244);
fd.Add(")", ar_244);
fd.Add(":", ar_244);
fd = state_139.Actions;
ActionRecord ar_245 = new ActionRecord(ParserActionType.Reduce, null, Terms_42, 3);
fd.Add("EOF\b", ar_245);
fd.Add(";", ar_245);
fd.Add("function", ar_245);
fd.Add("if", ar_245);
fd.Add("{", ar_245);
fd.Add("while", ar_245);
fd.Add("for", ar_245);
fd.Add("foreach", ar_245);
fd.Add("using", ar_245);
fd.Add("switch", ar_245);
fd.Add("try", ar_245);
fd.Add("break", ar_245);
fd.Add("continue", ar_245);
fd.Add("return", ar_245);
fd.Add("throw", ar_245);
fd.Add("true", ar_245);
fd.Add("false", ar_245);
fd.Add("null", ar_245);
fd.Add("string\b", ar_245);
fd.Add("number\b", ar_245);
fd.Add("idn\b", ar_245);
fd.Add("var", ar_245);
fd.Add("new", ar_245);
fd.Add("[", ar_245);
fd.Add("(", ar_245);
fd.Add("<!", ar_245);
fd.Add("~", ar_245);
fd.Add("-", ar_245);
fd.Add("!", ar_245);
fd.Add("$", ar_245);
fd.Add("ref", ar_245);
fd.Add("out", ar_245);
fd.Add("else", ar_245);
fd.Add("}", ar_245);
fd.Add("!>", ar_245);
fd.Add("default", ar_245);
fd.Add("case", ar_245);
fd = state_140.Actions;
fd.Add("EOF\b", ar_245);
fd.Add(";", ar_245);
fd.Add("function", ar_245);
fd.Add("if", ar_245);
fd.Add("{", ar_245);
fd.Add("while", ar_245);
fd.Add("for", ar_245);
fd.Add("foreach", ar_245);
fd.Add("using", ar_245);
fd.Add("switch", ar_245);
fd.Add("try", ar_245);
fd.Add("break", ar_245);
fd.Add("continue", ar_245);
fd.Add("return", ar_245);
fd.Add("throw", ar_245);
fd.Add("true", ar_245);
fd.Add("false", ar_245);
fd.Add("null", ar_245);
fd.Add("string\b", ar_245);
fd.Add("number\b", ar_245);
fd.Add("idn\b", ar_245);
fd.Add("var", ar_245);
fd.Add("new", ar_245);
fd.Add("[", ar_245);
fd.Add("(", ar_245);
fd.Add("<!", ar_245);
fd.Add("~", ar_245);
fd.Add("-", ar_245);
fd.Add("!", ar_245);
fd.Add("$", ar_245);
fd.Add("ref", ar_245);
fd.Add("out", ar_245);
fd.Add("else", ar_245);
fd.Add("}", ar_245);
fd.Add("!>", ar_245);
fd.Add("default", ar_245);
fd.Add("case", ar_245);
fd = state_141.Actions;
ActionRecord ar_246 = new ActionRecord(ParserActionType.Shift, state_177, null, 0);
fd.Add("*\b", ar_246);
ActionRecord ar_247 = new ActionRecord(ParserActionType.Reduce, null, Terms_56, 0);
fd.Add("<|", ar_247);
fd.Add("[", ar_247);
fd.Add("(", ar_247);
fd.Add(".", ar_247);
fd.Add("=", ar_247);
fd.Add("++", ar_247);
fd.Add("--", ar_247);
fd.Add(":=", ar_247);
fd.Add("+=", ar_247);
fd.Add("-=", ar_247);
fd.Add(";", ar_247);
fd.Add("+", ar_247);
fd.Add("-", ar_247);
fd.Add("*", ar_247);
fd.Add("/", ar_247);
fd.Add("%", ar_247);
fd.Add("^", ar_247);
fd.Add("&", ar_247);
fd.Add("|", ar_247);
fd.Add("&&", ar_247);
fd.Add("||", ar_247);
fd.Add("==", ar_247);
fd.Add("!=", ar_247);
fd.Add(">", ar_247);
fd.Add("<", ar_247);
fd.Add(">=", ar_247);
fd.Add("<=", ar_247);
fd.Add("is", ar_247);
fd.Add("]", ar_247);
fd.Add(",", ar_247);
fd.Add(")", ar_247);
fd.Add(":", ar_247);
fd = state_142.Actions;
fd.Add("BinOp\b", ar_83);
ActionRecord ar_248 = new ActionRecord(ParserActionType.Operator, state_78, Terms_4, 3);
fd.Add("is", ar_248);
ActionRecord ar_249 = new ActionRecord(ParserActionType.Operator, state_80, Terms_4, 3);
fd.Add("+", ar_249);
ActionRecord ar_250 = new ActionRecord(ParserActionType.Operator, state_81, Terms_4, 3);
fd.Add("-", ar_250);
ActionRecord ar_251 = new ActionRecord(ParserActionType.Operator, state_82, Terms_4, 3);
fd.Add("*", ar_251);
ActionRecord ar_252 = new ActionRecord(ParserActionType.Operator, state_83, Terms_4, 3);
fd.Add("/", ar_252);
ActionRecord ar_253 = new ActionRecord(ParserActionType.Operator, state_84, Terms_4, 3);
fd.Add("%", ar_253);
ActionRecord ar_254 = new ActionRecord(ParserActionType.Operator, state_85, Terms_4, 3);
fd.Add("^", ar_254);
ActionRecord ar_255 = new ActionRecord(ParserActionType.Operator, state_86, Terms_4, 3);
fd.Add("&", ar_255);
ActionRecord ar_256 = new ActionRecord(ParserActionType.Operator, state_87, Terms_4, 3);
fd.Add("|", ar_256);
ActionRecord ar_257 = new ActionRecord(ParserActionType.Operator, state_88, Terms_4, 3);
fd.Add("&&", ar_257);
ActionRecord ar_258 = new ActionRecord(ParserActionType.Operator, state_89, Terms_4, 3);
fd.Add("||", ar_258);
ActionRecord ar_259 = new ActionRecord(ParserActionType.Operator, state_90, Terms_4, 3);
fd.Add("==", ar_259);
ActionRecord ar_260 = new ActionRecord(ParserActionType.Operator, state_91, Terms_4, 3);
fd.Add("!=", ar_260);
ActionRecord ar_261 = new ActionRecord(ParserActionType.Operator, state_92, Terms_4, 3);
fd.Add(">", ar_261);
ActionRecord ar_262 = new ActionRecord(ParserActionType.Operator, state_93, Terms_4, 3);
fd.Add("<", ar_262);
ActionRecord ar_263 = new ActionRecord(ParserActionType.Operator, state_94, Terms_4, 3);
fd.Add(">=", ar_263);
ActionRecord ar_264 = new ActionRecord(ParserActionType.Operator, state_95, Terms_4, 3);
fd.Add("<=", ar_264);
ActionRecord ar_265 = new ActionRecord(ParserActionType.Reduce, null, Terms_4, 3);
fd.Add(";", ar_265);
fd.Add("]", ar_265);
fd.Add(",", ar_265);
fd.Add(")", ar_265);
fd.Add(":", ar_265);
fd = state_143.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_248);
fd.Add("+", ar_249);
fd.Add("-", ar_250);
fd.Add("*", ar_251);
fd.Add("/", ar_252);
fd.Add("%", ar_253);
fd.Add("^", ar_254);
fd.Add("&", ar_255);
fd.Add("|", ar_256);
fd.Add("&&", ar_257);
fd.Add("||", ar_258);
fd.Add("==", ar_259);
fd.Add("!=", ar_260);
fd.Add(">", ar_261);
fd.Add("<", ar_262);
fd.Add(">=", ar_263);
fd.Add("<=", ar_264);
fd.Add(";", ar_265);
fd.Add("]", ar_265);
fd.Add(",", ar_265);
fd.Add(")", ar_265);
fd.Add(":", ar_265);
fd = state_144.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_248);
fd.Add("+", ar_249);
fd.Add("-", ar_250);
fd.Add("*", ar_251);
fd.Add("/", ar_252);
fd.Add("%", ar_253);
fd.Add("^", ar_254);
fd.Add("&", ar_255);
fd.Add("|", ar_256);
fd.Add("&&", ar_257);
fd.Add("||", ar_258);
fd.Add("==", ar_259);
fd.Add("!=", ar_260);
fd.Add(">", ar_261);
fd.Add("<", ar_262);
fd.Add(">=", ar_263);
fd.Add("<=", ar_264);
fd.Add(";", ar_265);
fd.Add("]", ar_265);
fd.Add(",", ar_265);
fd.Add(")", ar_265);
fd.Add(":", ar_265);
fd = state_145.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_248);
fd.Add("+", ar_249);
fd.Add("-", ar_250);
fd.Add("*", ar_251);
fd.Add("/", ar_252);
fd.Add("%", ar_253);
fd.Add("^", ar_254);
fd.Add("&", ar_255);
fd.Add("|", ar_256);
fd.Add("&&", ar_257);
fd.Add("||", ar_258);
fd.Add("==", ar_259);
fd.Add("!=", ar_260);
fd.Add(">", ar_261);
fd.Add("<", ar_262);
fd.Add(">=", ar_263);
fd.Add("<=", ar_264);
fd.Add(";", ar_265);
fd.Add("]", ar_265);
fd.Add(",", ar_265);
fd.Add(")", ar_265);
fd.Add(":", ar_265);
fd = state_146.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_248);
fd.Add("+", ar_249);
fd.Add("-", ar_250);
fd.Add("*", ar_251);
fd.Add("/", ar_252);
fd.Add("%", ar_253);
fd.Add("^", ar_254);
fd.Add("&", ar_255);
fd.Add("|", ar_256);
fd.Add("&&", ar_257);
fd.Add("||", ar_258);
fd.Add("==", ar_259);
fd.Add("!=", ar_260);
fd.Add(">", ar_261);
fd.Add("<", ar_262);
fd.Add(">=", ar_263);
fd.Add("<=", ar_264);
fd.Add(";", ar_265);
fd.Add("]", ar_265);
fd.Add(",", ar_265);
fd.Add(")", ar_265);
fd.Add(":", ar_265);
fd = state_147.Actions;
ActionRecord ar_266 = new ActionRecord(ParserActionType.Reduce, null, Terms_55, 2);
fd.Add("<|", ar_266);
fd.Add("[", ar_266);
fd.Add("(", ar_266);
fd.Add(".", ar_266);
fd.Add("=", ar_266);
fd.Add("++", ar_266);
fd.Add("--", ar_266);
fd.Add(":=", ar_266);
fd.Add("+=", ar_266);
fd.Add("-=", ar_266);
fd.Add(";", ar_266);
fd.Add("+", ar_266);
fd.Add("-", ar_266);
fd.Add("*", ar_266);
fd.Add("/", ar_266);
fd.Add("%", ar_266);
fd.Add("^", ar_266);
fd.Add("&", ar_266);
fd.Add("|", ar_266);
fd.Add("&&", ar_266);
fd.Add("||", ar_266);
fd.Add("==", ar_266);
fd.Add("!=", ar_266);
fd.Add(">", ar_266);
fd.Add("<", ar_266);
fd.Add(">=", ar_266);
fd.Add("<=", ar_266);
fd.Add("is", ar_266);
fd.Add("]", ar_266);
fd.Add(",", ar_266);
fd.Add(")", ar_266);
fd.Add(":", ar_266);
fd = state_148.Actions;
ActionRecord ar_267 = new ActionRecord(ParserActionType.Reduce, null, Terms_63, 1);
fd.Add("<|", ar_267);
fd.Add("[", ar_267);
fd.Add("(", ar_267);
fd.Add(".", ar_267);
fd.Add("=", ar_267);
fd.Add("++", ar_267);
fd.Add("--", ar_267);
fd.Add(":=", ar_267);
fd.Add("+=", ar_267);
fd.Add("-=", ar_267);
fd.Add(";", ar_267);
fd.Add("+", ar_267);
fd.Add("-", ar_267);
fd.Add("*", ar_267);
fd.Add("/", ar_267);
fd.Add("%", ar_267);
fd.Add("^", ar_267);
fd.Add("&", ar_267);
fd.Add("|", ar_267);
fd.Add("&&", ar_267);
fd.Add("||", ar_267);
fd.Add("==", ar_267);
fd.Add("!=", ar_267);
fd.Add(">", ar_267);
fd.Add("<", ar_267);
fd.Add(">=", ar_267);
fd.Add("<=", ar_267);
fd.Add("is", ar_267);
fd.Add("]", ar_267);
fd.Add(",", ar_267);
fd.Add(")", ar_267);
fd.Add(":", ar_267);
fd = state_149.Actions;
fd.Add("<|", ar_267);
fd.Add("[", ar_267);
fd.Add("(", ar_267);
fd.Add(".", ar_267);
fd.Add("=", ar_267);
fd.Add("++", ar_267);
fd.Add("--", ar_267);
fd.Add(":=", ar_267);
fd.Add("+=", ar_267);
fd.Add("-=", ar_267);
fd.Add(";", ar_267);
fd.Add("+", ar_267);
fd.Add("-", ar_267);
fd.Add("*", ar_267);
fd.Add("/", ar_267);
fd.Add("%", ar_267);
fd.Add("^", ar_267);
fd.Add("&", ar_267);
fd.Add("|", ar_267);
fd.Add("&&", ar_267);
fd.Add("||", ar_267);
fd.Add("==", ar_267);
fd.Add("!=", ar_267);
fd.Add(">", ar_267);
fd.Add("<", ar_267);
fd.Add(">=", ar_267);
fd.Add("<=", ar_267);
fd.Add("is", ar_267);
fd.Add("]", ar_267);
fd.Add(",", ar_267);
fd.Add(")", ar_267);
fd.Add(":", ar_267);
fd = state_150.Actions;
fd.Add("<|", ar_267);
fd.Add("[", ar_267);
fd.Add("(", ar_267);
fd.Add(".", ar_267);
fd.Add("=", ar_267);
fd.Add("++", ar_267);
fd.Add("--", ar_267);
fd.Add(":=", ar_267);
fd.Add("+=", ar_267);
fd.Add("-=", ar_267);
fd.Add(";", ar_267);
fd.Add("+", ar_267);
fd.Add("-", ar_267);
fd.Add("*", ar_267);
fd.Add("/", ar_267);
fd.Add("%", ar_267);
fd.Add("^", ar_267);
fd.Add("&", ar_267);
fd.Add("|", ar_267);
fd.Add("&&", ar_267);
fd.Add("||", ar_267);
fd.Add("==", ar_267);
fd.Add("!=", ar_267);
fd.Add(">", ar_267);
fd.Add("<", ar_267);
fd.Add(">=", ar_267);
fd.Add("<=", ar_267);
fd.Add("is", ar_267);
fd.Add("]", ar_267);
fd.Add(",", ar_267);
fd.Add(")", ar_267);
fd.Add(":", ar_267);
fd = state_151.Actions;
ActionRecord ar_268 = new ActionRecord(ParserActionType.Shift, state_178, null, 0);
fd.Add("TypeList\b", ar_268);
ActionRecord ar_269 = new ActionRecord(ParserActionType.Shift, state_179, null, 0);
fd.Add("TypeExpr\b", ar_269);
fd.Add("idn\b", ar_123);
fd = state_152.Actions;
ActionRecord ar_270 = new ActionRecord(ParserActionType.Shift, state_180, null, 0);
fd.Add("ExprList\b", ar_270);
fd.Add("Expr\b", ar_126);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_153.Actions;
ActionRecord ar_271 = new ActionRecord(ParserActionType.Shift, state_181, null, 0);
fd.Add("\b", ar_271);
ActionRecord ar_272 = new ActionRecord(ParserActionType.Shift, state_182, null, 0);
fd.Add("ExprList\b", ar_272);
fd.Add("Expr\b", ar_126);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_273 = new ActionRecord(ParserActionType.Reduce, null, Terms_64, 0);
fd.Add(")", ar_273);
fd = state_154.Actions;
ActionRecord ar_274 = new ActionRecord(ParserActionType.Shift, state_183, null, 0);
fd.Add("\b", ar_274);
ActionRecord ar_275 = new ActionRecord(ParserActionType.Shift, state_184, null, 0);
fd.Add("idn\b", ar_275);
fd = state_155.Actions;
ActionRecord ar_276 = new ActionRecord(ParserActionType.Reduce, null, Terms_12, 2);
fd.Add(";", ar_276);
fd.Add("+", ar_276);
fd.Add("-", ar_276);
fd.Add("*", ar_276);
fd.Add("/", ar_276);
fd.Add("%", ar_276);
fd.Add("^", ar_276);
fd.Add("&", ar_276);
fd.Add("|", ar_276);
fd.Add("&&", ar_276);
fd.Add("||", ar_276);
fd.Add("==", ar_276);
fd.Add("!=", ar_276);
fd.Add(">", ar_276);
fd.Add("<", ar_276);
fd.Add(">=", ar_276);
fd.Add("<=", ar_276);
fd.Add("is", ar_276);
fd.Add("]", ar_276);
fd.Add(",", ar_276);
fd.Add(")", ar_276);
fd.Add(":", ar_276);
fd = state_156.Actions;
ActionRecord ar_277 = new ActionRecord(ParserActionType.Reduce, null, Terms_25, 3);
fd.Add(";", ar_277);
fd.Add("+", ar_277);
fd.Add("-", ar_277);
fd.Add("*", ar_277);
fd.Add("/", ar_277);
fd.Add("%", ar_277);
fd.Add("^", ar_277);
fd.Add("&", ar_277);
fd.Add("|", ar_277);
fd.Add("&&", ar_277);
fd.Add("||", ar_277);
fd.Add("==", ar_277);
fd.Add("!=", ar_277);
fd.Add(">", ar_277);
fd.Add("<", ar_277);
fd.Add(">=", ar_277);
fd.Add("<=", ar_277);
fd.Add("is", ar_277);
fd.Add("]", ar_277);
fd.Add(",", ar_277);
fd.Add(")", ar_277);
fd.Add(":", ar_277);
fd = state_157.Actions;
ActionRecord ar_278 = new ActionRecord(ParserActionType.Reduce, null, Terms_11, 2);
fd.Add("[", ar_278);
fd.Add("(", ar_278);
fd.Add(".", ar_278);
fd.Add(";", ar_278);
fd.Add("+", ar_278);
fd.Add("-", ar_278);
fd.Add("*", ar_278);
fd.Add("/", ar_278);
fd.Add("%", ar_278);
fd.Add("^", ar_278);
fd.Add("&", ar_278);
fd.Add("|", ar_278);
fd.Add("&&", ar_278);
fd.Add("||", ar_278);
fd.Add("==", ar_278);
fd.Add("!=", ar_278);
fd.Add(">", ar_278);
fd.Add("<", ar_278);
fd.Add(">=", ar_278);
fd.Add("<=", ar_278);
fd.Add("is", ar_278);
fd.Add("|>", ar_278);
fd.Add(",", ar_278);
fd.Add("]", ar_278);
fd.Add(")", ar_278);
fd.Add(":", ar_278);
fd = state_158.Actions;
ActionRecord ar_279 = new ActionRecord(ParserActionType.Reduce, null, Terms_60, 1);
fd.Add("[", ar_279);
fd.Add("(", ar_279);
fd.Add(".", ar_279);
fd.Add(";", ar_279);
fd.Add("+", ar_279);
fd.Add("-", ar_279);
fd.Add("*", ar_279);
fd.Add("/", ar_279);
fd.Add("%", ar_279);
fd.Add("^", ar_279);
fd.Add("&", ar_279);
fd.Add("|", ar_279);
fd.Add("&&", ar_279);
fd.Add("||", ar_279);
fd.Add("==", ar_279);
fd.Add("!=", ar_279);
fd.Add(">", ar_279);
fd.Add("<", ar_279);
fd.Add(">=", ar_279);
fd.Add("<=", ar_279);
fd.Add("is", ar_279);
fd.Add("|>", ar_279);
fd.Add(",", ar_279);
fd.Add("]", ar_279);
fd.Add(")", ar_279);
fd.Add(":", ar_279);
fd = state_159.Actions;
ActionRecord ar_280 = new ActionRecord(ParserActionType.Shift, state_185, null, 0);
fd.Add("Expr\b", ar_280);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_160.Actions;
ActionRecord ar_281 = new ActionRecord(ParserActionType.Reduce, null, Terms_18, 3);
fd.Add(";", ar_281);
fd.Add("+", ar_281);
fd.Add("-", ar_281);
fd.Add("*", ar_281);
fd.Add("/", ar_281);
fd.Add("%", ar_281);
fd.Add("^", ar_281);
fd.Add("&", ar_281);
fd.Add("|", ar_281);
fd.Add("&&", ar_281);
fd.Add("||", ar_281);
fd.Add("==", ar_281);
fd.Add("!=", ar_281);
fd.Add(">", ar_281);
fd.Add("<", ar_281);
fd.Add(">=", ar_281);
fd.Add("<=", ar_281);
fd.Add("is", ar_281);
fd.Add("]", ar_281);
fd.Add(",", ar_281);
fd.Add(")", ar_281);
fd.Add(":", ar_281);
fd = state_161.Actions;
ActionRecord ar_282 = new ActionRecord(ParserActionType.Reduce, null, Terms_19, 3);
fd.Add(";", ar_282);
fd.Add("+", ar_282);
fd.Add("-", ar_282);
fd.Add("*", ar_282);
fd.Add("/", ar_282);
fd.Add("%", ar_282);
fd.Add("^", ar_282);
fd.Add("&", ar_282);
fd.Add("|", ar_282);
fd.Add("&&", ar_282);
fd.Add("||", ar_282);
fd.Add("==", ar_282);
fd.Add("!=", ar_282);
fd.Add(">", ar_282);
fd.Add("<", ar_282);
fd.Add(">=", ar_282);
fd.Add("<=", ar_282);
fd.Add("is", ar_282);
fd.Add("]", ar_282);
fd.Add(",", ar_282);
fd.Add(")", ar_282);
fd.Add(":", ar_282);
fd = state_162.Actions;
ActionRecord ar_283 = new ActionRecord(ParserActionType.Shift, state_186, null, 0);
fd.Add("MObjectPart\b", ar_283);
ActionRecord ar_284 = new ActionRecord(ParserActionType.Shift, state_187, null, 0);
fd.Add("idn\b", ar_284);
fd = state_163.Actions;
ActionRecord ar_285 = new ActionRecord(ParserActionType.Shift, state_188, null, 0);
fd.Add("Expr\b", ar_285);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_164.Actions;
ActionRecord ar_286 = new ActionRecord(ParserActionType.Shift, state_189, null, 0);
fd.Add("\b", ar_286);
ActionRecord ar_287 = new ActionRecord(ParserActionType.Shift, state_190, null, 0);
fd.Add("Expr\b", ar_287);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
ActionRecord ar_288 = new ActionRecord(ParserActionType.Operator, state_61, Terms_71, 0);
fd.Add("-", ar_288);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_289 = new ActionRecord(ParserActionType.Reduce, null, Terms_71, 0);
fd.Add(";", ar_289);
fd.Add("+", ar_289);
fd.Add("*", ar_289);
fd.Add("/", ar_289);
fd.Add("%", ar_289);
fd.Add("^", ar_289);
fd.Add("&", ar_289);
fd.Add("|", ar_289);
fd.Add("&&", ar_289);
fd.Add("||", ar_289);
fd.Add("==", ar_289);
fd.Add("!=", ar_289);
fd.Add(">", ar_289);
fd.Add("<", ar_289);
fd.Add(">=", ar_289);
fd.Add("<=", ar_289);
fd.Add("is", ar_289);
fd.Add("]", ar_289);
fd.Add(",", ar_289);
fd.Add(")", ar_289);
fd.Add(":", ar_289);
fd = state_165.Actions;
ActionRecord ar_290 = new ActionRecord(ParserActionType.Reduce, null, Terms_7, 3);
fd.Add(";", ar_290);
fd.Add("+", ar_290);
fd.Add("-", ar_290);
fd.Add("*", ar_290);
fd.Add("/", ar_290);
fd.Add("%", ar_290);
fd.Add("^", ar_290);
fd.Add("&", ar_290);
fd.Add("|", ar_290);
fd.Add("&&", ar_290);
fd.Add("||", ar_290);
fd.Add("==", ar_290);
fd.Add("!=", ar_290);
fd.Add(">", ar_290);
fd.Add("<", ar_290);
fd.Add(">=", ar_290);
fd.Add("<=", ar_290);
fd.Add("is", ar_290);
fd.Add("]", ar_290);
fd.Add(",", ar_290);
fd.Add(")", ar_290);
fd.Add(":", ar_290);
fd = state_166.Actions;
ActionRecord ar_291 = new ActionRecord(ParserActionType.Shift, state_191, null, 0);
fd.Add("\b", ar_291);
ActionRecord ar_292 = new ActionRecord(ParserActionType.Shift, state_192, null, 0);
fd.Add("GlobalList\b", ar_292);
ActionRecord ar_293 = new ActionRecord(ParserActionType.Shift, state_193, null, 0);
fd.Add("global", ar_293);
ActionRecord ar_294 = new ActionRecord(ParserActionType.Reduce, null, Terms_66, 0);
fd.Add("{", ar_294);
fd.Add("[", ar_294);
fd = state_167.Actions;
ActionRecord ar_295 = new ActionRecord(ParserActionType.Shift, state_194, null, 0);
fd.Add("idn\b", ar_295);
fd = state_168.Actions;
ActionRecord ar_296 = new ActionRecord(ParserActionType.Shift, state_195, null, 0);
fd.Add(")", ar_296);
fd = state_169.Actions;
ActionRecord ar_297 = new ActionRecord(ParserActionType.Reduce, null, Terms_31, 4);
fd.Add("EOF\b", ar_297);
fd.Add(";", ar_297);
fd.Add("function", ar_297);
fd.Add("if", ar_297);
fd.Add("{", ar_297);
fd.Add("while", ar_297);
fd.Add("for", ar_297);
fd.Add("foreach", ar_297);
fd.Add("using", ar_297);
fd.Add("switch", ar_297);
fd.Add("try", ar_297);
fd.Add("break", ar_297);
fd.Add("continue", ar_297);
fd.Add("return", ar_297);
fd.Add("throw", ar_297);
fd.Add("true", ar_297);
fd.Add("false", ar_297);
fd.Add("null", ar_297);
fd.Add("string\b", ar_297);
fd.Add("number\b", ar_297);
fd.Add("idn\b", ar_297);
fd.Add("var", ar_297);
fd.Add("new", ar_297);
fd.Add("[", ar_297);
fd.Add("(", ar_297);
fd.Add("<!", ar_297);
fd.Add("~", ar_297);
fd.Add("-", ar_297);
fd.Add("!", ar_297);
fd.Add("$", ar_297);
fd.Add("ref", ar_297);
fd.Add("out", ar_297);
fd.Add("else", ar_297);
fd.Add("}", ar_297);
fd.Add("!>", ar_297);
fd.Add("default", ar_297);
fd.Add("case", ar_297);
fd = state_170.Actions;
ActionRecord ar_298 = new ActionRecord(ParserActionType.Shift, state_196, null, 0);
fd.Add("Statement\b", ar_298);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_171.Actions;
ActionRecord ar_299 = new ActionRecord(ParserActionType.Reduce, null, Terms_29, 3);
fd.Add(";", ar_299);
fd.Add("if", ar_299);
fd.Add("{", ar_299);
fd.Add("while", ar_299);
fd.Add("for", ar_299);
fd.Add("foreach", ar_299);
fd.Add("using", ar_299);
fd.Add("switch", ar_299);
fd.Add("try", ar_299);
fd.Add("break", ar_299);
fd.Add("continue", ar_299);
fd.Add("return", ar_299);
fd.Add("throw", ar_299);
fd.Add("true", ar_299);
fd.Add("false", ar_299);
fd.Add("null", ar_299);
fd.Add("string\b", ar_299);
fd.Add("number\b", ar_299);
fd.Add("idn\b", ar_299);
fd.Add("var", ar_299);
fd.Add("new", ar_299);
fd.Add("function", ar_299);
fd.Add("[", ar_299);
fd.Add("(", ar_299);
fd.Add("<!", ar_299);
fd.Add("~", ar_299);
fd.Add("-", ar_299);
fd.Add("!", ar_299);
fd.Add("$", ar_299);
fd.Add("ref", ar_299);
fd.Add("out", ar_299);
fd = state_172.Actions;
ActionRecord ar_300 = new ActionRecord(ParserActionType.Shift, state_197, null, 0);
fd.Add("OptionalExpression\b", ar_300);
fd.Add("Expr\b", ar_143);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd.Add(";", ar_144);
fd = state_173.Actions;
ActionRecord ar_301 = new ActionRecord(ParserActionType.Shift, state_198, null, 0);
fd.Add("Expr\b", ar_301);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_174.Actions;
ActionRecord ar_302 = new ActionRecord(ParserActionType.Shift, state_199, null, 0);
fd.Add("BlockStatement\b", ar_302);
fd.Add("{", ar_26);
fd = state_175.Actions;
ActionRecord ar_303 = new ActionRecord(ParserActionType.Shift, state_200, null, 0);
fd.Add("{", ar_303);
fd = state_176.Actions;
ActionRecord ar_304 = new ActionRecord(ParserActionType.Shift, state_201, null, 0);
fd.Add("idn\b", ar_304);
fd = state_177.Actions;
ActionRecord ar_305 = new ActionRecord(ParserActionType.Shift, state_202, null, 0);
fd.Add("\b", ar_305);
ActionRecord ar_306 = new ActionRecord(ParserActionType.Shift, state_203, null, 0);
fd.Add("GenericsPostfix\b", ar_306);
ActionRecord ar_307 = new ActionRecord(ParserActionType.Shift, state_204, null, 0);
fd.Add("ArrayResolution\b", ar_307);
ActionRecord ar_308 = new ActionRecord(ParserActionType.Shift, state_205, null, 0);
fd.Add("FunctionCall\b", ar_308);
fd.Add("<|", ar_187);
fd.Add("[", ar_188);
fd.Add("(", ar_189);
ActionRecord ar_309 = new ActionRecord(ParserActionType.Reduce, null, Terms_26, 4);
fd.Add(".", ar_309);
fd.Add("=", ar_309);
fd.Add("++", ar_309);
fd.Add("--", ar_309);
fd.Add(":=", ar_309);
fd.Add("+=", ar_309);
fd.Add("-=", ar_309);
fd.Add(";", ar_309);
fd.Add("+", ar_309);
fd.Add("-", ar_309);
fd.Add("*", ar_309);
fd.Add("/", ar_309);
fd.Add("%", ar_309);
fd.Add("^", ar_309);
fd.Add("&", ar_309);
fd.Add("|", ar_309);
fd.Add("&&", ar_309);
fd.Add("||", ar_309);
fd.Add("==", ar_309);
fd.Add("!=", ar_309);
fd.Add(">", ar_309);
fd.Add("<", ar_309);
fd.Add(">=", ar_309);
fd.Add("<=", ar_309);
fd.Add("is", ar_309);
fd.Add("]", ar_309);
fd.Add(",", ar_309);
fd.Add(")", ar_309);
fd.Add(":", ar_309);
fd = state_178.Actions;
ActionRecord ar_310 = new ActionRecord(ParserActionType.Shift, state_206, null, 0);
fd.Add("|>", ar_310);
ActionRecord ar_311 = new ActionRecord(ParserActionType.Shift, state_207, null, 0);
fd.Add(",", ar_311);
fd = state_179.Actions;
fd.Add(".", ar_192);
ActionRecord ar_312 = new ActionRecord(ParserActionType.Reduce, null, Terms_22, 1);
fd.Add("|>", ar_312);
fd.Add(",", ar_312);
fd = state_180.Actions;
ActionRecord ar_313 = new ActionRecord(ParserActionType.Shift, state_208, null, 0);
fd.Add("]", ar_313);
fd.Add(",", ar_198);
fd = state_181.Actions;
ActionRecord ar_314 = new ActionRecord(ParserActionType.Shift, state_209, null, 0);
fd.Add(")", ar_314);
fd.Add("idn\b", ar_130);
fd = state_182.Actions;
fd.Add(",", ar_198);
ActionRecord ar_315 = new ActionRecord(ParserActionType.Reduce, null, Terms_64, 1);
fd.Add(")", ar_315);
fd = state_183.Actions;
ActionRecord ar_316 = new ActionRecord(ParserActionType.Reduce, null, Terms_11, 3);
fd.Add("[", ar_316);
fd.Add("(", ar_316);
fd.Add(".", ar_316);
fd.Add(";", ar_316);
fd.Add("+", ar_316);
fd.Add("-", ar_316);
fd.Add("*", ar_316);
fd.Add("/", ar_316);
fd.Add("%", ar_316);
fd.Add("^", ar_316);
fd.Add("&", ar_316);
fd.Add("|", ar_316);
fd.Add("&&", ar_316);
fd.Add("||", ar_316);
fd.Add("==", ar_316);
fd.Add("!=", ar_316);
fd.Add(">", ar_316);
fd.Add("<", ar_316);
fd.Add(">=", ar_316);
fd.Add("<=", ar_316);
fd.Add("is", ar_316);
fd.Add("|>", ar_316);
fd.Add(",", ar_316);
fd.Add("]", ar_316);
fd.Add(")", ar_316);
fd.Add(":", ar_316);
fd = state_184.Actions;
ActionRecord ar_317 = new ActionRecord(ParserActionType.Shift, state_210, null, 0);
fd.Add("\b", ar_317);
ActionRecord ar_318 = new ActionRecord(ParserActionType.Shift, state_211, null, 0);
fd.Add("GenericsPostfix\b", ar_318);
fd.Add("<|", ar_187);
ActionRecord ar_319 = new ActionRecord(ParserActionType.Reduce, null, Terms_62, 0);
fd.Add("[", ar_319);
fd.Add("(", ar_319);
fd.Add(".", ar_319);
fd.Add(";", ar_319);
fd.Add("+", ar_319);
fd.Add("-", ar_319);
fd.Add("*", ar_319);
fd.Add("/", ar_319);
fd.Add("%", ar_319);
fd.Add("^", ar_319);
fd.Add("&", ar_319);
fd.Add("|", ar_319);
fd.Add("&&", ar_319);
fd.Add("||", ar_319);
fd.Add("==", ar_319);
fd.Add("!=", ar_319);
fd.Add(">", ar_319);
fd.Add("<", ar_319);
fd.Add(">=", ar_319);
fd.Add("<=", ar_319);
fd.Add("is", ar_319);
fd.Add("|>", ar_319);
fd.Add(",", ar_319);
fd.Add("]", ar_319);
fd.Add(")", ar_319);
fd.Add(":", ar_319);
fd = state_185.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
ActionRecord ar_320 = new ActionRecord(ParserActionType.Reduce, null, Terms_23, 3);
fd.Add("]", ar_320);
fd.Add(",", ar_320);
fd.Add(")", ar_320);
fd = state_186.Actions;
ActionRecord ar_321 = new ActionRecord(ParserActionType.Reduce, null, Terms_21, 3);
fd.Add("]", ar_321);
fd.Add(",", ar_321);
fd = state_187.Actions;
fd.Add("->", ar_203);
fd = state_188.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
ActionRecord ar_322 = new ActionRecord(ParserActionType.Reduce, null, Terms_20, 3);
fd.Add("]", ar_322);
fd.Add(",", ar_322);
fd = state_189.Actions;
fd.Add("idn\b", ar_130);
ActionRecord ar_323 = new ActionRecord(ParserActionType.Reduce, null, Terms_5, 4);
fd.Add(";", ar_323);
fd.Add("+", ar_323);
fd.Add("-", ar_323);
fd.Add("*", ar_323);
fd.Add("/", ar_323);
fd.Add("%", ar_323);
fd.Add("^", ar_323);
fd.Add("&", ar_323);
fd.Add("|", ar_323);
fd.Add("&&", ar_323);
fd.Add("||", ar_323);
fd.Add("==", ar_323);
fd.Add("!=", ar_323);
fd.Add(">", ar_323);
fd.Add("<", ar_323);
fd.Add(">=", ar_323);
fd.Add("<=", ar_323);
fd.Add("is", ar_323);
fd.Add("]", ar_323);
fd.Add(",", ar_323);
fd.Add(")", ar_323);
fd.Add(":", ar_323);
fd = state_190.Actions;
fd.Add("BinOp\b", ar_83);
ActionRecord ar_324 = new ActionRecord(ParserActionType.Operator, state_78, Terms_71, 1);
fd.Add("is", ar_324);
ActionRecord ar_325 = new ActionRecord(ParserActionType.Operator, state_80, Terms_71, 1);
fd.Add("+", ar_325);
ActionRecord ar_326 = new ActionRecord(ParserActionType.Operator, state_81, Terms_71, 1);
fd.Add("-", ar_326);
ActionRecord ar_327 = new ActionRecord(ParserActionType.Operator, state_82, Terms_71, 1);
fd.Add("*", ar_327);
ActionRecord ar_328 = new ActionRecord(ParserActionType.Operator, state_83, Terms_71, 1);
fd.Add("/", ar_328);
ActionRecord ar_329 = new ActionRecord(ParserActionType.Operator, state_84, Terms_71, 1);
fd.Add("%", ar_329);
ActionRecord ar_330 = new ActionRecord(ParserActionType.Operator, state_85, Terms_71, 1);
fd.Add("^", ar_330);
ActionRecord ar_331 = new ActionRecord(ParserActionType.Operator, state_86, Terms_71, 1);
fd.Add("&", ar_331);
ActionRecord ar_332 = new ActionRecord(ParserActionType.Operator, state_87, Terms_71, 1);
fd.Add("|", ar_332);
ActionRecord ar_333 = new ActionRecord(ParserActionType.Operator, state_88, Terms_71, 1);
fd.Add("&&", ar_333);
ActionRecord ar_334 = new ActionRecord(ParserActionType.Operator, state_89, Terms_71, 1);
fd.Add("||", ar_334);
ActionRecord ar_335 = new ActionRecord(ParserActionType.Operator, state_90, Terms_71, 1);
fd.Add("==", ar_335);
ActionRecord ar_336 = new ActionRecord(ParserActionType.Operator, state_91, Terms_71, 1);
fd.Add("!=", ar_336);
ActionRecord ar_337 = new ActionRecord(ParserActionType.Operator, state_92, Terms_71, 1);
fd.Add(">", ar_337);
ActionRecord ar_338 = new ActionRecord(ParserActionType.Operator, state_93, Terms_71, 1);
fd.Add("<", ar_338);
ActionRecord ar_339 = new ActionRecord(ParserActionType.Operator, state_94, Terms_71, 1);
fd.Add(">=", ar_339);
ActionRecord ar_340 = new ActionRecord(ParserActionType.Operator, state_95, Terms_71, 1);
fd.Add("<=", ar_340);
ActionRecord ar_341 = new ActionRecord(ParserActionType.Reduce, null, Terms_71, 1);
fd.Add(";", ar_341);
fd.Add("]", ar_341);
fd.Add(",", ar_341);
fd.Add(")", ar_341);
fd.Add(":", ar_341);
fd = state_191.Actions;
ActionRecord ar_342 = new ActionRecord(ParserActionType.Shift, state_212, null, 0);
fd.Add("\b", ar_342);
ActionRecord ar_343 = new ActionRecord(ParserActionType.Shift, state_213, null, 0);
fd.Add("FuncContract\b", ar_343);
ActionRecord ar_344 = new ActionRecord(ParserActionType.Shift, state_214, null, 0);
fd.Add("[", ar_344);
ActionRecord ar_345 = new ActionRecord(ParserActionType.Reduce, null, Terms_67, 0);
fd.Add("{", ar_345);
fd = state_192.Actions;
ActionRecord ar_346 = new ActionRecord(ParserActionType.Reduce, null, Terms_66, 1);
fd.Add("{", ar_346);
fd.Add("[", ar_346);
fd = state_193.Actions;
ActionRecord ar_347 = new ActionRecord(ParserActionType.Shift, state_215, null, 0);
fd.Add("(", ar_347);
fd = state_194.Actions;
ActionRecord ar_348 = new ActionRecord(ParserActionType.Reduce, null, Terms_58, 3);
fd.Add(",", ar_348);
fd.Add(")", ar_348);
fd = state_195.Actions;
ActionRecord ar_349 = new ActionRecord(ParserActionType.Shift, state_216, null, 0);
fd.Add("\b", ar_349);
ActionRecord ar_350 = new ActionRecord(ParserActionType.Shift, state_217, null, 0);
fd.Add("GlobalList\b", ar_350);
fd.Add("global", ar_293);
ActionRecord ar_351 = new ActionRecord(ParserActionType.Reduce, null, Terms_75, 0);
fd.Add("{", ar_351);
fd.Add("[", ar_351);
fd = state_196.Actions;
ActionRecord ar_352 = new ActionRecord(ParserActionType.Reduce, null, Terms_73, 2);
fd.Add("EOF\b", ar_352);
fd.Add(";", ar_352);
fd.Add("function", ar_352);
fd.Add("if", ar_352);
fd.Add("{", ar_352);
fd.Add("while", ar_352);
fd.Add("for", ar_352);
fd.Add("foreach", ar_352);
fd.Add("using", ar_352);
fd.Add("switch", ar_352);
fd.Add("try", ar_352);
fd.Add("break", ar_352);
fd.Add("continue", ar_352);
fd.Add("return", ar_352);
fd.Add("throw", ar_352);
fd.Add("true", ar_352);
fd.Add("false", ar_352);
fd.Add("null", ar_352);
fd.Add("string\b", ar_352);
fd.Add("number\b", ar_352);
fd.Add("idn\b", ar_352);
fd.Add("var", ar_352);
fd.Add("new", ar_352);
fd.Add("[", ar_352);
fd.Add("(", ar_352);
fd.Add("<!", ar_352);
fd.Add("~", ar_352);
fd.Add("-", ar_352);
fd.Add("!", ar_352);
fd.Add("$", ar_352);
fd.Add("ref", ar_352);
fd.Add("out", ar_352);
fd.Add("else", ar_352);
fd.Add("}", ar_352);
fd.Add("!>", ar_352);
fd.Add("default", ar_352);
fd.Add("case", ar_352);
fd = state_197.Actions;
ActionRecord ar_353 = new ActionRecord(ParserActionType.Shift, state_218, null, 0);
fd.Add(";", ar_353);
fd = state_198.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
ActionRecord ar_354 = new ActionRecord(ParserActionType.Shift, state_219, null, 0);
fd.Add(")", ar_354);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_199.Actions;
ActionRecord ar_355 = new ActionRecord(ParserActionType.Reduce, null, Terms_40, 5);
fd.Add("EOF\b", ar_355);
fd.Add(";", ar_355);
fd.Add("function", ar_355);
fd.Add("if", ar_355);
fd.Add("{", ar_355);
fd.Add("while", ar_355);
fd.Add("for", ar_355);
fd.Add("foreach", ar_355);
fd.Add("using", ar_355);
fd.Add("switch", ar_355);
fd.Add("try", ar_355);
fd.Add("break", ar_355);
fd.Add("continue", ar_355);
fd.Add("return", ar_355);
fd.Add("throw", ar_355);
fd.Add("true", ar_355);
fd.Add("false", ar_355);
fd.Add("null", ar_355);
fd.Add("string\b", ar_355);
fd.Add("number\b", ar_355);
fd.Add("idn\b", ar_355);
fd.Add("var", ar_355);
fd.Add("new", ar_355);
fd.Add("[", ar_355);
fd.Add("(", ar_355);
fd.Add("<!", ar_355);
fd.Add("~", ar_355);
fd.Add("-", ar_355);
fd.Add("!", ar_355);
fd.Add("$", ar_355);
fd.Add("ref", ar_355);
fd.Add("out", ar_355);
fd.Add("else", ar_355);
fd.Add("}", ar_355);
fd.Add("!>", ar_355);
fd.Add("default", ar_355);
fd.Add("case", ar_355);
fd = state_200.Actions;
ActionRecord ar_356 = new ActionRecord(ParserActionType.Shift, state_220, null, 0);
fd.Add("SwitchStatements\b", ar_356);
ActionRecord ar_357 = new ActionRecord(ParserActionType.Shift, state_221, null, 0);
fd.Add("SwitchCaseStatement*\b", ar_357);
ActionRecord ar_358 = new ActionRecord(ParserActionType.Reduce, null, Terms_57, 0);
fd.Add("default", ar_358);
fd.Add("case", ar_358);
fd.Add("}", ar_358);
fd = state_201.Actions;
ActionRecord ar_359 = new ActionRecord(ParserActionType.Shift, state_222, null, 0);
fd.Add(")", ar_359);
fd = state_202.Actions;
ActionRecord ar_360 = new ActionRecord(ParserActionType.Reduce, null, Terms_56, 2);
fd.Add("<|", ar_360);
fd.Add("[", ar_360);
fd.Add("(", ar_360);
fd.Add(".", ar_360);
fd.Add("=", ar_360);
fd.Add("++", ar_360);
fd.Add("--", ar_360);
fd.Add(":=", ar_360);
fd.Add("+=", ar_360);
fd.Add("-=", ar_360);
fd.Add(";", ar_360);
fd.Add("+", ar_360);
fd.Add("-", ar_360);
fd.Add("*", ar_360);
fd.Add("/", ar_360);
fd.Add("%", ar_360);
fd.Add("^", ar_360);
fd.Add("&", ar_360);
fd.Add("|", ar_360);
fd.Add("&&", ar_360);
fd.Add("||", ar_360);
fd.Add("==", ar_360);
fd.Add("!=", ar_360);
fd.Add(">", ar_360);
fd.Add("<", ar_360);
fd.Add(">=", ar_360);
fd.Add("<=", ar_360);
fd.Add("is", ar_360);
fd.Add("]", ar_360);
fd.Add(",", ar_360);
fd.Add(")", ar_360);
fd.Add(":", ar_360);
fd = state_203.Actions;
ActionRecord ar_361 = new ActionRecord(ParserActionType.Reduce, null, Terms_65, 1);
fd.Add("<|", ar_361);
fd.Add("[", ar_361);
fd.Add("(", ar_361);
fd.Add(".", ar_361);
fd.Add("=", ar_361);
fd.Add("++", ar_361);
fd.Add("--", ar_361);
fd.Add(":=", ar_361);
fd.Add("+=", ar_361);
fd.Add("-=", ar_361);
fd.Add(";", ar_361);
fd.Add("+", ar_361);
fd.Add("-", ar_361);
fd.Add("*", ar_361);
fd.Add("/", ar_361);
fd.Add("%", ar_361);
fd.Add("^", ar_361);
fd.Add("&", ar_361);
fd.Add("|", ar_361);
fd.Add("&&", ar_361);
fd.Add("||", ar_361);
fd.Add("==", ar_361);
fd.Add("!=", ar_361);
fd.Add(">", ar_361);
fd.Add("<", ar_361);
fd.Add(">=", ar_361);
fd.Add("<=", ar_361);
fd.Add("is", ar_361);
fd.Add("]", ar_361);
fd.Add(",", ar_361);
fd.Add(")", ar_361);
fd.Add(":", ar_361);
fd = state_204.Actions;
fd.Add("<|", ar_361);
fd.Add("[", ar_361);
fd.Add("(", ar_361);
fd.Add(".", ar_361);
fd.Add("=", ar_361);
fd.Add("++", ar_361);
fd.Add("--", ar_361);
fd.Add(":=", ar_361);
fd.Add("+=", ar_361);
fd.Add("-=", ar_361);
fd.Add(";", ar_361);
fd.Add("+", ar_361);
fd.Add("-", ar_361);
fd.Add("*", ar_361);
fd.Add("/", ar_361);
fd.Add("%", ar_361);
fd.Add("^", ar_361);
fd.Add("&", ar_361);
fd.Add("|", ar_361);
fd.Add("&&", ar_361);
fd.Add("||", ar_361);
fd.Add("==", ar_361);
fd.Add("!=", ar_361);
fd.Add(">", ar_361);
fd.Add("<", ar_361);
fd.Add(">=", ar_361);
fd.Add("<=", ar_361);
fd.Add("is", ar_361);
fd.Add("]", ar_361);
fd.Add(",", ar_361);
fd.Add(")", ar_361);
fd.Add(":", ar_361);
fd = state_205.Actions;
fd.Add("<|", ar_361);
fd.Add("[", ar_361);
fd.Add("(", ar_361);
fd.Add(".", ar_361);
fd.Add("=", ar_361);
fd.Add("++", ar_361);
fd.Add("--", ar_361);
fd.Add(":=", ar_361);
fd.Add("+=", ar_361);
fd.Add("-=", ar_361);
fd.Add(";", ar_361);
fd.Add("+", ar_361);
fd.Add("-", ar_361);
fd.Add("*", ar_361);
fd.Add("/", ar_361);
fd.Add("%", ar_361);
fd.Add("^", ar_361);
fd.Add("&", ar_361);
fd.Add("|", ar_361);
fd.Add("&&", ar_361);
fd.Add("||", ar_361);
fd.Add("==", ar_361);
fd.Add("!=", ar_361);
fd.Add(">", ar_361);
fd.Add("<", ar_361);
fd.Add(">=", ar_361);
fd.Add("<=", ar_361);
fd.Add("is", ar_361);
fd.Add("]", ar_361);
fd.Add(",", ar_361);
fd.Add(")", ar_361);
fd.Add(":", ar_361);
fd = state_206.Actions;
ActionRecord ar_362 = new ActionRecord(ParserActionType.Reduce, null, Terms_27, 3);
fd.Add("<|", ar_362);
fd.Add("[", ar_362);
fd.Add("(", ar_362);
fd.Add(".", ar_362);
fd.Add("=", ar_362);
fd.Add("++", ar_362);
fd.Add("--", ar_362);
fd.Add(":=", ar_362);
fd.Add("+=", ar_362);
fd.Add("-=", ar_362);
fd.Add(";", ar_362);
fd.Add("+", ar_362);
fd.Add("-", ar_362);
fd.Add("*", ar_362);
fd.Add("/", ar_362);
fd.Add("%", ar_362);
fd.Add("^", ar_362);
fd.Add("&", ar_362);
fd.Add("|", ar_362);
fd.Add("&&", ar_362);
fd.Add("||", ar_362);
fd.Add("==", ar_362);
fd.Add("!=", ar_362);
fd.Add(">", ar_362);
fd.Add("<", ar_362);
fd.Add(">=", ar_362);
fd.Add("<=", ar_362);
fd.Add("is", ar_362);
fd.Add("]", ar_362);
fd.Add(",", ar_362);
fd.Add(")", ar_362);
fd.Add(":", ar_362);
fd.Add("|>", ar_362);
fd = state_207.Actions;
ActionRecord ar_363 = new ActionRecord(ParserActionType.Shift, state_223, null, 0);
fd.Add("TypeExpr\b", ar_363);
fd.Add("idn\b", ar_123);
fd = state_208.Actions;
ActionRecord ar_364 = new ActionRecord(ParserActionType.Reduce, null, Terms_14, 3);
fd.Add("<|", ar_364);
fd.Add("[", ar_364);
fd.Add("(", ar_364);
fd.Add(".", ar_364);
fd.Add("=", ar_364);
fd.Add("++", ar_364);
fd.Add("--", ar_364);
fd.Add(":=", ar_364);
fd.Add("+=", ar_364);
fd.Add("-=", ar_364);
fd.Add(";", ar_364);
fd.Add("+", ar_364);
fd.Add("-", ar_364);
fd.Add("*", ar_364);
fd.Add("/", ar_364);
fd.Add("%", ar_364);
fd.Add("^", ar_364);
fd.Add("&", ar_364);
fd.Add("|", ar_364);
fd.Add("&&", ar_364);
fd.Add("||", ar_364);
fd.Add("==", ar_364);
fd.Add("!=", ar_364);
fd.Add(">", ar_364);
fd.Add("<", ar_364);
fd.Add(">=", ar_364);
fd.Add("<=", ar_364);
fd.Add("is", ar_364);
fd.Add("]", ar_364);
fd.Add(",", ar_364);
fd.Add(")", ar_364);
fd.Add(":", ar_364);
fd = state_209.Actions;
ActionRecord ar_365 = new ActionRecord(ParserActionType.Reduce, null, Terms_13, 3);
fd.Add("<|", ar_365);
fd.Add("[", ar_365);
fd.Add("(", ar_365);
fd.Add(".", ar_365);
fd.Add("=", ar_365);
fd.Add("++", ar_365);
fd.Add("--", ar_365);
fd.Add(":=", ar_365);
fd.Add("+=", ar_365);
fd.Add("-=", ar_365);
fd.Add(";", ar_365);
fd.Add("+", ar_365);
fd.Add("-", ar_365);
fd.Add("*", ar_365);
fd.Add("/", ar_365);
fd.Add("%", ar_365);
fd.Add("^", ar_365);
fd.Add("&", ar_365);
fd.Add("|", ar_365);
fd.Add("&&", ar_365);
fd.Add("||", ar_365);
fd.Add("==", ar_365);
fd.Add("!=", ar_365);
fd.Add(">", ar_365);
fd.Add("<", ar_365);
fd.Add(">=", ar_365);
fd.Add("<=", ar_365);
fd.Add("is", ar_365);
fd.Add("]", ar_365);
fd.Add(",", ar_365);
fd.Add(")", ar_365);
fd.Add(":", ar_365);
fd = state_210.Actions;
ActionRecord ar_366 = new ActionRecord(ParserActionType.Reduce, null, Terms_61, 2);
fd.Add("[", ar_366);
fd.Add("(", ar_366);
fd.Add(".", ar_366);
fd.Add(";", ar_366);
fd.Add("+", ar_366);
fd.Add("-", ar_366);
fd.Add("*", ar_366);
fd.Add("/", ar_366);
fd.Add("%", ar_366);
fd.Add("^", ar_366);
fd.Add("&", ar_366);
fd.Add("|", ar_366);
fd.Add("&&", ar_366);
fd.Add("||", ar_366);
fd.Add("==", ar_366);
fd.Add("!=", ar_366);
fd.Add(">", ar_366);
fd.Add("<", ar_366);
fd.Add(">=", ar_366);
fd.Add("<=", ar_366);
fd.Add("is", ar_366);
fd.Add("|>", ar_366);
fd.Add(",", ar_366);
fd.Add("]", ar_366);
fd.Add(")", ar_366);
fd.Add(":", ar_366);
fd = state_211.Actions;
ActionRecord ar_367 = new ActionRecord(ParserActionType.Reduce, null, Terms_62, 1);
fd.Add("[", ar_367);
fd.Add("(", ar_367);
fd.Add(".", ar_367);
fd.Add(";", ar_367);
fd.Add("+", ar_367);
fd.Add("-", ar_367);
fd.Add("*", ar_367);
fd.Add("/", ar_367);
fd.Add("%", ar_367);
fd.Add("^", ar_367);
fd.Add("&", ar_367);
fd.Add("|", ar_367);
fd.Add("&&", ar_367);
fd.Add("||", ar_367);
fd.Add("==", ar_367);
fd.Add("!=", ar_367);
fd.Add(">", ar_367);
fd.Add("<", ar_367);
fd.Add(">=", ar_367);
fd.Add("<=", ar_367);
fd.Add("is", ar_367);
fd.Add("|>", ar_367);
fd.Add(",", ar_367);
fd.Add("]", ar_367);
fd.Add(")", ar_367);
fd.Add(":", ar_367);
fd = state_212.Actions;
ActionRecord ar_368 = new ActionRecord(ParserActionType.Shift, state_224, null, 0);
fd.Add("BlockStatement\b", ar_368);
fd.Add("{", ar_26);
fd = state_213.Actions;
ActionRecord ar_369 = new ActionRecord(ParserActionType.Reduce, null, Terms_67, 1);
fd.Add("{", ar_369);
fd = state_214.Actions;
ActionRecord ar_370 = new ActionRecord(ParserActionType.Shift, state_225, null, 0);
fd.Add("Pre Conditions\b", ar_370);
ActionRecord ar_371 = new ActionRecord(ParserActionType.Shift, state_226, null, 0);
fd.Add("pre", ar_371);
fd = state_215.Actions;
ActionRecord ar_372 = new ActionRecord(ParserActionType.Shift, state_227, null, 0);
fd.Add("ParamaterList\b", ar_372);
fd.Add("idn+\b", ar_135);
fd.Add("idn\b", ar_136);
fd.Add(")", ar_137);
fd = state_216.Actions;
ActionRecord ar_373 = new ActionRecord(ParserActionType.Shift, state_228, null, 0);
fd.Add("\b", ar_373);
ActionRecord ar_374 = new ActionRecord(ParserActionType.Shift, state_229, null, 0);
fd.Add("FuncContract\b", ar_374);
fd.Add("[", ar_344);
ActionRecord ar_375 = new ActionRecord(ParserActionType.Reduce, null, Terms_76, 0);
fd.Add("{", ar_375);
fd = state_217.Actions;
ActionRecord ar_376 = new ActionRecord(ParserActionType.Reduce, null, Terms_75, 1);
fd.Add("{", ar_376);
fd.Add("[", ar_376);
fd = state_218.Actions;
ActionRecord ar_377 = new ActionRecord(ParserActionType.Shift, state_230, null, 0);
fd.Add("OptionalExpression\b", ar_377);
fd.Add("Expr\b", ar_143);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd.Add(")", ar_144);
fd = state_219.Actions;
ActionRecord ar_378 = new ActionRecord(ParserActionType.Shift, state_231, null, 0);
fd.Add("Statement\b", ar_378);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_220.Actions;
ActionRecord ar_379 = new ActionRecord(ParserActionType.Shift, state_232, null, 0);
fd.Add("}", ar_379);
fd = state_221.Actions;
ActionRecord ar_380 = new ActionRecord(ParserActionType.Shift, state_233, null, 0);
fd.Add("\b", ar_380);
ActionRecord ar_381 = new ActionRecord(ParserActionType.Shift, state_234, null, 0);
fd.Add("SwitchCaseStatement\b", ar_381);
ActionRecord ar_382 = new ActionRecord(ParserActionType.Shift, state_235, null, 0);
fd.Add("SwitchDefaultStatement\b", ar_382);
ActionRecord ar_383 = new ActionRecord(ParserActionType.Shift, state_236, null, 0);
fd.Add("case", ar_383);
ActionRecord ar_384 = new ActionRecord(ParserActionType.Shift, state_237, null, 0);
fd.Add("default", ar_384);
ActionRecord ar_385 = new ActionRecord(ParserActionType.Reduce, null, Terms_74, 0);
fd.Add("}", ar_385);
fd = state_222.Actions;
ActionRecord ar_386 = new ActionRecord(ParserActionType.Shift, state_238, null, 0);
fd.Add("BlockStatement\b", ar_386);
fd.Add("{", ar_26);
fd = state_223.Actions;
fd.Add(".", ar_192);
ActionRecord ar_387 = new ActionRecord(ParserActionType.Reduce, null, Terms_22, 3);
fd.Add("|>", ar_387);
fd.Add(",", ar_387);
fd = state_224.Actions;
ActionRecord ar_388 = new ActionRecord(ParserActionType.Reduce, null, Terms_8, 7);
fd.Add(";", ar_388);
fd.Add("+", ar_388);
fd.Add("-", ar_388);
fd.Add("*", ar_388);
fd.Add("/", ar_388);
fd.Add("%", ar_388);
fd.Add("^", ar_388);
fd.Add("&", ar_388);
fd.Add("|", ar_388);
fd.Add("&&", ar_388);
fd.Add("||", ar_388);
fd.Add("==", ar_388);
fd.Add("!=", ar_388);
fd.Add(">", ar_388);
fd.Add("<", ar_388);
fd.Add(">=", ar_388);
fd.Add("<=", ar_388);
fd.Add("is", ar_388);
fd.Add("]", ar_388);
fd.Add(",", ar_388);
fd.Add(")", ar_388);
fd.Add(":", ar_388);
fd = state_225.Actions;
ActionRecord ar_389 = new ActionRecord(ParserActionType.Shift, state_239, null, 0);
fd.Add(";", ar_389);
fd = state_226.Actions;
ActionRecord ar_390 = new ActionRecord(ParserActionType.Shift, state_240, null, 0);
fd.Add("(", ar_390);
fd = state_227.Actions;
ActionRecord ar_391 = new ActionRecord(ParserActionType.Shift, state_241, null, 0);
fd.Add(")", ar_391);
fd = state_228.Actions;
ActionRecord ar_392 = new ActionRecord(ParserActionType.Shift, state_242, null, 0);
fd.Add("BlockStatement\b", ar_392);
fd.Add("{", ar_26);
fd = state_229.Actions;
ActionRecord ar_393 = new ActionRecord(ParserActionType.Reduce, null, Terms_76, 1);
fd.Add("{", ar_393);
fd = state_230.Actions;
ActionRecord ar_394 = new ActionRecord(ParserActionType.Shift, state_243, null, 0);
fd.Add(")", ar_394);
fd = state_231.Actions;
ActionRecord ar_395 = new ActionRecord(ParserActionType.Reduce, null, Terms_34, 7);
fd.Add("EOF\b", ar_395);
fd.Add(";", ar_395);
fd.Add("function", ar_395);
fd.Add("if", ar_395);
fd.Add("{", ar_395);
fd.Add("while", ar_395);
fd.Add("for", ar_395);
fd.Add("foreach", ar_395);
fd.Add("using", ar_395);
fd.Add("switch", ar_395);
fd.Add("try", ar_395);
fd.Add("break", ar_395);
fd.Add("continue", ar_395);
fd.Add("return", ar_395);
fd.Add("throw", ar_395);
fd.Add("true", ar_395);
fd.Add("false", ar_395);
fd.Add("null", ar_395);
fd.Add("string\b", ar_395);
fd.Add("number\b", ar_395);
fd.Add("idn\b", ar_395);
fd.Add("var", ar_395);
fd.Add("new", ar_395);
fd.Add("[", ar_395);
fd.Add("(", ar_395);
fd.Add("<!", ar_395);
fd.Add("~", ar_395);
fd.Add("-", ar_395);
fd.Add("!", ar_395);
fd.Add("$", ar_395);
fd.Add("ref", ar_395);
fd.Add("out", ar_395);
fd.Add("else", ar_395);
fd.Add("}", ar_395);
fd.Add("!>", ar_395);
fd.Add("default", ar_395);
fd.Add("case", ar_395);
fd = state_232.Actions;
ActionRecord ar_396 = new ActionRecord(ParserActionType.Reduce, null, Terms_36, 7);
fd.Add("EOF\b", ar_396);
fd.Add(";", ar_396);
fd.Add("function", ar_396);
fd.Add("if", ar_396);
fd.Add("{", ar_396);
fd.Add("while", ar_396);
fd.Add("for", ar_396);
fd.Add("foreach", ar_396);
fd.Add("using", ar_396);
fd.Add("switch", ar_396);
fd.Add("try", ar_396);
fd.Add("break", ar_396);
fd.Add("continue", ar_396);
fd.Add("return", ar_396);
fd.Add("throw", ar_396);
fd.Add("true", ar_396);
fd.Add("false", ar_396);
fd.Add("null", ar_396);
fd.Add("string\b", ar_396);
fd.Add("number\b", ar_396);
fd.Add("idn\b", ar_396);
fd.Add("var", ar_396);
fd.Add("new", ar_396);
fd.Add("[", ar_396);
fd.Add("(", ar_396);
fd.Add("<!", ar_396);
fd.Add("~", ar_396);
fd.Add("-", ar_396);
fd.Add("!", ar_396);
fd.Add("$", ar_396);
fd.Add("ref", ar_396);
fd.Add("out", ar_396);
fd.Add("else", ar_396);
fd.Add("}", ar_396);
fd.Add("!>", ar_396);
fd.Add("default", ar_396);
fd.Add("case", ar_396);
fd = state_233.Actions;
ActionRecord ar_397 = new ActionRecord(ParserActionType.Reduce, null, Terms_37, 2);
fd.Add("}", ar_397);
fd = state_234.Actions;
ActionRecord ar_398 = new ActionRecord(ParserActionType.Reduce, null, Terms_57, 2);
fd.Add("default", ar_398);
fd.Add("case", ar_398);
fd.Add("}", ar_398);
fd = state_235.Actions;
ActionRecord ar_399 = new ActionRecord(ParserActionType.Reduce, null, Terms_74, 1);
fd.Add("}", ar_399);
fd = state_236.Actions;
ActionRecord ar_400 = new ActionRecord(ParserActionType.Shift, state_244, null, 0);
fd.Add("Expr\b", ar_400);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_237.Actions;
ActionRecord ar_401 = new ActionRecord(ParserActionType.Shift, state_245, null, 0);
fd.Add(":", ar_401);
fd = state_238.Actions;
ActionRecord ar_402 = new ActionRecord(ParserActionType.Shift, state_246, null, 0);
fd.Add("finally", ar_402);
fd = state_239.Actions;
ActionRecord ar_403 = new ActionRecord(ParserActionType.Shift, state_247, null, 0);
fd.Add("Post Conditions\b", ar_403);
ActionRecord ar_404 = new ActionRecord(ParserActionType.Shift, state_248, null, 0);
fd.Add("post", ar_404);
fd = state_240.Actions;
ActionRecord ar_405 = new ActionRecord(ParserActionType.Shift, state_249, null, 0);
fd.Add("\b", ar_405);
ActionRecord ar_406 = new ActionRecord(ParserActionType.Shift, state_250, null, 0);
fd.Add("ExprList\b", ar_406);
fd.Add("Expr\b", ar_126);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_407 = new ActionRecord(ParserActionType.Reduce, null, Terms_68, 0);
fd.Add(")", ar_407);
fd = state_241.Actions;
ActionRecord ar_408 = new ActionRecord(ParserActionType.Reduce, null, Terms_28, 4);
fd.Add("{", ar_408);
fd.Add("[", ar_408);
fd = state_242.Actions;
ActionRecord ar_409 = new ActionRecord(ParserActionType.Reduce, null, Terms_49, 8);
fd.Add("EOF\b", ar_409);
fd.Add(";", ar_409);
fd.Add("function", ar_409);
fd.Add("if", ar_409);
fd.Add("{", ar_409);
fd.Add("while", ar_409);
fd.Add("for", ar_409);
fd.Add("foreach", ar_409);
fd.Add("using", ar_409);
fd.Add("switch", ar_409);
fd.Add("try", ar_409);
fd.Add("break", ar_409);
fd.Add("continue", ar_409);
fd.Add("return", ar_409);
fd.Add("throw", ar_409);
fd.Add("true", ar_409);
fd.Add("false", ar_409);
fd.Add("null", ar_409);
fd.Add("string\b", ar_409);
fd.Add("number\b", ar_409);
fd.Add("idn\b", ar_409);
fd.Add("var", ar_409);
fd.Add("new", ar_409);
fd.Add("[", ar_409);
fd.Add("(", ar_409);
fd.Add("<!", ar_409);
fd.Add("~", ar_409);
fd.Add("-", ar_409);
fd.Add("!", ar_409);
fd.Add("$", ar_409);
fd.Add("ref", ar_409);
fd.Add("out", ar_409);
fd.Add("!>", ar_409);
fd = state_243.Actions;
ActionRecord ar_410 = new ActionRecord(ParserActionType.Shift, state_251, null, 0);
fd.Add("Statement\b", ar_410);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
fd = state_244.Actions;
fd.Add("BinOp\b", ar_83);
fd.Add("is", ar_84);
ActionRecord ar_411 = new ActionRecord(ParserActionType.Shift, state_252, null, 0);
fd.Add(":", ar_411);
fd.Add("+", ar_86);
fd.Add("-", ar_87);
fd.Add("*", ar_88);
fd.Add("/", ar_89);
fd.Add("%", ar_90);
fd.Add("^", ar_91);
fd.Add("&", ar_92);
fd.Add("|", ar_93);
fd.Add("&&", ar_94);
fd.Add("||", ar_95);
fd.Add("==", ar_96);
fd.Add("!=", ar_97);
fd.Add(">", ar_98);
fd.Add("<", ar_99);
fd.Add(">=", ar_100);
fd.Add("<=", ar_101);
fd = state_245.Actions;
ActionRecord ar_412 = new ActionRecord(ParserActionType.Shift, state_253, null, 0);
fd.Add("Statements(Compound)\b", ar_412);
fd.Add(";", ar_81);
fd.Add("if", ar_81);
fd.Add("{", ar_81);
fd.Add("while", ar_81);
fd.Add("for", ar_81);
fd.Add("foreach", ar_81);
fd.Add("using", ar_81);
fd.Add("switch", ar_81);
fd.Add("try", ar_81);
fd.Add("break", ar_81);
fd.Add("continue", ar_81);
fd.Add("return", ar_81);
fd.Add("throw", ar_81);
fd.Add("true", ar_81);
fd.Add("false", ar_81);
fd.Add("null", ar_81);
fd.Add("string\b", ar_81);
fd.Add("number\b", ar_81);
fd.Add("idn\b", ar_81);
fd.Add("var", ar_81);
fd.Add("new", ar_81);
fd.Add("function", ar_81);
fd.Add("[", ar_81);
fd.Add("(", ar_81);
fd.Add("<!", ar_81);
fd.Add("~", ar_81);
fd.Add("-", ar_81);
fd.Add("!", ar_81);
fd.Add("$", ar_81);
fd.Add("ref", ar_81);
fd.Add("out", ar_81);
fd.Add("}", ar_81);
fd = state_246.Actions;
ActionRecord ar_413 = new ActionRecord(ParserActionType.Shift, state_254, null, 0);
fd.Add("BlockStatement\b", ar_413);
fd.Add("{", ar_26);
fd = state_247.Actions;
ActionRecord ar_414 = new ActionRecord(ParserActionType.Shift, state_255, null, 0);
fd.Add(";", ar_414);
fd = state_248.Actions;
ActionRecord ar_415 = new ActionRecord(ParserActionType.Shift, state_256, null, 0);
fd.Add("(", ar_415);
fd = state_249.Actions;
ActionRecord ar_416 = new ActionRecord(ParserActionType.Shift, state_257, null, 0);
fd.Add(")", ar_416);
fd.Add("idn\b", ar_130);
fd = state_250.Actions;
fd.Add(",", ar_198);
ActionRecord ar_417 = new ActionRecord(ParserActionType.Reduce, null, Terms_68, 1);
fd.Add(")", ar_417);
fd = state_251.Actions;
ActionRecord ar_418 = new ActionRecord(ParserActionType.Reduce, null, Terms_33, 9);
fd.Add("EOF\b", ar_418);
fd.Add(";", ar_418);
fd.Add("function", ar_418);
fd.Add("if", ar_418);
fd.Add("{", ar_418);
fd.Add("while", ar_418);
fd.Add("for", ar_418);
fd.Add("foreach", ar_418);
fd.Add("using", ar_418);
fd.Add("switch", ar_418);
fd.Add("try", ar_418);
fd.Add("break", ar_418);
fd.Add("continue", ar_418);
fd.Add("return", ar_418);
fd.Add("throw", ar_418);
fd.Add("true", ar_418);
fd.Add("false", ar_418);
fd.Add("null", ar_418);
fd.Add("string\b", ar_418);
fd.Add("number\b", ar_418);
fd.Add("idn\b", ar_418);
fd.Add("var", ar_418);
fd.Add("new", ar_418);
fd.Add("[", ar_418);
fd.Add("(", ar_418);
fd.Add("<!", ar_418);
fd.Add("~", ar_418);
fd.Add("-", ar_418);
fd.Add("!", ar_418);
fd.Add("$", ar_418);
fd.Add("ref", ar_418);
fd.Add("out", ar_418);
fd.Add("else", ar_418);
fd.Add("}", ar_418);
fd.Add("!>", ar_418);
fd.Add("default", ar_418);
fd.Add("case", ar_418);
fd = state_252.Actions;
ActionRecord ar_419 = new ActionRecord(ParserActionType.Shift, state_258, null, 0);
fd.Add("Statements(Compound)\b", ar_419);
fd.Add(";", ar_81);
fd.Add("if", ar_81);
fd.Add("{", ar_81);
fd.Add("while", ar_81);
fd.Add("for", ar_81);
fd.Add("foreach", ar_81);
fd.Add("using", ar_81);
fd.Add("switch", ar_81);
fd.Add("try", ar_81);
fd.Add("break", ar_81);
fd.Add("continue", ar_81);
fd.Add("return", ar_81);
fd.Add("throw", ar_81);
fd.Add("true", ar_81);
fd.Add("false", ar_81);
fd.Add("null", ar_81);
fd.Add("string\b", ar_81);
fd.Add("number\b", ar_81);
fd.Add("idn\b", ar_81);
fd.Add("var", ar_81);
fd.Add("new", ar_81);
fd.Add("function", ar_81);
fd.Add("[", ar_81);
fd.Add("(", ar_81);
fd.Add("<!", ar_81);
fd.Add("~", ar_81);
fd.Add("-", ar_81);
fd.Add("!", ar_81);
fd.Add("$", ar_81);
fd.Add("ref", ar_81);
fd.Add("out", ar_81);
fd.Add("default", ar_81);
fd.Add("case", ar_81);
fd.Add("}", ar_81);
fd = state_253.Actions;
fd.Add("Statement\b", ar_149);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_420 = new ActionRecord(ParserActionType.Reduce, null, Terms_39, 3);
fd.Add("}", ar_420);
fd = state_254.Actions;
ActionRecord ar_421 = new ActionRecord(ParserActionType.Reduce, null, Terms_41, 9);
fd.Add("EOF\b", ar_421);
fd.Add(";", ar_421);
fd.Add("function", ar_421);
fd.Add("if", ar_421);
fd.Add("{", ar_421);
fd.Add("while", ar_421);
fd.Add("for", ar_421);
fd.Add("foreach", ar_421);
fd.Add("using", ar_421);
fd.Add("switch", ar_421);
fd.Add("try", ar_421);
fd.Add("break", ar_421);
fd.Add("continue", ar_421);
fd.Add("return", ar_421);
fd.Add("throw", ar_421);
fd.Add("true", ar_421);
fd.Add("false", ar_421);
fd.Add("null", ar_421);
fd.Add("string\b", ar_421);
fd.Add("number\b", ar_421);
fd.Add("idn\b", ar_421);
fd.Add("var", ar_421);
fd.Add("new", ar_421);
fd.Add("[", ar_421);
fd.Add("(", ar_421);
fd.Add("<!", ar_421);
fd.Add("~", ar_421);
fd.Add("-", ar_421);
fd.Add("!", ar_421);
fd.Add("$", ar_421);
fd.Add("ref", ar_421);
fd.Add("out", ar_421);
fd.Add("else", ar_421);
fd.Add("}", ar_421);
fd.Add("!>", ar_421);
fd.Add("default", ar_421);
fd.Add("case", ar_421);
fd = state_255.Actions;
ActionRecord ar_422 = new ActionRecord(ParserActionType.Shift, state_259, null, 0);
fd.Add("Invariant Conditions\b", ar_422);
ActionRecord ar_423 = new ActionRecord(ParserActionType.Shift, state_260, null, 0);
fd.Add("invariant", ar_423);
fd = state_256.Actions;
ActionRecord ar_424 = new ActionRecord(ParserActionType.Shift, state_261, null, 0);
fd.Add("\b", ar_424);
ActionRecord ar_425 = new ActionRecord(ParserActionType.Shift, state_262, null, 0);
fd.Add("ExprList\b", ar_425);
fd.Add("Expr\b", ar_126);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_426 = new ActionRecord(ParserActionType.Reduce, null, Terms_69, 0);
fd.Add(")", ar_426);
fd = state_257.Actions;
ActionRecord ar_427 = new ActionRecord(ParserActionType.Reduce, null, Terms_52, 4);
fd.Add(";", ar_427);
fd = state_258.Actions;
fd.Add("Statement\b", ar_149);
fd.Add(";", ar_8);
fd.Add("IfStatement\b", ar_9);
fd.Add("WhileStatement\b", ar_10);
fd.Add("ForStatement\b", ar_11);
fd.Add("ForEachStatement\b", ar_12);
fd.Add("UsingStatement\b", ar_13);
fd.Add("SwitchStatement\b", ar_14);
fd.Add("BlockStatement\b", ar_15);
fd.Add("TryCatchFinallyStatement\b", ar_16);
fd.Add("ExprStatement\b", ar_17);
fd.Add("FlowControl\b", ar_18);
fd.Add("if", ar_20);
fd.Add("while", ar_21);
fd.Add("for", ar_22);
fd.Add("foreach", ar_23);
fd.Add("using", ar_24);
fd.Add("switch", ar_25);
fd.Add("{", ar_26);
fd.Add("try", ar_27);
fd.Add("Expr\b", ar_28);
fd.Add("break", ar_29);
fd.Add("continue", ar_30);
fd.Add("return", ar_31);
fd.Add("throw", ar_32);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("\b", ar_59);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_428 = new ActionRecord(ParserActionType.Reduce, null, Terms_38, 4);
fd.Add("default", ar_428);
fd.Add("case", ar_428);
fd.Add("}", ar_428);
fd = state_259.Actions;
ActionRecord ar_429 = new ActionRecord(ParserActionType.Shift, state_263, null, 0);
fd.Add(";", ar_429);
fd = state_260.Actions;
ActionRecord ar_430 = new ActionRecord(ParserActionType.Shift, state_264, null, 0);
fd.Add("(", ar_430);
fd = state_261.Actions;
ActionRecord ar_431 = new ActionRecord(ParserActionType.Shift, state_265, null, 0);
fd.Add(")", ar_431);
fd.Add("idn\b", ar_130);
fd = state_262.Actions;
fd.Add(",", ar_198);
ActionRecord ar_432 = new ActionRecord(ParserActionType.Reduce, null, Terms_69, 1);
fd.Add(")", ar_432);
fd = state_263.Actions;
ActionRecord ar_433 = new ActionRecord(ParserActionType.Shift, state_266, null, 0);
fd.Add("]", ar_433);
fd = state_264.Actions;
ActionRecord ar_434 = new ActionRecord(ParserActionType.Shift, state_267, null, 0);
fd.Add("\b", ar_434);
ActionRecord ar_435 = new ActionRecord(ParserActionType.Shift, state_268, null, 0);
fd.Add("ExprList\b", ar_435);
fd.Add("Expr\b", ar_126);
fd.Add("ConstExpr\b", ar_33);
fd.Add("BinExpr\b", ar_34);
fd.Add("UnaryExpr\b", ar_35);
fd.Add("QualifiedName\b", ar_36);
fd.Add("AssignExpr\b", ar_37);
fd.Add("NewStmt\b", ar_38);
fd.Add("FuncDefExpr\b", ar_39);
fd.Add("NewArrStmt\b", ar_40);
fd.Add("ArrayConstructor\b", ar_41);
fd.Add("MObjectConstructor\b", ar_42);
fd.Add("TypeConvertExpr\b", ar_43);
fd.Add("MetaExpr\b", ar_44);
fd.Add("RefExpr\b", ar_45);
fd.Add("VarExpr\b", ar_46);
fd.Add("true", ar_47);
fd.Add("false", ar_48);
fd.Add("null", ar_49);
fd.Add("string\b", ar_50);
fd.Add("number\b", ar_51);
fd.Add("IsExpr\b", ar_52);
fd.Add("LUnOp\b", ar_53);
fd.Add("idn\b", ar_54);
fd.Add("new", ar_55);
fd.Add("function", ar_105);
fd.Add("[", ar_56);
fd.Add("(", ar_57);
fd.Add("<!", ar_58);
fd.Add("var", ar_60);
fd.Add("~", ar_61);
fd.Add("-", ar_62);
fd.Add("!", ar_63);
fd.Add("$", ar_64);
fd.Add("ref", ar_65);
fd.Add("out", ar_66);
ActionRecord ar_436 = new ActionRecord(ParserActionType.Reduce, null, Terms_70, 0);
fd.Add(")", ar_436);
fd = state_265.Actions;
ActionRecord ar_437 = new ActionRecord(ParserActionType.Reduce, null, Terms_53, 4);
fd.Add(";", ar_437);
fd = state_266.Actions;
ActionRecord ar_438 = new ActionRecord(ParserActionType.Reduce, null, Terms_50, 8);
fd.Add("{", ar_438);
fd = state_267.Actions;
ActionRecord ar_439 = new ActionRecord(ParserActionType.Shift, state_269, null, 0);
fd.Add(")", ar_439);
fd.Add("idn\b", ar_130);
fd = state_268.Actions;
fd.Add(",", ar_198);
ActionRecord ar_440 = new ActionRecord(ParserActionType.Reduce, null, Terms_70, 1);
fd.Add(")", ar_440);
fd = state_269.Actions;
ActionRecord ar_441 = new ActionRecord(ParserActionType.Reduce, null, Terms_54, 4);
fd.Add(";", ar_441);
InitialState = state_0;
FinalState = state_1;
TerminalList tl;
NumberLiteral n = new NumberLiteral();
IdentifierTerminal v = new IdentifierTerminal();
ITerminal s = new StringLiteral();
ITerminal Comment = new CommentTerminal("Comment", "/*", "*/");
ITerminal LineComment = new CommentTerminal("LineComment", "//", "\n");
tl = new TerminalList() { SymbolTerminal.GetSymbol("-="), SymbolTerminal.GetSymbol("->"), SymbolTerminal.GetSymbol("--"), SymbolTerminal.GetSymbol("-"), };
Scanner.TerminalsLookup.Add((char)45, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("!>"), SymbolTerminal.GetSymbol("!="), SymbolTerminal.GetSymbol("!"), };
Scanner.TerminalsLookup.Add((char)33, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("$"), };
Scanner.TerminalsLookup.Add((char)36, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("%"), };
Scanner.TerminalsLookup.Add((char)37, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("&&"), SymbolTerminal.GetSymbol("&"), };
Scanner.TerminalsLookup.Add((char)38, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("("), };
Scanner.TerminalsLookup.Add((char)40, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol(")"), };
Scanner.TerminalsLookup.Add((char)41, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("*"), };
Scanner.TerminalsLookup.Add((char)42, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol(","), };
Scanner.TerminalsLookup.Add((char)44, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("."), };
Scanner.TerminalsLookup.Add((char)46, tl);
tl = new TerminalList() { LineComment, Comment, SymbolTerminal.GetSymbol("/"), };
Scanner.TerminalsLookup.Add((char)47, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol(":="), SymbolTerminal.GetSymbol(":"), };
Scanner.TerminalsLookup.Add((char)58, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol(";"), };
Scanner.TerminalsLookup.Add((char)59, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("["), };
Scanner.TerminalsLookup.Add((char)91, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("]"), };
Scanner.TerminalsLookup.Add((char)93, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("^"), };
Scanner.TerminalsLookup.Add((char)94, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("{"), };
Scanner.TerminalsLookup.Add((char)123, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("|>"), SymbolTerminal.GetSymbol("||"), SymbolTerminal.GetSymbol("|"), };
Scanner.TerminalsLookup.Add((char)124, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("}"), };
Scanner.TerminalsLookup.Add((char)125, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("~"), };
Scanner.TerminalsLookup.Add((char)126, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("+="), SymbolTerminal.GetSymbol("++"), SymbolTerminal.GetSymbol("+"), };
Scanner.TerminalsLookup.Add((char)43, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("<|"), SymbolTerminal.GetSymbol("<="), SymbolTerminal.GetSymbol("<!"), SymbolTerminal.GetSymbol("<"), };
Scanner.TerminalsLookup.Add((char)60, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol("=="), SymbolTerminal.GetSymbol("="), };
Scanner.TerminalsLookup.Add((char)61, tl);
tl = new TerminalList() { SymbolTerminal.GetSymbol(">="), SymbolTerminal.GetSymbol(">"), };
Scanner.TerminalsLookup.Add((char)62, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("break"), };
Scanner.TerminalsLookup.Add((char)98, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("continue"), SymbolTerminal.GetSymbol("catch"), SymbolTerminal.GetSymbol("case"), };
Scanner.TerminalsLookup.Add((char)99, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("default"), };
Scanner.TerminalsLookup.Add((char)100, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("else"), };
Scanner.TerminalsLookup.Add((char)101, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("function"), SymbolTerminal.GetSymbol("foreach"), SymbolTerminal.GetSymbol("finally"), SymbolTerminal.GetSymbol("false"), SymbolTerminal.GetSymbol("for"), };
Scanner.TerminalsLookup.Add((char)102, tl);
tl = new TerminalList() { v, v, SymbolTerminal.GetSymbol("global"), };
Scanner.TerminalsLookup.Add((char)103, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)65, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)66, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)67, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)68, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)69, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)70, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)71, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)72, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)73, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)74, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)75, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)76, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)77, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)78, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)79, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)80, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)81, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)82, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)83, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)84, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)85, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)86, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)87, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)88, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)89, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)90, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)97, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)104, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("invariant"), SymbolTerminal.GetSymbol("is"), SymbolTerminal.GetSymbol("if"), SymbolTerminal.GetSymbol("in"), };
Scanner.TerminalsLookup.Add((char)105, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)106, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)107, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)108, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)109, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("null"), SymbolTerminal.GetSymbol("new"), };
Scanner.TerminalsLookup.Add((char)110, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("out"), };
Scanner.TerminalsLookup.Add((char)111, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("post"), SymbolTerminal.GetSymbol("pre"), };
Scanner.TerminalsLookup.Add((char)112, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)113, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("return"), SymbolTerminal.GetSymbol("ref"), };
Scanner.TerminalsLookup.Add((char)114, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("switch"), };
Scanner.TerminalsLookup.Add((char)115, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("throw"), SymbolTerminal.GetSymbol("true"), SymbolTerminal.GetSymbol("try"), };
Scanner.TerminalsLookup.Add((char)116, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("using"), };
Scanner.TerminalsLookup.Add((char)117, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("var"), };
Scanner.TerminalsLookup.Add((char)118, tl);
tl = new TerminalList() { v, SymbolTerminal.GetSymbol("while"), };
Scanner.TerminalsLookup.Add((char)119, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)120, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)121, tl);
tl = new TerminalList() { v, };
Scanner.TerminalsLookup.Add((char)122, tl);
tl = new TerminalList() { n, n, };
Scanner.TerminalsLookup.Add((char)48, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)49, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)50, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)51, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)52, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)53, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)54, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)55, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)56, tl);
tl = new TerminalList() { n, };
Scanner.TerminalsLookup.Add((char)57, tl);
tl = new TerminalList() { s, };
Scanner.TerminalsLookup.Add((char)39, tl);
tl = new TerminalList() { s, };
Scanner.TerminalsLookup.Add((char)34, tl);
tl = new TerminalList() { s, };
Scanner.TerminalsLookup.Add((char)64, tl);
SymbolTerminal.RegisterPunctuation("(", ")", "[", "]", "{", "}", ",", ";");
SymbolTerminal.RegisterOperators(1, "=", "+=", "-=", ":=");
SymbolTerminal.RegisterOperators(2, "|", "||");
SymbolTerminal.RegisterOperators(3, "&", "&&");
SymbolTerminal.RegisterOperators(4, "==", "!=", ">", "<", ">=", "<=");
SymbolTerminal.RegisterOperators(5, "is");
SymbolTerminal.RegisterOperators(6, "+", "-");
SymbolTerminal.RegisterOperators(7, "*", "/", "%");
SymbolTerminal.RegisterOperators(8, Associativity.Right, "^");
SymbolTerminal.RegisterOperators(9, "~", "!", "$", "++", "--");
SymbolTerminal.RegisterOperators(10, ".");
SymbolTerminal.ClearSymbols();
}
private AstNode CreateNode(ActionRecord reduceAction, SourceSpan sourceSpan, AstNodeList childNodes)
{
IGrammarTerm nonTeminal = reduceAction.NonTerminal;
AstNode result;
AstNodeArgs args = new AstNodeArgs(nonTeminal, sourceSpan, childNodes);
Type ntNodeType = nonTeminal.NodeType ?? typeof(AstNode);
bool isList = nonTeminal.IsSet(TermOptions.IsList);
if (isList && childNodes.Count > 1 && childNodes[0].Term == nonTeminal)
{
result = childNodes[0];
AstNode newChild = childNodes[childNodes.Count - 1];
newChild.Parent = result;
result.ChildNodes.Add(newChild);
return result;
}
if (nonTeminal.IsSet(TermOptions.IsStarList) && childNodes.Count == 1)
{
childNodes = childNodes[0].ChildNodes;
}
if (!isList && !nonTeminal.IsSet(TermOptions.IsPunctuation) && childNodes.Count == 1)
{
Type childNodeType = childNodes[0].Term.NodeType ?? typeof(AstNode);
if (childNodeType == ntNodeType || childNodeType.IsSubclassOf(ntNodeType))
return childNodes[0];
}
result = null;
if (ntNodeType == typeof(AstNode))
{
result = new AstNode(args);
}
else
{
ConstructorInfo ctor = ntNodeType.GetConstructor(new Type[] { typeof(AstNodeArgs) });
if (ctor == null)
throw new Exception("Failed to located constructor: " + ntNodeType.ToString() + "(AstNodeArgs args)");
result = (AstNode)ctor.Invoke(new object[] { args });
}
return result;
}
private void ExecuteReduceAction(ActionRecord action)
{
ParserState oldState = _currentState;
int popCnt = action.PopCount;
AstNodeList childNodes = new AstNodeList();
for (int i = 0; i < action.PopCount; i++)
{
AstNode child = _stack[_stack.Count - popCnt + i].Node;
if (!child.Term.IsSet(TermOptions.IsPunctuation))
childNodes.Add(child);
}
SourceSpan newNodeSpan;
if (popCnt == 0)
{
newNodeSpan = new SourceSpan(_currentToken.Location, 0);
}
else
{
SourceLocation firstPopLoc = _stack[_stack.Count - popCnt].Node.Location;
int lastPopEndPos = _stack[_stack.Count - 1].Node.Span.EndPos;
newNodeSpan = new SourceSpan(firstPopLoc, lastPopEndPos - firstPopLoc.Position);
_currentState = _stack[_stack.Count - popCnt].State;
_stack.Pop(popCnt);
}
AstNode node = CreateNode(action, newNodeSpan, childNodes);
_stack.Push(node, _currentState);
ActionRecord gotoAction;
if (_currentState.Actions.TryGetValue(action.NonTerminal.Key, out gotoAction))
{
_currentState = gotoAction.NewState;
}
else
throw new CompilerException(string.Format("Cannot find transition for input {0}; state: {1}, popped state: {2}",
action.NonTerminal, oldState, _currentState));
}
private void ExecuteShiftAction(ActionRecord action)
{
_stack.Push(_currentToken, _currentState);
_currentState = action.NewState;
NextToken();
}