コード例 #1
0
ファイル: LRParser.cs プロジェクト: singba/SSharp
        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);
        }
コード例 #2
0
ファイル: LRParser.cs プロジェクト: singba/SSharp
        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;
                }
            }
        }
コード例 #3
0
ファイル: LRParser.cs プロジェクト: singba/SSharp
        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));
            }
        }
コード例 #4
0
ファイル: LRParser.cs プロジェクト: singba/SSharp
        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);
        }
コード例 #5
0
ファイル: LRParser.cs プロジェクト: singba/SSharp
 private void ExecuteShiftAction(ActionRecord action)
 {
     _stack.Push(_currentToken, _currentState);
     _currentState = action.NewState;
     NextToken();
 }
コード例 #6
0
    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();

    }
コード例 #7
0
ファイル: LRParser.cs プロジェクト: eightrivers/SSharp
    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;
    }
コード例 #8
0
ファイル: LRParser.cs プロジェクト: eightrivers/SSharp
    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));
    }
コード例 #9
0
ファイル: LRParser.cs プロジェクト: eightrivers/SSharp
 private void ExecuteShiftAction(ActionRecord action)
 {
   _stack.Push(_currentToken, _currentState);
   _currentState = action.NewState;
   NextToken();
 }