diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2Tests.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2Tests.java index 0637eeae3a6..86315ca2d3e 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2Tests.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2Tests.java @@ -4184,15 +4184,12 @@ public class AST2Tests extends AST2BaseTest { IASTTranslationUnit tu = parse( buffer.toString(), ParserLanguage.CPP, false ); CNameCollector col = new CNameCollector(); tu.accept(col); - Iterator i = col.nameList.iterator(); - while (i.hasNext()) { - IASTName n = (IASTName) i.next(); - if (n.isReference() && "f1".equals(n.toString())) { + for(Object o : col.nameList) { + IASTName n = (IASTName)o; + if (n.isReference() && "f1".equals(n.toString())) assertTrue(n.resolveBinding() instanceof IProblemBinding); - } - else { + else assertFalse(n.resolveBinding() instanceof IProblemBinding); - } } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguity.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguity.java index 17b57c0b88b..f9071bfa96d 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguity.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTAmbiguity.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2004, 2007 IBM Corporation and others. + * Copyright (c) 2004, 2008 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at @@ -11,8 +11,6 @@ *******************************************************************************/ package org.eclipse.cdt.internal.core.dom.parser.cpp; //no change for leave() -import java.util.Arrays; - import org.eclipse.cdt.core.dom.ast.ASTVisitor; import org.eclipse.cdt.core.dom.ast.DOMException; import org.eclipse.cdt.core.dom.ast.IASTName; @@ -36,7 +34,8 @@ public abstract class CPPASTAmbiguity extends CPPASTNode { shouldVisitNames = true; } - public int visit(IASTName name) { + @Override + public int visit(IASTName name) { if (name != null) { namesPos++; names = (IASTName[]) ArrayUtil.append(IASTName.class, names, name); @@ -52,30 +51,28 @@ public abstract class CPPASTAmbiguity extends CPPASTNode { protected abstract IASTNode[] getNodes(); - public boolean accept(ASTVisitor visitor) { + @Override + public boolean accept(ASTVisitor visitor) { IASTNode[] nodez = getNodes(); -// if( debugging ) -// printNode(); - int[] issues = new int[nodez.length]; - for (int i = 0; i < nodez.length; ++i) { - IASTNode s = nodez[i]; - s.accept( visitor ); - CPPASTNameCollector resolver = new CPPASTNameCollector(); - s.accept(resolver); - IASTName[] names = resolver.getNames(); - for (int j = 0; j < names.length; ++j) { + int[] problems = new int[nodez.length]; + for(int i = 0; i < nodez.length; ++i) { + IASTNode node = nodez[i]; + node.accept(visitor); + CPPASTNameCollector nameCollector = new CPPASTNameCollector(); + node.accept(nameCollector); + IASTName[] names = nameCollector.getNames(); + for(IASTName name : names) { try { - IBinding b = names[j].resolveBinding(); - if (b == null || b instanceof IProblemBinding) - ++issues[i]; + IBinding b = name.resolveBinding(); + if(b == null || b instanceof IProblemBinding) + ++problems[i]; } catch (Exception t) { - ++issues[i]; + ++problems[i]; } } - if (names.length > 0) { + if(names.length > 0) { IScope scope = CPPVisitor.getContainingScope(names[0]); - if( scope != null ) - { + if( scope != null ) { try { ASTInternal.flushCache(scope); } catch (DOMException de) {} @@ -83,11 +80,11 @@ public abstract class CPPASTAmbiguity extends CPPASTNode { } } int bestIndex = 0; - int bestValue = issues[0]; - for (int i = 1; i < issues.length; ++i) { - if (issues[i] < bestValue) { + int bestValue = problems[0]; + for (int i = 1; i < problems.length; ++i) { + if (problems[i] < bestValue) { bestIndex = i; - bestValue = issues[i]; + bestValue = problems[i]; } } @@ -96,14 +93,4 @@ public abstract class CPPASTAmbiguity extends CPPASTNode { return true; } -// protected void printNode() { -// System.out.println( "Ambiguity " + getClass().getName() + ": "); -// IASTNode [] nodes = getNodes(); -// for( int i = 0; i < nodes.length; ++i ) -// { -// System.out.print( "\t" + i + " : " ); -// System.out.println( ASTSignatureUtil.getNodeSignature(nodes[i]) ); -// } -// } - } diff --git a/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml b/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml index 5a05cd1f945..96f11442b79 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml +++ b/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml @@ -75,6 +75,10 @@ + + + + diff --git a/lrparser/org.eclipse.cdt.core.lrparser/grammar/c99/C99Grammar.g b/lrparser/org.eclipse.cdt.core.lrparser/grammar/c99/C99Grammar.g index 2391edd0b7d..68b06c2e369 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/grammar/c99/C99Grammar.g +++ b/lrparser/org.eclipse.cdt.core.lrparser/grammar/c99/C99Grammar.g @@ -238,7 +238,7 @@ unary_expression | 'sizeof' unary_expression /. $Build consumeExpressionUnaryOperator(IASTUnaryExpression.op_sizeof); $EndBuild ./ | 'sizeof' '(' type_name ')' - /. $Build consumeExpressionSizeofTypeId(); $EndBuild ./ + /. $Build consumeExpressionTypeId(IASTTypeIdExpression.op_sizeof); $EndBuild ./ cast_expression diff --git a/lrparser/org.eclipse.cdt.core.lrparser/grammar/cpp/CPPSizeofExpressionParser.g b/lrparser/org.eclipse.cdt.core.lrparser/grammar/cpp/CPPSizeofExpressionParser.g new file mode 100644 index 00000000000..ea977476189 --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/grammar/cpp/CPPSizeofExpressionParser.g @@ -0,0 +1,40 @@ +----------------------------------------------------------------------------------- +-- Copyright (c) 2006, 2008 IBM Corporation and others. +-- All rights reserved. This program and the accompanying materials +-- are made available under the terms of the Eclipse Public License v1.0 +-- which accompanies this distribution, and is available at +-- http://www.eclipse.org/legal/epl-v10.html +-- +-- Contributors: +-- IBM Corporation - initial API and implementation +----------------------------------------------------------------------------------- + +%options la=2 +%options package=org.eclipse.cdt.internal.core.dom.lrparser.cpp +%options template=btParserTemplateD.g + + +$Import + CPPGrammar.g +$DropRules + + unary_expression + ::= 'sizeof' '(' type_id ')' + + postfix_expression + ::= 'typeid' '(' type_id ')' + +$End + +$Start + no_sizeof_type_name_start +$End + +$Rules + + no_sizeof_type_name_start + ::= expression + | ERROR_TOKEN + /. $Build consumeExpressionProblem(); $EndBuild ./ + +$End \ No newline at end of file diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/BuildASTParserAction.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/BuildASTParserAction.java index 62fe966e147..8a66ea2c134 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/BuildASTParserAction.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/BuildASTParserAction.java @@ -57,6 +57,7 @@ import org.eclipse.cdt.core.dom.ast.IASTProblem; import org.eclipse.cdt.core.dom.ast.IASTProblemExpression; import org.eclipse.cdt.core.dom.ast.IASTProblemHolder; import org.eclipse.cdt.core.dom.ast.IASTReturnStatement; +import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclSpecifier; import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration; import org.eclipse.cdt.core.dom.ast.IASTStatement; import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit; @@ -70,6 +71,8 @@ import org.eclipse.cdt.core.dom.lrparser.IParser; import org.eclipse.cdt.core.dom.lrparser.IParserActionTokenProvider; import static org.eclipse.cdt.core.dom.lrparser.util.CollectionUtils.matchTokens; import org.eclipse.cdt.core.dom.lrparser.util.DebugUtil; +import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99Parsersym; +import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99SizeofExpressionParser; import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPParsersym; import org.eclipse.cdt.internal.core.dom.parser.ASTNode; @@ -139,6 +142,13 @@ public abstract class BuildASTParserAction { protected abstract IParser getNoCastExpressionParser(); + /** + * Expression parser that treats all sizeof and typeid expressions + * as unary expressions. + */ + protected abstract IParser getSizeofExpressionParser(); + + /** * Create a new parser action. @@ -408,16 +418,37 @@ public abstract class BuildASTParserAction { } } + IASTNode result; if(expressionStatement == null) - astStack.push(declarationStatement); + result = declarationStatement; + else if(isImplicitInt(decl)) + result = expressionStatement; else - astStack.push(nodeFactory.newAmbiguousStatement(declarationStatement, expressionStatement)); + result = nodeFactory.newAmbiguousStatement(declarationStatement, expressionStatement); + astStack.push(result); if(TRACE_AST_STACK) System.out.println(astStack); } + /** + * TODO : don't think this is correct. + * + * Returns true if the given declaration has unspecified type, + * in this case the type defaults to int and is know as "implicit int". + */ + protected static boolean isImplicitInt(IASTDeclaration declaration) { + if(declaration instanceof IASTSimpleDeclaration) { + IASTDeclSpecifier declSpec = ((IASTSimpleDeclaration)declaration).getDeclSpecifier(); + if(declSpec instanceof IASTSimpleDeclSpecifier && + ((IASTSimpleDeclSpecifier)declSpec).getType() == IASTSimpleDeclSpecifier.t_unspecified) { + + return true; + } + } + return false; + } /** @@ -591,9 +622,26 @@ public abstract class BuildASTParserAction { IASTTypeId typeId = (IASTTypeId) astStack.pop(); IASTTypeIdExpression expr = nodeFactory.newTypeIdExpression(operator, typeId); setOffsetAndLength(expr); - astStack.push(expr); + + // try parsing as an expression to resolve ambiguities + IParser secondaryParser = getSizeofExpressionParser(); + IASTNode alternateExpr = runSecondaryParser(secondaryParser); + + if(alternateExpr == null || alternateExpr instanceof IASTProblemExpression) + astStack.push(expr); + else + astStack.push(nodeFactory.newAmbiguousExpression(expr, (IASTExpression)alternateExpr)); if(TRACE_AST_STACK) System.out.println(astStack); + +// if(TRACE_ACTIONS) DebugUtil.printMethodTrace(); +// +// IASTTypeId typeId = (IASTTypeId) astStack.pop(); +// IASTTypeIdExpression expr = nodeFactory.newTypeIdExpression(operator, typeId); +// setOffsetAndLength(expr); +// astStack.push(expr); +// +// if(TRACE_AST_STACK) System.out.println(astStack); } diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/c99/C99BuildASTParserAction.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/c99/C99BuildASTParserAction.java index 957d2a1d83a..cf861de6d16 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/c99/C99BuildASTParserAction.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/c99/C99BuildASTParserAction.java @@ -38,14 +38,11 @@ import java.util.List; import lpg.lpgjavaruntime.IToken; -import org.eclipse.cdt.core.dom.ast.IASTCompletionNode; import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement; import org.eclipse.cdt.core.dom.ast.IASTDeclSpecifier; import org.eclipse.cdt.core.dom.ast.IASTDeclaration; -import org.eclipse.cdt.core.dom.ast.IASTDeclarationStatement; import org.eclipse.cdt.core.dom.ast.IASTElaboratedTypeSpecifier; import org.eclipse.cdt.core.dom.ast.IASTExpression; -import org.eclipse.cdt.core.dom.ast.IASTExpressionStatement; import org.eclipse.cdt.core.dom.ast.IASTFieldReference; import org.eclipse.cdt.core.dom.ast.IASTFunctionDeclarator; import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition; @@ -53,10 +50,8 @@ import org.eclipse.cdt.core.dom.ast.IASTIfStatement; import org.eclipse.cdt.core.dom.ast.IASTInitializer; import org.eclipse.cdt.core.dom.ast.IASTInitializerList; import org.eclipse.cdt.core.dom.ast.IASTName; -import org.eclipse.cdt.core.dom.ast.IASTNode; import org.eclipse.cdt.core.dom.ast.IASTParameterDeclaration; import org.eclipse.cdt.core.dom.ast.IASTPointer; -import org.eclipse.cdt.core.dom.ast.IASTProblemExpression; import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclSpecifier; import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration; import org.eclipse.cdt.core.dom.ast.IASTStandardFunctionDeclarator; @@ -64,8 +59,6 @@ import org.eclipse.cdt.core.dom.ast.IASTStatement; import org.eclipse.cdt.core.dom.ast.IASTSwitchStatement; import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit; import org.eclipse.cdt.core.dom.ast.IASTTypeId; -import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression; -import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression; import org.eclipse.cdt.core.dom.ast.IASTWhileStatement; import org.eclipse.cdt.core.dom.ast.c.ICASTArrayDesignator; import org.eclipse.cdt.core.dom.ast.c.ICASTArrayModifier; @@ -90,10 +83,8 @@ import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99ExpressionStatementPars import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99NoCastExpressionParser; import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99Parsersym; import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99SizeofExpressionParser; +import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPParsersym; import org.eclipse.cdt.internal.core.dom.parser.ASTNode; -import org.eclipse.cdt.internal.core.dom.parser.IASTAmbiguousExpression; -import org.eclipse.cdt.internal.core.dom.parser.IASTAmbiguousStatement; -import org.eclipse.cdt.internal.core.dom.parser.c.CASTAmbiguousExpression; /** * Semantic actions called by the C99 parser to build an AST. @@ -148,6 +139,10 @@ public class C99BuildASTParserAction extends BuildASTParserAction { return new C99NoCastExpressionParser(C99Parsersym.orderedTerminalSymbols); } + @Override + protected IParser getSizeofExpressionParser() { + return new C99SizeofExpressionParser(CPPParsersym.orderedTerminalSymbols); + } /******************************************************************** @@ -193,28 +188,28 @@ public class C99BuildASTParserAction extends BuildASTParserAction { if(TRACE_AST_STACK) System.out.println(astStack); } - /** - * Lots of rules, no need to list them. - * @param operator From IASTUnaryExpression - */ - public void consumeExpressionSizeofTypeId() { - if(TRACE_ACTIONS) DebugUtil.printMethodTrace(); - - IASTTypeId typeId = (IASTTypeId) astStack.pop(); - IASTTypeIdExpression expr = nodeFactory.newTypeIdExpression(IASTTypeIdExpression.op_sizeof, typeId); - setOffsetAndLength(expr); - - // try parsing as an expression to resolve ambiguities - C99SizeofExpressionParser secondaryParser = new C99SizeofExpressionParser(C99Parsersym.orderedTerminalSymbols); - IASTNode alternateExpr = runSecondaryParser(secondaryParser); - - if(alternateExpr == null || alternateExpr instanceof IASTProblemExpression) - astStack.push(expr); - else - astStack.push(nodeFactory.newAmbiguousExpression(expr, (IASTExpression)alternateExpr)); - - if(TRACE_AST_STACK) System.out.println(astStack); - } +// /** +// * Lots of rules, no need to list them. +// * @param operator From IASTUnaryExpression +// */ +// public void consumeExpressionSizeofTypeId() { +// if(TRACE_ACTIONS) DebugUtil.printMethodTrace(); +// +// IASTTypeId typeId = (IASTTypeId) astStack.pop(); +// IASTTypeIdExpression expr = nodeFactory.newTypeIdExpression(IASTTypeIdExpression.op_sizeof, typeId); +// setOffsetAndLength(expr); +// +// // try parsing as an expression to resolve ambiguities +// C99SizeofExpressionParser secondaryParser = new C99SizeofExpressionParser(C99Parsersym.orderedTerminalSymbols); +// IASTNode alternateExpr = runSecondaryParser(secondaryParser); +// +// if(alternateExpr == null || alternateExpr instanceof IASTProblemExpression) +// astStack.push(expr); +// else +// astStack.push(nodeFactory.newAmbiguousExpression(expr, (IASTExpression)alternateExpr)); +// +// if(TRACE_AST_STACK) System.out.println(astStack); +// } /** diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/cpp/CPPBuildASTParserAction.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/cpp/CPPBuildASTParserAction.java index 3e0c5243b58..f152c3fac9f 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/cpp/CPPBuildASTParserAction.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/cpp/CPPBuildASTParserAction.java @@ -94,6 +94,7 @@ import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99Parsersym; import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPExpressionStatementParser; import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPNoCastExpressionParser; import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPParsersym; +import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPSizeofExpressionParser; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTFunctionDeclarator; import org.eclipse.cdt.internal.core.dom.parser.cpp.OverloadableOperator; @@ -136,6 +137,11 @@ public class CPPBuildASTParserAction extends BuildASTParserAction { return new CPPNoCastExpressionParser(CPPParsersym.orderedTerminalSymbols); } + + @Override + protected IParser getSizeofExpressionParser() { + return new CPPSizeofExpressionParser(CPPParsersym.orderedTerminalSymbols); + } /** * new_expression diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/util/BindingCheckVisitor.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/util/BindingCheckVisitor.java index b744c653bbd..63c1164bc10 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/util/BindingCheckVisitor.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/util/BindingCheckVisitor.java @@ -37,13 +37,13 @@ class BindingCheckVisitor extends CASTVisitor { shouldVisitEnumerators = true; shouldVisitTranslationUnit = true; shouldVisitProblems = false; - shouldVisitComments = false; shouldVisitDesignators = true; } + @Override public int visit(IASTName name) { if(name.getBinding() == null) - throw new AssertionError("Binding did not get pre-resolved: '" + name + "'"); + throw new AssertionError("Binding did not get pre-resolved: '" + name + "'"); //$NON-NLS-1$ //$NON-NLS-2$ return PROCESS_CONTINUE; } diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99ExpressionStatementParser.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99ExpressionStatementParser.java index 1875cd1d6ef..713a7b3a838 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99ExpressionStatementParser.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99ExpressionStatementParser.java @@ -375,7 +375,7 @@ public C99ExpressionStatementParser(String[] mapFrom) { // constructor // // Rule 41: unary_expression ::= sizeof ( type_name ) // - case 41: { action. consumeExpressionSizeofTypeId(); break; + case 41: { action. consumeExpressionTypeId(IASTTypeIdExpression.op_sizeof); break; } // diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99NoCastExpressionParser.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99NoCastExpressionParser.java index 7de63328cd8..0a6475bf949 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99NoCastExpressionParser.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99NoCastExpressionParser.java @@ -375,7 +375,7 @@ public C99NoCastExpressionParser(String[] mapFrom) { // constructor // // Rule 41: unary_expression ::= sizeof ( type_name ) // - case 41: { action. consumeExpressionSizeofTypeId(); break; + case 41: { action. consumeExpressionTypeId(IASTTypeIdExpression.op_sizeof); break; } // diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99Parser.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99Parser.java index 2b56eedd292..16f1bae7192 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99Parser.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/c99/C99Parser.java @@ -375,7 +375,7 @@ public C99Parser(String[] mapFrom) { // constructor // // Rule 41: unary_expression ::= sizeof ( type_name ) // - case 41: { action. consumeExpressionSizeofTypeId(); break; + case 41: { action. consumeExpressionTypeId(IASTTypeIdExpression.op_sizeof); break; } // diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPParser.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPParser.java index bf56d609485..f7ee5039469 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPParser.java +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPParser.java @@ -185,7 +185,6 @@ private void initActions(IASTTranslationUnit tu) { public void addToken(IToken token) { token.setKind(mapKind(token.getKind())); - //System.out.println("Token: " + token); super.addToken(token); } diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParser.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParser.java new file mode 100644 index 00000000000..d6130ba4636 --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParser.java @@ -0,0 +1,2045 @@ +/******************************************************************************* +* Copyright (c) 2006, 2008 IBM Corporation and others. +* All rights reserved. This program and the accompanying materials +* are made available under the terms of the Eclipse Public License v1.0 +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl_v10.html +* +* Contributors: +* IBM Corporation - initial API and implementation +*********************************************************************************/ + +// This file was generated by LPG + +package org.eclipse.cdt.internal.core.dom.lrparser.cpp; + +import lpg.lpgjavaruntime.*; + +import java.util.*; + +import org.eclipse.cdt.core.dom.ast.*; +import org.eclipse.cdt.core.dom.ast.cpp.*; +import org.eclipse.cdt.core.dom.lrparser.action.cpp.CPPASTNodeFactory; +import org.eclipse.cdt.core.dom.lrparser.action.cpp.CPPBuildASTParserAction; +import org.eclipse.cdt.core.dom.lrparser.IParser; +import org.eclipse.cdt.core.dom.lrparser.IParserActionTokenProvider; +import org.eclipse.cdt.core.dom.lrparser.util.DebugUtil; + +import org.eclipse.cdt.core.dom.lrparser.action.ITokenMap; +import org.eclipse.cdt.core.dom.lrparser.action.TokenMap; + +public class CPPSizeofExpressionParser extends PrsStream implements RuleAction , IParserActionTokenProvider, IParser +{ + private static ParseTable prs = new CPPSizeofExpressionParserprs(); + private BacktrackingParser btParser; + + public BacktrackingParser getParser() { return btParser; } + private void setResult(Object object) { btParser.setSym1(object); } + public Object getRhsSym(int i) { return btParser.getSym(i); } + + public int getRhsTokenIndex(int i) { return btParser.getToken(i); } + public IToken getRhsIToken(int i) { return super.getIToken(getRhsTokenIndex(i)); } + + public int getRhsFirstTokenIndex(int i) { return btParser.getFirstToken(i); } + public IToken getRhsFirstIToken(int i) { return super.getIToken(getRhsFirstTokenIndex(i)); } + + public int getRhsLastTokenIndex(int i) { return btParser.getLastToken(i); } + public IToken getRhsLastIToken(int i) { return super.getIToken(getRhsLastTokenIndex(i)); } + + public int getLeftSpan() { return btParser.getFirstToken(); } + public IToken getLeftIToken() { return super.getIToken(getLeftSpan()); } + + public int getRightSpan() { return btParser.getLastToken(); } + public IToken getRightIToken() { return super.getIToken(getRightSpan()); } + + public int getRhsErrorTokenIndex(int i) + { + int index = btParser.getToken(i); + IToken err = super.getIToken(index); + return (err instanceof ErrorToken ? index : 0); + } + public ErrorToken getRhsErrorIToken(int i) + { + int index = btParser.getToken(i); + IToken err = super.getIToken(index); + return (ErrorToken) (err instanceof ErrorToken ? err : null); + } + + public CPPSizeofExpressionParser(LexStream lexStream) + { + super(lexStream); + + try + { + super.remapTerminalSymbols(orderedTerminalSymbols(), CPPSizeofExpressionParserprs.EOFT_SYMBOL); + } + catch(NullExportedSymbolsException e) { + } + catch(NullTerminalSymbolsException e) { + } + catch(UnimplementedTerminalsException e) + { + java.util.ArrayList unimplemented_symbols = e.getSymbols(); + System.out.println("The Lexer will not scan the following token(s):"); + for (int i = 0; i < unimplemented_symbols.size(); i++) + { + Integer id = (Integer) unimplemented_symbols.get(i); + System.out.println(" " + CPPSizeofExpressionParsersym.orderedTerminalSymbols[id.intValue()]); + } + System.out.println(); + } + catch(UndefinedEofSymbolException e) + { + throw new Error(new UndefinedEofSymbolException + ("The Lexer does not implement the Eof symbol " + + CPPSizeofExpressionParsersym.orderedTerminalSymbols[CPPSizeofExpressionParserprs.EOFT_SYMBOL])); + } + } + + public String[] orderedTerminalSymbols() { return CPPSizeofExpressionParsersym.orderedTerminalSymbols; } + public String getTokenKindName(int kind) { return CPPSizeofExpressionParsersym.orderedTerminalSymbols[kind]; } + public int getEOFTokenKind() { return CPPSizeofExpressionParserprs.EOFT_SYMBOL; } + public PrsStream getParseStream() { return (PrsStream) this; } + + // + // Report error message for given error_token. + // + public final void reportErrorTokenMessage(int error_token, String msg) + { + int firsttok = super.getFirstErrorToken(error_token), + lasttok = super.getLastErrorToken(error_token); + String location = super.getFileName() + ':' + + (firsttok > lasttok + ? (super.getEndLine(lasttok) + ":" + super.getEndColumn(lasttok)) + : (super.getLine(error_token) + ":" + + super.getColumn(error_token) + ":" + + super.getEndLine(error_token) + ":" + + super.getEndColumn(error_token))) + + ": "; + super.reportError((firsttok > lasttok ? ParseErrorCodes.INSERTION_CODE : ParseErrorCodes.SUBSTITUTION_CODE), location, msg); + } + + public Object parser() + { + return parser(null, 0); + } + + public Object parser(Monitor monitor) + { + return parser(monitor, 0); + } + + public Object parser(int error_repair_count) + { + return parser(null, error_repair_count); + } + + public Object parser(Monitor monitor, int error_repair_count) + { + try + { + btParser = new BacktrackingParser(monitor, (TokenStream) this, prs, (RuleAction) this); + } + catch (NotBacktrackParseTableException e) + { + throw new Error(new NotBacktrackParseTableException + ("Regenerate CPPSizeofExpressionParserprs.java with -BACKTRACK option")); + } + catch (BadParseSymFileException e) + { + throw new Error(new BadParseSymFileException("Bad Parser Symbol File -- CPPSizeofExpressionParsersym.java")); + } + + try + { + return (Object) btParser.parse(error_repair_count); + } + catch (BadParseException e) + { + reset(e.error_token); // point to error token + DiagnoseParser diagnoseParser = new DiagnoseParser(this, prs); + diagnoseParser.diagnose(e.error_token); + } + + return null; + } + + +private CPPParserAction action; + +// uncomment to use with backtracking parser +public CPPSizeofExpressionParser() { // constructor +} + +private void initActions(IASTTranslationUnit tu) { + // binding resolution actions need access to IASTName nodes, temporary + action = new CPPParserAction (); + //action.resolver = new C99TypedefTrackerParserAction (this); + action.builder = new CPPBuildASTParserAction ( CPPASTNodeFactory.DEFAULT_INSTANCE , this, tu); + //action.builder.setTokenMap(CPPParsersym.orderedTerminalSymbols); + + // comment this line to use with backtracking parser + //setParserAction(action); +} + + +public void addToken(IToken token) { + token.setKind(mapKind(token.getKind())); + super.addToken(token); +} + + +public IASTCompletionNode parse(IASTTranslationUnit tu) { + // this has to be done, or... kaboom! + setStreamLength(getSize()); + initActions(tu); + + final int errorRepairCount = -1; // _1 means full error handling + parser(null, errorRepairCount); // do the actual parse + super.resetTokenStream(); // allow tokens to be garbage collected + + // the completion node may be null + IASTCompletionNode compNode = action.builder.getASTCompletionNode(); + + //action = null; // causes getSecondaryParseResult() to fail + + // Comment this line to use with backtracking parser + //parserAction = null; + + return compNode; +} + + +public int getKind(int i) { + int kind = super.getKind(i); + + // There used to be a special token kind for zero used to parser pure virtual function declarations. + // But it turned out to be easier to just parse them as an init_declarator and programaticaly check + // for pure virtual, see consumeMemberDeclaratorWithInitializer(). + + //if(kind == CPPParsersym.TK_integer && "0".equals(getTokenText(i))) { //$NON-NLS-1$ + // kind = CPPParsersym.TK_zero; + //} + + // lexer feedback hack! + //else if(kind == C99Parsersym.TK_identifier && action.resolver.isTypedef(getTokenText(i))) { + // kind = C99Parsersym.TK_TypedefName; + //} + + return kind; +} + + +// uncomment this method to use with backtracking parser +public List getRuleTokens() { + return Collections.unmodifiableList(getTokens().subList(getLeftSpan(), getRightSpan() + 1)); +} + + +public IASTNode getSecondaryParseResult() { + return action.builder.getSecondaryParseResult(); +} + + +private ITokenMap tokenMap = null; + +public void setTokens(List tokens) { + resetTokenStream(); + addToken(new Token(null, 0, 0, 0)); // dummy token + for(IToken token : tokens) { + token.setKind(tokenMap.mapKind(token.getKind())); + addToken(token); + } + addToken(new Token(null, 0, 0, CPPSizeofExpressionParsersym.TK_EOF_TOKEN)); +} + +public CPPSizeofExpressionParser(String[] mapFrom) { // constructor + tokenMap = new TokenMap(CPPSizeofExpressionParsersym.orderedTerminalSymbols, mapFrom); +} + + + + public void ruleAction(int ruleNumber) + { + switch (ruleNumber) + { + + // + // Rule 1: ::= $Empty + // + case 1: { action.builder. + openASTScope(); break; + } + + // + // Rule 2: ::= $Empty + // + case 2: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 11: translation_unit ::= external_declaration_list + // + case 11: { action.builder. + consumeTranslationUnit(); break; + } + + // + // Rule 12: translation_unit ::= $Empty + // + case 12: { action.builder. + consumeTranslationUnit(); break; + } + + // + // Rule 16: external_declaration ::= ERROR_TOKEN + // + case 16: { action.builder. + consumeDeclarationProblem(); break; + } + + // + // Rule 19: literal ::= integer + // + case 19: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_integer_constant); break; + } + + // + // Rule 20: literal ::= 0 + // + case 20: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_integer_constant); break; + } + + // + // Rule 21: literal ::= floating + // + case 21: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_float_constant); break; + } + + // + // Rule 22: literal ::= charconst + // + case 22: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_char_constant); break; + } + + // + // Rule 23: literal ::= stringlit + // + case 23: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_string_literal); break; + } + + // + // Rule 24: literal ::= true + // + case 24: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_true); break; + } + + // + // Rule 25: literal ::= false + // + case 25: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_false); break; + } + + // + // Rule 26: literal ::= this + // + case 26: { action.builder. + consumeExpressionLiteral(ICPPASTLiteralExpression.lk_this); break; + } + + // + // Rule 28: primary_expression ::= ( expression ) + // + case 28: { action.builder. + consumeExpressionBracketed(); break; + } + + // + // Rule 30: id_expression ::= qualified_or_unqualified_name + // + case 30: { action.builder. + consumeExpressionName(); break; + } + + // + // Rule 37: unqualified_id_name ::= ~ class_name + // + case 37: { action.builder. + consumeDestructorName(); break; + } + + // + // Rule 38: identifier_name ::= identifier_token + // + case 38: { action.builder. + consumeIdentifierName(); break; + } + + // + // Rule 39: template_opt ::= template + // + case 39: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 40: template_opt ::= $Empty + // + case 40: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 41: dcolon_opt ::= :: + // + case 41: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 42: dcolon_opt ::= $Empty + // + case 42: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 43: qualified_id_name ::= dcolon_opt nested_name_specifier template_opt unqualified_id_name + // + case 43: { action.builder. + consumeQualifiedId(true); break; + } + + // + // Rule 44: qualified_id_name ::= :: identifier_name + // + case 44: { action.builder. + consumeGlobalQualifiedId(); break; + } + + // + // Rule 45: qualified_id_name ::= :: operator_function_id_name + // + case 45: { action.builder. + consumeGlobalQualifiedId(); break; + } + + // + // Rule 46: qualified_id_name ::= :: template_id_name + // + case 46: { action.builder. + consumeGlobalQualifiedId(); break; + } + + // + // Rule 47: nested_name_specifier ::= class_or_namespace_name :: nested_name_specifier_with_template + // + case 47: { action.builder. + consumeNestedNameSpecifier(true); break; + } + + // + // Rule 48: nested_name_specifier ::= class_or_namespace_name :: + // + case 48: { action.builder. + consumeNestedNameSpecifier(false); break; + } + + // + // Rule 49: nested_name_specifier_with_template ::= class_or_namespace_name_with_template :: nested_name_specifier_with_template + // + case 49: { action.builder. + consumeNestedNameSpecifier(true); break; + } + + // + // Rule 50: nested_name_specifier_with_template ::= class_or_namespace_name_with_template :: + // + case 50: { action.builder. + consumeNestedNameSpecifier(false); break; + } + + // + // Rule 51: class_or_namespace_name_with_template ::= template_opt class_or_namespace_name + // + case 51: { action.builder. + consumeNameWithTemplateKeyword(); break; + } + + // + // Rule 53: nested_name_specifier_opt ::= $Empty + // + case 53: { action.builder. + consumeNestedNameSpecifierEmpty(); break; + } + + // + // Rule 57: postfix_expression ::= postfix_expression [ expression ] + // + case 57: { action.builder. + consumeExpressionArraySubscript(); break; + } + + // + // Rule 58: postfix_expression ::= postfix_expression ( expression_list_opt ) + // + case 58: { action.builder. + consumeExpressionFunctionCall(); break; + } + + // + // Rule 59: postfix_expression ::= simple_type_specifier ( expression_list_opt ) + // + case 59: { action.builder. + consumeExpressionSimpleTypeConstructor(); break; + } + + // + // Rule 60: postfix_expression ::= typename dcolon_opt nested_name_specifier identifier_name ( expression_list_opt ) + // + case 60: { action.builder. + consumeExpressionTypeName(); break; + } + + // + // Rule 61: postfix_expression ::= typename dcolon_opt nested_name_specifier template_opt template_id_name ( expression_list_opt ) + // + case 61: { action.builder. + consumeExpressionTypeName(); break; + } + + // + // Rule 62: postfix_expression ::= postfix_expression . qualified_or_unqualified_name + // + case 62: { action.builder. + consumeExpressionFieldReference(false, false); break; + } + + // + // Rule 63: postfix_expression ::= postfix_expression -> qualified_or_unqualified_name + // + case 63: { action.builder. + consumeExpressionFieldReference(true, false); break; + } + + // + // Rule 64: postfix_expression ::= postfix_expression . template qualified_or_unqualified_name + // + case 64: { action.builder. + consumeExpressionFieldReference(false, true); break; + } + + // + // Rule 65: postfix_expression ::= postfix_expression -> template qualified_or_unqualified_name + // + case 65: { action.builder. + consumeExpressionFieldReference(true, true); break; + } + + // + // Rule 66: postfix_expression ::= postfix_expression . pseudo_destructor_name + // + case 66: { action.builder. + consumeExpressionFieldReference(false, false); break; + } + + // + // Rule 67: postfix_expression ::= postfix_expression -> pseudo_destructor_name + // + case 67: { action.builder. + consumeExpressionFieldReference(true, false); break; + } + + // + // Rule 68: postfix_expression ::= postfix_expression ++ + // + case 68: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_postFixIncr); break; + } + + // + // Rule 69: postfix_expression ::= postfix_expression -- + // + case 69: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_postFixDecr); break; + } + + // + // Rule 70: postfix_expression ::= dynamic_cast < type_id > ( expression ) + // + case 70: { action.builder. + consumeExpressionCast(ICPPASTCastExpression.op_dynamic_cast); break; + } + + // + // Rule 71: postfix_expression ::= static_cast < type_id > ( expression ) + // + case 71: { action.builder. + consumeExpressionCast(ICPPASTCastExpression.op_static_cast); break; + } + + // + // Rule 72: postfix_expression ::= reinterpret_cast < type_id > ( expression ) + // + case 72: { action.builder. + consumeExpressionCast(ICPPASTCastExpression.op_reinterpret_cast); break; + } + + // + // Rule 73: postfix_expression ::= const_cast < type_id > ( expression ) + // + case 73: { action.builder. + consumeExpressionCast(ICPPASTCastExpression.op_const_cast); break; + } + + // + // Rule 74: postfix_expression ::= typeid ( expression ) + // + case 74: { action.builder. + consumeExpressionUnaryOperator(ICPPASTUnaryExpression.op_typeid); break; + } + + // + // Rule 75: pseudo_destructor_name ::= dcolon_opt nested_name_specifier_opt type_name :: ~ type_name + // + case 75: { action.builder. + consumePsudoDestructorName(true); break; + } + + // + // Rule 76: pseudo_destructor_name ::= dcolon_opt nested_name_specifier template template_id_name :: ~ type_name + // + case 76: { action.builder. + consumePsudoDestructorName(true); break; + } + + // + // Rule 77: pseudo_destructor_name ::= dcolon_opt nested_name_specifier_opt ~ type_name + // + case 77: { action.builder. + consumePsudoDestructorName(false); break; + } + + // + // Rule 81: unary_expression ::= ++ cast_expression + // + case 81: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_prefixIncr); break; + } + + // + // Rule 82: unary_expression ::= -- cast_expression + // + case 82: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_prefixDecr); break; + } + + // + // Rule 83: unary_expression ::= & cast_expression + // + case 83: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_amper); break; + } + + // + // Rule 84: unary_expression ::= * cast_expression + // + case 84: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_star); break; + } + + // + // Rule 85: unary_expression ::= + cast_expression + // + case 85: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_plus); break; + } + + // + // Rule 86: unary_expression ::= - cast_expression + // + case 86: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_minus); break; + } + + // + // Rule 87: unary_expression ::= ~ cast_expression + // + case 87: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_tilde); break; + } + + // + // Rule 88: unary_expression ::= ! cast_expression + // + case 88: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_not); break; + } + + // + // Rule 89: unary_expression ::= sizeof unary_expression + // + case 89: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_sizeof); break; + } + + // + // Rule 90: new_expression ::= dcolon_opt new new_placement_opt new_type_id new_array_expressions_opt new_initializer_opt + // + case 90: { action.builder. + consumeExpressionNew(true); break; + } + + // + // Rule 91: new_expression ::= dcolon_opt new new_placement_opt ( type_id ) new_initializer_opt + // + case 91: { action.builder. + consumeExpressionNew(false); break; + } + + // + // Rule 94: new_placement_opt ::= $Empty + // + case 94: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 95: new_type_id ::= type_specifier_seq + // + case 95: { action.builder. + consumeTypeId(false); break; + } + + // + // Rule 96: new_type_id ::= type_specifier_seq new_declarator + // + case 96: { action.builder. + consumeTypeId(true); break; + } + + // + // Rule 97: new_declarator ::= new_pointer_operators + // + case 97: { action.builder. + consumeNewDeclarator(); break; + } + + // + // Rule 106: new_initializer_opt ::= $Empty + // + case 106: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 107: delete_expression ::= dcolon_opt delete cast_expression + // + case 107: { action.builder. + consumeExpressionDelete(false); break; + } + + // + // Rule 108: delete_expression ::= dcolon_opt delete [ ] cast_expression + // + case 108: { action.builder. + consumeExpressionDelete(true); break; + } + + // + // Rule 110: cast_expression ::= ( type_id ) cast_expression + // + case 110: { action.builder. + consumeExpressionCast(ICPPASTCastExpression.op_cast); break; + } + + // + // Rule 112: pm_expression ::= pm_expression .* cast_expression + // + case 112: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_pmdot); break; + } + + // + // Rule 113: pm_expression ::= pm_expression ->* cast_expression + // + case 113: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_pmarrow); break; + } + + // + // Rule 115: multiplicative_expression ::= multiplicative_expression * pm_expression + // + case 115: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_multiply); break; + } + + // + // Rule 116: multiplicative_expression ::= multiplicative_expression / pm_expression + // + case 116: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_divide); break; + } + + // + // Rule 117: multiplicative_expression ::= multiplicative_expression % pm_expression + // + case 117: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_modulo); break; + } + + // + // Rule 119: additive_expression ::= additive_expression + multiplicative_expression + // + case 119: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_plus); break; + } + + // + // Rule 120: additive_expression ::= additive_expression - multiplicative_expression + // + case 120: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_minus); break; + } + + // + // Rule 122: shift_expression ::= shift_expression << additive_expression + // + case 122: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftLeft); break; + } + + // + // Rule 123: shift_expression ::= shift_expression >> additive_expression + // + case 123: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftRight); break; + } + + // + // Rule 125: relational_expression ::= relational_expression < shift_expression + // + case 125: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessThan); break; + } + + // + // Rule 126: relational_expression ::= relational_expression > shift_expression + // + case 126: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterThan); break; + } + + // + // Rule 127: relational_expression ::= relational_expression <= shift_expression + // + case 127: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessEqual); break; + } + + // + // Rule 128: relational_expression ::= relational_expression >= shift_expression + // + case 128: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterEqual); break; + } + + // + // Rule 130: equality_expression ::= equality_expression == relational_expression + // + case 130: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_equals); break; + } + + // + // Rule 131: equality_expression ::= equality_expression != relational_expression + // + case 131: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_notequals); break; + } + + // + // Rule 133: and_expression ::= and_expression & equality_expression + // + case 133: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAnd); break; + } + + // + // Rule 135: exclusive_or_expression ::= exclusive_or_expression ^ and_expression + // + case 135: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXor); break; + } + + // + // Rule 137: inclusive_or_expression ::= inclusive_or_expression | exclusive_or_expression + // + case 137: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOr); break; + } + + // + // Rule 139: logical_and_expression ::= logical_and_expression && inclusive_or_expression + // + case 139: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalAnd); break; + } + + // + // Rule 141: logical_or_expression ::= logical_or_expression || logical_and_expression + // + case 141: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalOr); break; + } + + // + // Rule 143: conditional_expression ::= logical_or_expression ? expression : assignment_expression + // + case 143: { action.builder. + consumeExpressionConditional(); break; + } + + // + // Rule 144: throw_expression ::= throw + // + case 144: { action.builder. + consumeExpressionThrow(false); break; + } + + // + // Rule 145: throw_expression ::= throw assignment_expression + // + case 145: { action.builder. + consumeExpressionThrow(true); break; + } + + // + // Rule 148: assignment_expression ::= logical_or_expression = assignment_expression + // + case 148: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_assign); break; + } + + // + // Rule 149: assignment_expression ::= logical_or_expression *= assignment_expression + // + case 149: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_multiplyAssign); break; + } + + // + // Rule 150: assignment_expression ::= logical_or_expression /= assignment_expression + // + case 150: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_divideAssign); break; + } + + // + // Rule 151: assignment_expression ::= logical_or_expression %= assignment_expression + // + case 151: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_moduloAssign); break; + } + + // + // Rule 152: assignment_expression ::= logical_or_expression += assignment_expression + // + case 152: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_plusAssign); break; + } + + // + // Rule 153: assignment_expression ::= logical_or_expression -= assignment_expression + // + case 153: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_minusAssign); break; + } + + // + // Rule 154: assignment_expression ::= logical_or_expression >>= assignment_expression + // + case 154: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftRightAssign); break; + } + + // + // Rule 155: assignment_expression ::= logical_or_expression <<= assignment_expression + // + case 155: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftLeftAssign); break; + } + + // + // Rule 156: assignment_expression ::= logical_or_expression &= assignment_expression + // + case 156: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAndAssign); break; + } + + // + // Rule 157: assignment_expression ::= logical_or_expression ^= assignment_expression + // + case 157: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXorAssign); break; + } + + // + // Rule 158: assignment_expression ::= logical_or_expression |= assignment_expression + // + case 158: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOrAssign); break; + } + + // + // Rule 160: expression ::= ERROR_TOKEN + // + case 160: { action.builder. + consumeExpressionProblem(); break; + } + + // + // Rule 161: expression_list ::= expression_list_actual + // + case 161: { action.builder. + consumeExpressionList(); break; + } + + // + // Rule 165: expression_list_opt ::= $Empty + // + case 165: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 167: expression_opt ::= $Empty + // + case 167: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 170: constant_expression_opt ::= $Empty + // + case 170: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 179: statement ::= ERROR_TOKEN + // + case 179: { action.builder. + consumeStatementProblem(); break; + } + + // + // Rule 180: labeled_statement ::= identifier : statement + // + case 180: { action.builder. + consumeStatementLabeled(); break; + } + + // + // Rule 181: labeled_statement ::= case constant_expression : + // + case 181: { action.builder. + consumeStatementCase(); break; + } + + // + // Rule 182: labeled_statement ::= default : + // + case 182: { action.builder. + consumeStatementDefault(); break; + } + + // + // Rule 183: expression_statement ::= expression ; + // + case 183: { action.builder. + consumeStatementExpression(); break; + } + + // + // Rule 184: expression_statement ::= ; + // + case 184: { action.builder. + consumeStatementNull(); break; + } + + // + // Rule 185: compound_statement ::= { statement_seq } + // + case 185: { action.builder. + consumeStatementCompoundStatement(true); break; + } + + // + // Rule 186: compound_statement ::= { } + // + case 186: { action.builder. + consumeStatementCompoundStatement(false); break; + } + + // + // Rule 189: selection_statement ::= if ( condition ) statement + // + case 189: { action.builder. + consumeStatementIf(false); break; + } + + // + // Rule 190: selection_statement ::= if ( condition ) statement else statement + // + case 190: { action.builder. + consumeStatementIf(true); break; + } + + // + // Rule 191: selection_statement ::= switch ( condition ) statement + // + case 191: { action.builder. + consumeStatementSwitch(); break; + } + + // + // Rule 193: condition ::= type_specifier_seq declarator = assignment_expression + // + case 193: { action.builder. + consumeConditionDeclaration(); break; + } + + // + // Rule 194: iteration_statement ::= while ( condition ) statement + // + case 194: { action.builder. + consumeStatementWhileLoop(); break; + } + + // + // Rule 195: iteration_statement ::= do statement while ( expression ) ; + // + case 195: { action.builder. + consumeStatementDoLoop(); break; + } + + // + // Rule 196: iteration_statement ::= for ( expression_opt ; expression_opt ; expression_opt ) statement + // + case 196: { action.builder. + consumeStatementForLoop(); break; + } + + // + // Rule 197: iteration_statement ::= for ( simple_declaration expression_opt ; expression_opt ) statement + // + case 197: { action.builder. + consumeStatementForLoop(); break; + } + + // + // Rule 198: jump_statement ::= break ; + // + case 198: { action.builder. + consumeStatementBreak(); break; + } + + // + // Rule 199: jump_statement ::= continue ; + // + case 199: { action.builder. + consumeStatementContinue(); break; + } + + // + // Rule 200: jump_statement ::= return expression ; + // + case 200: { action.builder. + consumeStatementReturn(true); break; + } + + // + // Rule 201: jump_statement ::= return ; + // + case 201: { action.builder. + consumeStatementReturn(false); break; + } + + // + // Rule 202: jump_statement ::= goto identifier_token ; + // + case 202: { action.builder. + consumeStatementGoto(); break; + } + + // + // Rule 203: declaration_statement ::= block_declaration + // + case 203: { action.builder. + consumeStatementDeclaration(); break; + } + + // + // Rule 220: simple_declaration ::= declaration_specifiers_opt init_declarator_list_opt ; + // + case 220: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 221: declaration_specifiers ::= simple_declaration_specifiers + // + case 221: { action.builder. + consumeDeclarationSpecifiersSimple(); break; + } + + // + // Rule 222: declaration_specifiers ::= class_declaration_specifiers + // + case 222: { action.builder. + consumeDeclarationSpecifiersComposite(); break; + } + + // + // Rule 223: declaration_specifiers ::= elaborated_declaration_specifiers + // + case 223: { action.builder. + consumeDeclarationSpecifiersComposite(); break; + } + + // + // Rule 224: declaration_specifiers ::= enum_declaration_specifiers + // + case 224: { action.builder. + consumeDeclarationSpecifiersComposite(); break; + } + + // + // Rule 225: declaration_specifiers ::= type_name_declaration_specifiers + // + case 225: { action.builder. + consumeDeclarationSpecifiersTypeName(); break; + } + + // + // Rule 227: declaration_specifiers_opt ::= $Empty + // + case 227: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 231: no_type_declaration_specifier ::= friend + // + case 231: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 232: no_type_declaration_specifier ::= typedef + // + case 232: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 261: simple_type_specifier ::= simple_type_specifier_token + // + case 261: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 277: type_name_specifier ::= dcolon_opt nested_name_specifier_opt type_name + // + case 277: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 278: type_name_specifier ::= dcolon_opt nested_name_specifier template template_id_name + // + case 278: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 279: type_name_specifier ::= typename dcolon_opt nested_name_specifier identifier_name + // + case 279: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 280: type_name_specifier ::= typename dcolon_opt nested_name_specifier template_opt template_id_name + // + case 280: { action.builder. + consumeQualifiedId(true); break; + } + + // + // Rule 281: elaborated_type_specifier ::= class_keyword dcolon_opt nested_name_specifier_opt identifier_name + // + case 281: { action.builder. + consumeTypeSpecifierElaborated(false); break; + } + + // + // Rule 282: elaborated_type_specifier ::= class_keyword dcolon_opt nested_name_specifier_opt template_opt template_id_name + // + case 282: { action.builder. + consumeTypeSpecifierElaborated(true); break; + } + + // + // Rule 283: elaborated_type_specifier ::= enum dcolon_opt nested_name_specifier_opt identifier_name + // + case 283: { action.builder. + consumeTypeSpecifierElaborated(false); break; + } + + // + // Rule 285: enum_specifier ::= enum { enumerator_list_opt } + // + case 285: { action.builder. + consumeTypeSpecifierEnumeration(false); break; + } + + // + // Rule 286: enum_specifier ::= enum identifier_token { enumerator_list_opt } + // + case 286: { action.builder. + consumeTypeSpecifierEnumeration(true); break; + } + + // + // Rule 291: enumerator_definition ::= enumerator + // + case 291: { action.builder. + consumeEnumerator(false); break; + } + + // + // Rule 292: enumerator_definition ::= enumerator = constant_expression + // + case 292: { action.builder. + consumeEnumerator(true); break; + } + + // + // Rule 301: original_namespace_definition ::= namespace identifier_name { declaration_seq_opt } + // + case 301: { action.builder. + consumeNamespaceDefinition(true); break; + } + + // + // Rule 302: extension_namespace_definition ::= namespace original_namespace_name { declaration_seq_opt } + // + case 302: { action.builder. + consumeNamespaceDefinition(true); break; + } + + // + // Rule 303: unnamed_namespace_definition ::= namespace { declaration_seq_opt } + // + case 303: { action.builder. + consumeNamespaceDefinition(false); break; + } + + // + // Rule 305: namespace_alias_definition ::= namespace identifier_token = dcolon_opt nested_name_specifier_opt namespace_name ; + // + case 305: { action.builder. + consumeNamespaceAliasDefinition(); break; + } + + // + // Rule 306: using_declaration ::= using typename_opt dcolon_opt nested_name_specifier_opt unqualified_id_name ; + // + case 306: { action.builder. + consumeUsingDeclaration(); break; + } + + // + // Rule 307: typename_opt ::= typename + // + case 307: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 308: typename_opt ::= $Empty + // + case 308: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 309: using_directive ::= using namespace dcolon_opt nested_name_specifier_opt namespace_name ; + // + case 309: { action.builder. + consumeUsingDirective(); break; + } + + // + // Rule 310: asm_definition ::= asm ( stringlit ) ; + // + case 310: { action.builder. + consumeDeclarationASM(); break; + } + + // + // Rule 311: linkage_specification ::= extern stringlit { declaration_seq_opt } + // + case 311: { action.builder. + consumeLinkageSpecification(); break; + } + + // + // Rule 312: linkage_specification ::= extern stringlit declaration + // + case 312: { action.builder. + consumeLinkageSpecification(); break; + } + + // + // Rule 318: init_declarator ::= declarator initializer + // + case 318: { action.builder. + consumeDeclaratorWithInitializer(true); break; + } + + // + // Rule 320: declarator ::= ptr_operator_seq direct_declarator + // + case 320: { action.builder. + consumeDeclaratorWithPointer(true); break; + } + + // + // Rule 322: function_declarator ::= ptr_operator_seq direct_declarator + // + case 322: { action.builder. + consumeDeclaratorWithPointer(true); break; + } + + // + // Rule 326: basic_direct_declarator ::= declarator_id_name + // + case 326: { action.builder. + consumeDirectDeclaratorIdentifier(); break; + } + + // + // Rule 327: basic_direct_declarator ::= ( declarator ) + // + case 327: { action.builder. + consumeDirectDeclaratorBracketed(); break; + } + + // + // Rule 328: function_direct_declarator ::= basic_direct_declarator ( parameter_declaration_clause ) cv_qualifier_seq_opt exception_specification_opt + // + case 328: { action.builder. + consumeDirectDeclaratorFunctionDeclarator(true); break; + } + + // + // Rule 329: array_direct_declarator ::= array_direct_declarator array_modifier + // + case 329: { action.builder. + consumeDirectDeclaratorArrayDeclarator(true); break; + } + + // + // Rule 330: array_direct_declarator ::= basic_direct_declarator array_modifier + // + case 330: { action.builder. + consumeDirectDeclaratorArrayDeclarator(true); break; + } + + // + // Rule 331: array_modifier ::= [ constant_expression ] + // + case 331: { action.builder. + consumeDirectDeclaratorArrayModifier(true); break; + } + + // + // Rule 332: array_modifier ::= [ ] + // + case 332: { action.builder. + consumeDirectDeclaratorArrayModifier(false); break; + } + + // + // Rule 333: ptr_operator ::= * cv_qualifier_seq_opt + // + case 333: { action.builder. + consumePointer(); break; + } + + // + // Rule 334: ptr_operator ::= & + // + case 334: { action.builder. + consumeReferenceOperator(); break; + } + + // + // Rule 335: ptr_operator ::= dcolon_opt nested_name_specifier * cv_qualifier_seq_opt + // + case 335: { action.builder. + consumePointerToMember(); break; + } + + // + // Rule 341: cv_qualifier ::= const + // + case 341: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 342: cv_qualifier ::= volatile + // + case 342: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 344: declarator_id_name ::= dcolon_opt nested_name_specifier_opt type_name + // + case 344: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 345: type_id ::= type_specifier_seq + // + case 345: { action.builder. + consumeTypeId(false); break; + } + + // + // Rule 346: type_id ::= type_specifier_seq abstract_declarator + // + case 346: { action.builder. + consumeTypeId(true); break; + } + + // + // Rule 349: abstract_declarator ::= ptr_operator_seq + // + case 349: { action.builder. + consumeDeclaratorWithPointer(false); break; + } + + // + // Rule 350: abstract_declarator ::= ptr_operator_seq direct_abstract_declarator + // + case 350: { action.builder. + consumeDeclaratorWithPointer(true); break; + } + + // + // Rule 354: basic_direct_abstract_declarator ::= ( abstract_declarator ) + // + case 354: { action.builder. + consumeDirectDeclaratorBracketed(); break; + } + + // + // Rule 355: array_direct_abstract_declarator ::= array_modifier + // + case 355: { action.builder. + consumeDirectDeclaratorArrayDeclarator(false); break; + } + + // + // Rule 356: array_direct_abstract_declarator ::= array_direct_abstract_declarator array_modifier + // + case 356: { action.builder. + consumeDirectDeclaratorArrayDeclarator(true); break; + } + + // + // Rule 357: array_direct_abstract_declarator ::= basic_direct_abstract_declarator array_modifier + // + case 357: { action.builder. + consumeDirectDeclaratorArrayDeclarator(true); break; + } + + // + // Rule 358: function_direct_abstract_declarator ::= basic_direct_abstract_declarator ( parameter_declaration_clause ) cv_qualifier_seq_opt exception_specification_opt + // + case 358: { action.builder. + consumeDirectDeclaratorFunctionDeclarator(true); break; + } + + // + // Rule 359: function_direct_abstract_declarator ::= ( parameter_declaration_clause ) cv_qualifier_seq_opt exception_specification_opt + // + case 359: { action.builder. + consumeDirectDeclaratorFunctionDeclarator(false); break; + } + + // + // Rule 360: parameter_declaration_clause ::= parameter_declaration_list_opt ... + // + case 360: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 361: parameter_declaration_clause ::= parameter_declaration_list_opt + // + case 361: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 362: parameter_declaration_clause ::= parameter_declaration_list , ... + // + case 362: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 368: abstract_declarator_opt ::= $Empty + // + case 368: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 369: parameter_declaration ::= declaration_specifiers parameter_init_declarator + // + case 369: { action.builder. + consumeParameterDeclaration(); break; + } + + // + // Rule 370: parameter_declaration ::= declaration_specifiers + // + case 370: { action.builder. + consumeParameterDeclarationWithoutDeclarator(); break; + } + + // + // Rule 372: parameter_init_declarator ::= declarator = parameter_initializer + // + case 372: { action.builder. + consumeDeclaratorWithInitializer(true); break; + } + + // + // Rule 374: parameter_init_declarator ::= abstract_declarator = parameter_initializer + // + case 374: { action.builder. + consumeDeclaratorWithInitializer(true); break; + } + + // + // Rule 375: parameter_init_declarator ::= = parameter_initializer + // + case 375: { action.builder. + consumeDeclaratorWithInitializer(false); break; + } + + // + // Rule 376: parameter_initializer ::= assignment_expression + // + case 376: { action.builder. + consumeInitializer(); break; + } + + // + // Rule 377: function_definition ::= declaration_specifiers_opt function_declarator ctor_initializer_list_opt function_body + // + case 377: { action.builder. + consumeFunctionDefinition(false); break; + } + + // + // Rule 378: function_definition ::= declaration_specifiers_opt function_declarator try ctor_initializer_list_opt function_body handler_seq + // + case 378: { action.builder. + consumeFunctionDefinition(true); break; + } + + // + // Rule 381: initializer ::= ( expression_list ) + // + case 381: { action.builder. + consumeInitializerConstructor(); break; + } + + // + // Rule 382: initializer_clause ::= assignment_expression + // + case 382: { action.builder. + consumeInitializer(); break; + } + + // + // Rule 383: initializer_clause ::= { initializer_list , } + // + case 383: { action.builder. + consumeInitializerList(); break; + } + + // + // Rule 384: initializer_clause ::= { initializer_list } + // + case 384: { action.builder. + consumeInitializerList(); break; + } + + // + // Rule 385: initializer_clause ::= { } + // + case 385: { action.builder. + consumeInitializerList(); break; + } + + // + // Rule 390: class_specifier ::= class_head { member_declaration_list_opt } + // + case 390: { action.builder. + consumeClassSpecifier(); break; + } + + // + // Rule 391: class_head ::= class_keyword identifier_name_opt base_clause_opt + // + case 391: { action.builder. + consumeClassHead(false); break; + } + + // + // Rule 392: class_head ::= class_keyword template_id_name base_clause_opt + // + case 392: { action.builder. + consumeClassHead(false); break; + } + + // + // Rule 393: class_head ::= class_keyword nested_name_specifier identifier_name base_clause_opt + // + case 393: { action.builder. + consumeClassHead(true); break; + } + + // + // Rule 394: class_head ::= class_keyword nested_name_specifier template_id_name base_clause_opt + // + case 394: { action.builder. + consumeClassHead(true); break; + } + + // + // Rule 396: identifier_name_opt ::= $Empty + // + case 396: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 400: visibility_label ::= access_specifier_keyword : + // + case 400: { action.builder. + consumeVisibilityLabel(); break; + } + + // + // Rule 401: member_declaration ::= declaration_specifiers_opt member_declarator_list ; + // + case 401: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 402: member_declaration ::= declaration_specifiers_opt ; + // + case 402: { action.builder. + consumeDeclarationSimple(false); break; + } + + // + // Rule 405: member_declaration ::= dcolon_opt nested_name_specifier template_opt unqualified_id_name ; + // + case 405: { action.builder. + consumeMemberDeclarationQualifiedId(); break; + } + + // + // Rule 409: member_declaration ::= ERROR_TOKEN + // + case 409: { action.builder. + consumeDeclarationProblem(); break; + } + + // + // Rule 417: member_declarator ::= declarator constant_initializer + // + case 417: { action.builder. + consumeMemberDeclaratorWithInitializer(); break; + } + + // + // Rule 418: member_declarator ::= bit_field_declarator : constant_expression + // + case 418: { action.builder. + consumeBitField(true); break; + } + + // + // Rule 419: member_declarator ::= : constant_expression + // + case 419: { action.builder. + consumeBitField(false); break; + } + + // + // Rule 420: bit_field_declarator ::= identifier_name + // + case 420: { action.builder. + consumeDirectDeclaratorIdentifier(); break; + } + + // + // Rule 427: base_specifier ::= dcolon_opt nested_name_specifier_opt class_name + // + case 427: { action.builder. + consumeBaseSpecifier(false); break; + } + + // + // Rule 428: base_specifier ::= virtual_opt access_specifier_keyword virtual_opt dcolon_opt nested_name_specifier_opt class_name + // + case 428: { action.builder. + consumeBaseSpecifier(true); break; + } + + // + // Rule 429: virtual_opt ::= virtual + // + case 429: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 430: virtual_opt ::= $Empty + // + case 430: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 436: conversion_function_id_name ::= operator conversion_type_id + // + case 436: { action.builder. + consumeConversionName(); break; + } + + // + // Rule 437: conversion_type_id ::= type_specifier_seq conversion_declarator + // + case 437: { action.builder. + consumeTypeId(true); break; + } + + // + // Rule 438: conversion_type_id ::= type_specifier_seq + // + case 438: { action.builder. + consumeTypeId(false); break; + } + + // + // Rule 439: conversion_declarator ::= ptr_operator_seq + // + case 439: { action.builder. + consumeDeclaratorWithPointer(false); break; + } + + // + // Rule 445: mem_initializer ::= mem_initializer_name ( expression_list_opt ) + // + case 445: { action.builder. + consumeConstructorChainInitializer(); break; + } + + // + // Rule 446: mem_initializer_name ::= dcolon_opt nested_name_specifier_opt class_name + // + case 446: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 449: operator_function_id_name ::= operator_id_name < template_argument_list_opt > + // + case 449: { action.builder. + consumeTemplateId(); break; + } + + // + // Rule 450: operator_id_name ::= operator overloadable_operator + // + case 450: { action.builder. + consumeOperatorName(); break; + } + + // + // Rule 493: template_declaration ::= export_opt template < template_parameter_list > declaration + // + case 493: { action.builder. + consumeTemplateDeclaration(); break; + } + + // + // Rule 494: export_opt ::= export + // + case 494: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 495: export_opt ::= $Empty + // + case 495: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 500: type_parameter ::= class identifier_name_opt + // + case 500: { action.builder. + consumeSimpleTypeTemplateParameter(false); break; + } + + // + // Rule 501: type_parameter ::= class identifier_name_opt = type_id + // + case 501: { action.builder. + consumeSimpleTypeTemplateParameter(true); break; + } + + // + // Rule 502: type_parameter ::= typename identifier_name_opt + // + case 502: { action.builder. + consumeSimpleTypeTemplateParameter(false); break; + } + + // + // Rule 503: type_parameter ::= typename identifier_name_opt = type_id + // + case 503: { action.builder. + consumeSimpleTypeTemplateParameter(true); break; + } + + // + // Rule 504: type_parameter ::= template < template_parameter_list > class identifier_name_opt + // + case 504: { action.builder. + consumeTemplatedTypeTemplateParameter(false); break; + } + + // + // Rule 505: type_parameter ::= template < template_parameter_list > class identifier_name_opt = id_expression + // + case 505: { action.builder. + consumeTemplatedTypeTemplateParameter(true); break; + } + + // + // Rule 506: template_id_name ::= template_identifier < template_argument_list_opt > + // + case 506: { action.builder. + consumeTemplateId(); break; + } + + // + // Rule 515: explicit_instantiation ::= template declaration + // + case 515: { action.builder. + consumeTemplateExplicitInstantiation(); break; + } + + // + // Rule 516: explicit_specialization ::= template < > declaration + // + case 516: { action.builder. + consumeTemplateExplicitSpecialization(); break; + } + + // + // Rule 517: try_block ::= try compound_statement handler_seq + // + case 517: { action.builder. + consumeStatementTryBlock(); break; + } + + // + // Rule 520: handler ::= catch ( exception_declaration ) compound_statement + // + case 520: { action.builder. + consumeStatementCatchHandler(false); break; + } + + // + // Rule 521: handler ::= catch ( ... ) compound_statement + // + case 521: { action.builder. + consumeStatementCatchHandler(true); break; + } + + // + // Rule 522: exception_declaration ::= type_specifier_seq declarator + // + case 522: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 523: exception_declaration ::= type_specifier_seq abstract_declarator + // + case 523: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 524: exception_declaration ::= type_specifier_seq + // + case 524: { action.builder. + consumeDeclarationSimple(false); break; + } + + // + // Rule 532: no_sizeof_type_name_start ::= ERROR_TOKEN + // + case 532: { action.builder. + consumeExpressionProblem(); break; + } + + + default: + break; + } + return; + } +} + diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParserprs.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParserprs.java new file mode 100644 index 00000000000..d11681d6114 --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParserprs.java @@ -0,0 +1,2870 @@ +/******************************************************************************* +* Copyright (c) 2006, 2008 IBM Corporation and others. +* All rights reserved. This program and the accompanying materials +* are made available under the terms of the Eclipse Public License v1.0 +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl_v10.html +* +* Contributors: +* IBM Corporation - initial API and implementation +*********************************************************************************/ + +// This file was generated by LPG + +package org.eclipse.cdt.internal.core.dom.lrparser.cpp; + +public class CPPSizeofExpressionParserprs implements lpg.lpgjavaruntime.ParseTable, CPPSizeofExpressionParsersym { + + public interface IsKeyword { + public final static byte isKeyword[] = {0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0 + }; + }; + public final static byte isKeyword[] = IsKeyword.isKeyword; + public final boolean isKeyword(int index) { return isKeyword[index] != 0; } + + public interface BaseCheck { + public final static short baseCheck[] = {0, + 0,0,1,1,1,1,1,1,1,1, + 1,0,1,2,1,1,1,1,1,1, + 1,1,1,1,1,1,1,3,1,1, + 1,1,1,1,1,1,2,1,1,0, + 1,0,4,2,2,2,3,2,3,2, + 2,1,0,1,1,1,4,4,4,8, + 8,3,3,4,4,3,3,2,2,7, + 7,7,7,4,6,7,4,1,1,1, + 2,2,2,2,2,2,2,2,2,7, + 7,3,1,0,1,2,2,1,2,3, + 4,1,0,3,1,0,3,5,1,4, + 1,3,3,1,3,3,3,1,3,3, + 1,3,3,1,3,3,3,3,1,3, + 3,1,3,1,3,1,3,1,3,1, + 3,1,5,1,2,1,1,3,3,3, + 3,3,3,3,3,3,3,3,1,1, + 2,1,3,1,0,1,0,1,1,0, + 1,1,1,1,1,1,1,1,1,3, + 3,2,2,1,4,2,1,2,5,7, + 5,1,4,5,7,9,8,2,2,3, + 2,3,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,2,1,0,4, + 2,2,2,2,2,1,0,1,1,1, + 1,1,1,2,1,2,2,2,1,1, + 2,2,1,2,2,1,2,2,1,2, + 2,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,3,4,4,5, + 4,5,4,1,5,6,1,3,1,0, + 1,3,1,1,1,1,1,1,1,1, + 6,6,5,1,7,6,1,0,6,5, + 6,4,1,3,1,0,1,2,1,3, + 1,3,1,1,1,1,3,9,2,2, + 3,2,3,1,5,1,2,2,1,0, + 1,1,1,3,1,2,1,1,2,3, + 1,1,1,3,1,2,2,9,8,2, + 1,3,1,3,1,0,1,0,2,1, + 1,3,1,3,2,1,5,8,1,2, + 3,1,5,4,3,1,3,1,1,5, + 4,4,5,5,1,0,1,1,1,2, + 4,2,2,1,5,1,1,1,1,1, + 2,1,0,1,3,1,2,3,2,1, + 2,2,1,0,1,3,3,6,1,0, + 1,1,1,1,0,2,2,1,2,2, + 1,0,1,3,4,3,1,1,5,2, + 1,1,3,3,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 2,2,7,1,0,1,3,1,1,2, + 4,2,4,7,9,5,1,1,3,1, + 0,1,1,1,2,4,4,1,2,5, + 5,3,3,1,4,3,1,0,1,3, + 1,1,-63,0,0,0,0,-53,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-370,0,0,0, + 0,0,0,0,0,0,0,0,-259,0, + 0,-411,0,0,0,-148,0,0,0,0, + -54,0,0,0,0,0,0,0,-88,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-51,0,0,0,0,0,0,-117, + 0,0,0,-331,-65,0,0,0,0,-20, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-66,-73,0,0, + 0,0,0,0,0,0,0,0,0,0, + -177,0,0,0,0,0,0,-60,0,0, + 0,0,0,0,-116,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -417,0,0,0,-2,0,0,-4,-352,-147, + -74,0,0,0,0,0,0,0,0,0, + 0,0,0,-288,-395,0,0,0,-133,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-61,0,0,0,0,0, + 0,-195,0,0,0,0,0,0,0,0, + -50,0,0,-233,0,0,-512,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-58,0,-223,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -5,0,0,-124,0,0,0,0,0,0, + 0,-178,0,0,0,0,-234,0,0,0, + 0,-245,-6,0,0,0,0,0,-510,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-7,0,0,0,0,0,0,0, + 0,0,0,0,-8,0,0,0,0,0, + 0,-21,0,0,0,0,-9,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-416,0,0, + -520,0,0,0,0,-10,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-285,0,0,0,0,0, + 0,0,0,0,0,0,-432,0,0,-310, + 0,0,0,-151,0,0,0,0,0,0, + 0,0,0,0,0,0,-205,0,-12,-13, + -14,-3,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-57,0,0,0,0, + 0,0,0,-229,0,0,0,0,0,0, + 0,-16,0,0,-135,-146,0,0,0,0, + 0,0,0,0,0,0,-149,0,0,0, + 0,-29,0,0,-277,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-30,0,0,0, + 0,0,0,0,0,0,0,-131,-11,-312, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-44,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-313,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-184,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-306,0,0,0,-132,0,-473,0,0, + 0,0,-31,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-209,0,0,0,0,0,0,0,-453, + 0,0,0,-109,0,0,-115,0,0,0, + -40,0,0,0,0,-138,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-32,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-261, + 0,0,0,-42,0,0,0,0,-33,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-185,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-152,0,0,0,-96,0,0, + 0,0,-139,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-114,0,0,0,0,-143,0,0,0, + 0,0,0,-34,0,0,-333,-35,0,0, + -97,0,0,0,0,-36,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-215,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-201, + 0,0,0,-98,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-153,0,0,0,0,0,0,-37, + 0,0,-38,-39,0,0,-99,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -187,0,0,0,0,0,0,0,0,0, + 0,0,-210,0,0,-237,-41,0,0,-100, + 0,0,0,0,-493,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-55,0,0,-244,-56, + 0,0,-101,0,0,0,0,-59,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-189,0,0,0, + 0,0,0,0,0,0,0,0,-341,0, + 0,-251,-280,0,0,-102,0,0,0,0, + -67,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-192, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-252,-68,0,0,-103,0, + 0,0,0,-69,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-199,0,0, + 0,0,0,0,-71,0,0,-253,-72,0, + 0,-104,0,0,0,0,-110,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-144,0,0,0,0, + 0,0,0,0,0,0,0,-254,0,0, + 0,-264,0,0,-105,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -111,0,0,-361,-112,0,0,-106,0,0, + 0,0,-281,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-203,0,0,0,0,0,0,0,-113, + 0,0,0,-120,0,0,-324,-127,0,0, + -136,0,0,0,0,-128,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-208,0,0,0,0,0, + 0,0,0,0,0,0,-140,0,0,-154, + -129,-216,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-339,0,0,0,0,0,0, + 0,0,0,0,-17,0,0,0,0,0, + -286,0,0,-349,-505,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-45,0, + 0,0,0,0,0,0,0,0,0,0, + -155,0,0,0,-156,0,0,-309,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-227,0,0,0,0,0,0,0,0, + 0,0,0,-289,0,0,-323,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -145,0,0,0,0,0,0,0,-231,0, + 0,0,-157,0,0,-186,0,0,0,0, + -158,-347,-141,-214,0,0,0,0,0,0, + -159,-337,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-160,0,0,0,-161,0,0, + -358,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-228,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-162, + -232,0,0,-163,0,0,0,-248,0,0, + 0,0,-164,0,0,-359,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-165,0,0,-166,0,0, + 0,-167,0,0,-403,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-257,0, + 0,0,0,0,0,0,-168,0,0,0, + 0,0,0,-368,-169,0,0,-327,0,0, + 0,0,-295,-276,0,0,0,0,0,-108, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-272,0,0,0,-230,0,0,-95,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-301,0,0,0,0,0,0,0, + -170,0,0,-93,0,0,0,0,-308,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-171,0,-94,0,0, + 0,0,-172,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-298,0,0,0,0,-119,0,0,-52, + 0,0,0,0,0,0,-476,-351,0,0, + 0,0,0,0,0,0,0,0,-130,0, + 0,0,0,-366,0,0,-90,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-173,0,0,0,-300, + 0,0,0,0,0,0,0,-332,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-296,0,-174,-314,-175,-176,0,0,0, + 0,0,0,0,0,0,-19,0,0,0, + 0,-342,0,0,0,0,-386,0,0,0, + 0,-388,0,0,0,0,-405,0,0,0, + 0,0,0,0,-179,0,0,0,0,0, + -320,0,0,0,-377,0,-180,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-91,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-316,0,0,0,0, + -92,0,0,0,0,-181,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-396,0,0,0,0,-84, + 0,0,0,0,-190,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-191,0,0,0,-85,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-86,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-196, + 0,0,0,-87,0,0,0,0,-197,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-200,0,0, + 0,-239,0,0,0,0,0,0,0,0, + 0,0,0,0,-89,0,0,0,0,-448, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-315,0,0,0,0,-211,-49,-354,0, + 0,-267,0,-221,0,-222,-235,0,0,0, + 0,0,-481,0,0,0,0,-121,-367,0, + 0,0,-317,0,-378,-46,0,-224,-328,0, + 0,0,-268,0,-283,0,0,0,0,0, + 0,0,0,0,0,0,0,-238,0,0, + -240,0,0,0,0,0,0,0,0,0, + -504,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-360,0,-330,0,0, + 0,0,0,-142,0,0,0,0,0,-385, + 0,0,0,0,0,0,0,-182,0,0, + -357,0,-249,0,0,0,-48,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-262,0,-346,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-263, + 0,-343,0,-271,0,0,0,0,0,0, + 0,0,0,0,0,-273,-400,0,0,0, + 0,0,0,0,0,0,0,0,0,-79, + 0,0,0,0,-470,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-123,0,-80,0,0,0,0, + -274,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-278, + 0,-302,0,0,0,0,0,0,0,0, + 0,0,0,0,-424,0,0,0,0,0, + 0,0,0,0,0,0,0,-236,0,0, + 0,0,-502,-279,0,0,0,0,-456,-498, + 0,0,-353,0,-284,-334,-413,0,0,-125, + 0,0,-269,0,-242,0,0,0,0,0, + 0,0,0,-290,-414,0,0,0,0,0, + 0,0,0,0,0,0,0,-225,0,0, + -293,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-362,-75,0,0, + 0,0,0,-471,0,-294,0,0,0,0, + 0,0,-299,0,-325,0,0,0,0,-304, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-122,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-363, + 0,-305,0,0,0,0,0,0,0,0, + -321,-376,-62,0,0,0,0,0,-478,0, + -326,0,0,0,0,-437,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-419,0, + 0,0,0,0,0,-430,-348,0,0,0, + 0,0,0,0,0,0,0,0,0,-480, + 0,0,0,0,0,-336,0,-243,0,0, + 0,0,0,-338,0,-503,0,0,0,0, + 0,-380,-458,0,-383,-364,0,0,0,0, + 0,-47,0,0,0,0,0,-494,0,0, + 0,0,0,0,0,0,0,-442,0,0, + 0,0,0,0,0,0,-365,0,0,-371, + -373,-212,0,0,0,0,-415,0,0,0, + 0,0,0,0,0,0,-250,0,0,0, + 0,0,0,0,0,0,0,0,-375,0, + 0,0,0,0,0,-270,0,0,0,0, + -482,0,0,0,0,0,0,0,0,0, + -22,0,0,0,0,-381,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-382,-391,-394,-402,-81,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-82,0,0,0,0,-404,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-83,0,0,0,0, + -406,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-319, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-275,0,0,0,0,-393,0,0, + 0,0,0,0,0,0,0,0,0,0, + -421,-1,-384,-407,-369,0,0,0,-265,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-408,-118,-258,-443,0,0,0,0,0, + 0,0,-247,0,0,0,0,-420,-207,0, + 0,0,0,0,-410,0,0,0,0,0, + -418,0,0,-423,0,0,0,0,-401,0, + -297,0,0,0,0,-425,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-427,-452,0,-428,0, + -287,0,0,0,0,-422,-429,0,0,0, + 0,0,-431,-433,-426,0,-434,0,0,0, + 0,0,0,0,-446,0,0,0,0,0, + -450,0,-435,-440,0,0,0,-455,0,0, + 0,0,0,0,0,0,0,0,-23,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-445,0,0,0,0,0,-457,-459,-463, + 0,0,0,0,0,-454,-461,-24,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -25,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-26,0,0,0,0,-468,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-27,0,0,0, + 0,-487,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-28, + 0,0,0,0,-501,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-64,0,0,0,0,-506,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-77,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-78,0, + 0,0,0,-465,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-126,0,0,0,0,-485,0,0,0, + 0,0,-340,-467,0,0,-469,-497,0,0, + -483,-496,-255,0,0,0,0,0,-134,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-475,-484,0,-206,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -379,-202,-495,0,0,0,0,0,-15,0, + 0,0,-509,0,0,0,0,0,-489,0, + 0,-462,-499,-500,0,0,0,-508,0,0, + -511,0,0,-150,0,0,0,0,0,-514, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-392,0,0,0, + -246,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-516,0,0,0,0,0,-412, + 0,0,0,0,0,0,0,-466,0,0, + -517,-519,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-409,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-183,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-472,0,0,0,-436,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-311,0,0, + 0,0,0,0,-444,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-449,-350,-43,-318, + 0,0,0,0,0,0,-292,0,0,0, + -345,0,0,0,0,-188,0,0,0,0, + 0,0,0,0,-256,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-451,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-322, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-439,0,0,0,0, + 0,0,0,-390,0,0,0,0,0,0, + 0,0,0,-477,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-387,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-137,-486,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-194,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-488,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-492,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-513,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-398,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-518,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-399,0,-70,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-521,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-397, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-355,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-474,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-303,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-490,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-464,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -226,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-198,0,0, + 0,0,0,0,0,0,-356,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-193,0,0,0,0,0,-266,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-438,0, + 0,0,0,0,0,0,0,-282,0,0, + 0,0,0,0,0,0,-447,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-307,0,0,0,0,0,0,0, + 0,0,-76,-107,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-329, + 0,0,0,0,0,-335,0,0,0,0, + 0,0,0,0,-372,0,0,0,0,0, + -374,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-460, + 0,0,0,0,0,0,0,-479,0,0, + 0,0,0,0,-204,0,0,0,0,0, + 0,0,-213,0,0,0,0,0,0,0, + 0,0,-260,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-18,0,0,0,0,0, + 0,-241,-389,-441,-344,-217,0,0,0,0, + 0,-507,-515,0,0,0,0,0,0,-218, + 0,0,0,0,0,0,0,0,0,0, + -219,-220,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-291,0,0, + 0,0,0,0,0,0,-491,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0 + }; + }; + public final static short baseCheck[] = BaseCheck.baseCheck; + public final int baseCheck(int index) { return baseCheck[index]; } + public final static short rhs[] = baseCheck; + public final int rhs(int index) { return rhs[index]; }; + + public interface BaseAction { + public final static char baseAction[] = { + 173,5,137,81,81,36,36,66,66,40, + 40,194,194,195,195,196,196,1,1,16, + 16,16,16,16,16,16,16,17,17,17, + 15,11,11,9,9,9,9,9,2,67, + 67,6,6,12,12,12,12,48,48,138, + 138,139,62,62,46,46,18,18,18,18, + 18,18,18,18,18,18,18,18,18,18, + 18,18,18,18,18,140,140,140,19,19, + 19,19,19,19,19,19,19,19,19,19, + 20,20,177,174,174,175,175,178,142,142, + 179,179,176,176,143,141,141,21,21,22, + 22,23,23,23,25,25,25,25,26,26, + 26,27,27,27,28,28,28,28,28,30, + 30,30,31,31,33,33,34,34,35,35, + 37,37,38,38,42,42,41,41,41,41, + 41,41,41,41,41,41,41,41,41,39, + 39,29,144,144,104,104,107,107,99,197, + 197,72,72,72,72,72,72,72,72,72, + 73,73,73,74,74,57,57,180,180,75, + 75,75,118,118,76,76,76,76,77,77, + 77,77,77,78,82,82,82,82,82,82, + 82,52,52,52,52,52,109,109,110,110, + 50,24,24,24,24,24,47,47,94,94, + 94,94,94,151,151,146,146,146,146,146, + 147,147,147,148,148,148,149,149,149,150, + 150,150,95,95,95,95,95,96,96,96, + 88,13,14,14,14,14,14,14,14,14, + 14,14,14,83,83,83,122,122,122,122, + 122,120,120,120,89,121,121,153,153,152, + 152,124,124,125,44,44,43,87,87,90, + 90,92,93,91,45,54,49,154,154,55, + 53,86,86,155,155,145,145,126,126,80, + 80,156,156,64,64,64,59,59,58,65, + 65,70,70,56,56,56,97,97,106,105, + 105,61,61,60,60,63,63,51,108,108, + 108,100,100,100,101,102,102,102,103,103, + 111,111,111,113,113,112,112,198,198,98, + 98,182,182,182,182,182,128,68,68,158, + 181,181,129,129,129,129,183,183,32,32, + 119,130,130,130,130,114,114,123,123,123, + 160,161,161,161,161,161,161,161,161,161, + 186,186,184,184,185,185,162,162,162,162, + 163,187,116,115,115,188,188,164,164,132, + 132,131,131,131,199,199,10,189,189,190, + 165,157,157,166,166,167,168,168,7,7, + 8,170,170,170,170,170,170,170,170,170, + 170,170,170,170,170,170,170,170,170,170, + 170,170,170,170,170,170,170,170,170,170, + 170,170,170,170,170,170,170,170,170,170, + 170,170,170,69,71,71,171,171,133,133, + 134,134,134,134,134,134,3,4,172,172, + 169,169,135,135,135,84,85,79,159,159, + 117,117,191,191,191,136,136,127,127,192, + 192,173,173,1427,1818,1689,1685,1021,863,2834, + 34,1062,31,35,30,32,1857,261,29,27, + 56,1082,109,79,80,111,1117,3361,1285,1223, + 1384,1309,3433,1396,1388,273,1473,1470,1474,3223, + 1517,146,686,3238,162,147,2136,38,1020,36, + 1021,2911,4903,34,1062,31,35,65,32,3525, + 38,1020,36,1021,230,2477,34,1062,31,35, + 30,32,1019,261,29,27,56,1082,109,79, + 80,111,1117,2118,1285,2134,276,491,620,492, + 1029,275,274,186,3641,1563,4002,233,228,229, + 3484,38,1020,36,1021,390,2477,34,1062,31, + 35,30,32,1019,261,29,27,56,1082,89, + 79,80,240,243,246,249,3104,1167,1799,38, + 1020,36,1021,1814,3904,34,1062,31,35,63, + 32,686,38,507,2754,1021,336,861,2911,3453, + 2377,2768,2944,3020,3792,2445,38,1020,36,1021, + 2380,2477,34,1062,31,35,2517,32,1019,261, + 29,27,56,1082,109,79,80,111,1117,347, + 1285,1223,1384,1309,3819,1396,1388,2848,1473,1470, + 1474,2255,1517,146,1066,1220,512,147,1288,3641, + 2205,3292,38,1020,36,1021,3133,3904,34,1062, + 31,35,62,32,3436,1849,3519,3527,513,2445, + 38,1020,36,1021,2380,2477,34,1062,31,35, + 2517,32,1019,261,29,27,56,1082,109,79, + 80,111,1117,347,1285,1223,1384,1309,3545,1396, + 1388,3013,1473,1470,1474,2911,1517,146,3516,441, + 512,147,686,1818,1826,389,1021,3252,67,1716, + 3133,83,93,437,1284,293,685,2835,38,1020, + 36,1021,513,4903,34,1062,31,35,30,32, + 508,28,505,3277,273,2974,38,1020,36,1021, + 2380,2477,34,1062,31,35,2517,32,1019,261, + 29,27,56,1082,109,79,80,111,1117,347, + 1285,1223,1384,1309,2505,1396,1388,2566,1473,1470, + 1474,985,1517,146,2846,2614,512,147,47,2747, + 4672,66,686,38,2756,277,3133,686,38,283, + 275,274,2781,601,508,91,3435,105,513,2784, + 38,1020,36,1021,441,2477,34,1062,31,35, + 30,32,1019,261,29,27,56,1082,109,79, + 80,111,1117,1496,1285,1223,1384,1309,2679,1396, + 1388,2566,1473,1470,1474,1568,1517,146,287,2906, + 382,147,3525,38,1020,36,1021,1736,2477,34, + 1062,31,35,30,32,1019,261,29,27,56, + 1082,109,79,80,88,385,2272,2951,686,3592, + 509,2857,38,1020,36,1021,1788,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,111,1117,2301,1285,1223,1384,1309, + 2380,1396,1388,450,1473,1470,1474,3103,1517,146, + 686,293,382,147,2136,38,1020,36,1021,2702, + 4903,34,1062,31,35,64,32,2498,386,1547, + 2142,2442,3121,38,1020,36,1021,383,2477,34, + 1062,31,35,30,32,1019,261,29,27,56, + 1082,109,79,80,111,1117,83,1285,1223,1384, + 1309,749,1396,1388,1796,1473,1470,1474,1994,1517, + 146,3034,2854,162,147,1029,1877,38,1020,36, + 1021,4002,3971,34,1062,43,35,686,38,1826, + 389,1021,3101,364,1066,3121,38,1020,36,1021, + 387,2477,34,1062,31,35,30,32,1019,261, + 29,27,56,1082,109,79,80,111,1117,37, + 1285,1223,1384,1309,519,1396,1388,1056,1473,1470, + 1474,336,1517,146,288,2906,376,147,863,60, + 3121,38,1020,36,1021,2857,2477,34,1062,31, + 35,30,32,1019,261,29,27,56,1082,109, + 79,80,111,1117,83,1285,1223,1384,1309,2380, + 1396,1388,4638,1473,1470,1474,861,1517,146,391, + 423,376,147,3121,38,1020,36,1021,347,2477, + 34,1062,31,35,30,32,1019,261,29,27, + 56,1082,109,79,80,111,1117,83,1285,1223, + 1384,1309,3048,1396,1388,3133,1473,1470,1474,454, + 1517,146,2782,375,376,147,863,1697,3059,38, + 1020,36,1021,412,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 111,1117,2489,1285,1223,1384,1309,3931,1396,1388, + 1802,1473,1470,1474,2911,1517,146,2911,374,382, + 147,2930,38,1020,36,1021,1843,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,111,1117,158,1285,1223,1384,1309, + 74,1396,1388,59,1473,1470,1474,453,1517,146, + 944,372,145,147,3121,38,1020,36,1021,3106, + 2477,34,1062,31,35,30,32,1019,261,29, + 27,56,1082,109,79,80,111,1117,83,1285, + 1223,1384,1309,4621,1396,1388,356,1473,1470,1474, + 403,1517,146,1599,2911,163,147,380,3121,38, + 1020,36,1021,1551,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 111,1117,1624,1285,1223,1384,1309,863,1396,1388, + 58,1473,1470,1474,159,1517,146,3286,152,158, + 147,3121,38,1020,36,1021,592,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,111,1117,3301,1285,1223,1384,1309, + 96,1396,1388,357,1473,1470,1474,401,1517,146, + 2911,318,157,147,3121,38,1020,36,1021,671, + 2477,34,1062,31,35,30,32,1019,261,29, + 27,56,1082,109,79,80,111,1117,3848,1285, + 1223,1384,1309,863,1396,1388,354,1473,1470,1474, + 236,1517,146,424,510,156,147,3121,38,1020, + 36,1021,1066,2477,34,1062,31,35,30,32, + 1019,261,29,27,56,1082,109,79,80,111, + 1117,83,1285,1223,1384,1309,1054,1396,1388,872, + 1473,1470,1474,2911,1517,146,2911,1537,155,147, + 3121,38,1020,36,1021,3109,2477,34,1062,31, + 35,30,32,1019,261,29,27,56,1082,109, + 79,80,111,1117,57,1285,1223,1384,1309,92, + 1396,1388,2234,1473,1470,1474,1611,1517,146,2911, + 1755,154,147,3121,38,1020,36,1021,3119,2477, + 34,1062,31,35,30,32,1019,261,29,27, + 56,1082,109,79,80,111,1117,1200,1285,1223, + 1384,1309,2029,1396,1388,744,1473,1470,1474,1303, + 1517,146,2911,3612,153,147,3121,38,1020,36, + 1021,324,2477,34,1062,31,35,30,32,1019, + 261,29,27,56,1082,109,79,80,111,1117, + 83,1285,1223,1384,1309,804,1396,1388,73,1473, + 1470,1474,519,1517,146,2911,1486,152,147,3121, + 38,1020,36,1021,500,2477,34,1062,31,35, + 30,32,1019,261,29,27,56,1082,109,79, + 80,111,1117,329,1285,1223,1384,1309,863,1396, + 1388,72,1473,1470,1474,1489,1517,146,2911,1607, + 151,147,3121,38,1020,36,1021,171,2477,34, + 1062,31,35,30,32,1019,261,29,27,56, + 1082,109,79,80,111,1117,3326,1285,1223,1384, + 1309,2380,1396,1388,71,1473,1470,1474,2911,1517, + 146,2826,1757,150,147,3121,38,1020,36,1021, + 347,2477,34,1062,31,35,30,32,1019,261, + 29,27,56,1082,109,79,80,111,1117,331, + 1285,1223,1384,1309,70,1396,1388,1242,1473,1470, + 1474,699,1517,146,1640,787,149,147,3121,38, + 1020,36,1021,1609,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 111,1117,83,1285,1223,1384,1309,4962,1396,1388, + 2123,1473,1470,1474,1693,1517,146,863,969,148, + 147,3018,38,1020,36,1021,3278,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,111,1117,83,1285,1223,1384,1309, + 882,1396,1388,330,1473,1470,1474,3193,2698,168, + 246,60,3121,38,1020,36,1021,4289,2477,34, + 1062,31,35,30,32,1019,261,29,27,56, + 1082,109,79,80,111,1117,2440,1285,1223,1384, + 1309,1845,1396,1388,3744,1473,1470,1474,100,1517, + 146,359,332,143,147,1008,38,1568,46,1021, + 527,2911,45,1062,3318,3442,38,1020,36,1021, + 1678,2477,34,1062,31,35,30,32,1019,261, + 29,27,56,1082,109,79,80,111,1117,83, + 1285,1223,1384,1309,2380,1396,1388,2511,1473,1470, + 1474,334,1517,146,405,1694,193,147,3525,38, + 1020,36,1021,347,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 111,1117,83,1285,1223,1384,1309,2752,1396,1388, + 3133,1473,1470,1474,3436,2698,168,3525,38,1020, + 36,1021,1771,2477,34,1062,31,35,30,32, + 1019,261,29,27,56,1082,109,79,80,111, + 1117,83,1285,1223,1384,1309,1022,1396,1388,1796, + 1473,1470,1474,3105,2698,168,686,38,2115,1982, + 1021,3107,863,60,511,1818,1826,389,1021,4895, + 1513,2115,3525,38,1020,36,1021,292,2477,34, + 1062,31,35,30,32,1019,261,29,27,56, + 1082,109,79,80,111,1117,273,1285,1223,1384, + 1309,417,1396,1388,2833,1473,1470,1474,2838,2698, + 168,3525,38,1020,36,1021,2042,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,111,1117,3344,1285,1223,1384,1309, + 2783,1396,1388,101,1473,1470,1474,2853,2698,168, + 3170,83,275,274,1518,90,2894,105,686,1818, + 1826,389,1021,1876,392,423,3525,38,1020,36, + 1021,419,2477,34,1062,31,35,30,32,1019, + 261,29,27,56,1082,109,79,80,111,1117, + 273,1285,1223,1384,1309,680,1396,1388,3220,1473, + 1470,1474,3241,2698,168,3566,38,1020,36,1021, + 418,2477,34,1062,31,35,30,32,1019,261, + 29,27,56,1082,109,79,80,111,1117,83, + 1285,1223,1384,1309,3491,1396,1388,1136,1473,1470, + 1474,77,2698,168,3318,1549,275,274,1877,38, + 1020,36,1021,2911,83,34,1062,1914,35,4078, + 3525,38,1020,36,1021,421,2477,34,1062,31, + 35,30,32,1019,261,29,27,56,1082,109, + 79,80,111,1117,306,1285,1223,1384,1309,61, + 1396,1388,3223,1473,1470,2353,2851,38,281,3525, + 38,1020,36,1021,3553,2477,34,1062,31,35, + 30,32,1019,261,29,27,56,1082,109,79, + 80,111,1117,514,1285,1223,1384,1309,624,1396, + 1388,335,1473,2311,3525,38,1020,36,1021,3223, + 2477,34,1062,31,35,30,32,1019,261,29, + 27,56,1082,109,79,80,111,1117,285,1285, + 1223,1384,1309,3286,1396,1388,1662,2217,3525,38, + 1020,36,1021,852,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 111,1117,1167,1285,1223,1384,1309,940,1396,2225, + 3607,1818,1826,389,1021,286,2399,3223,1877,38, + 1020,36,1021,235,261,34,1062,2224,35,774, + 1646,1654,389,1021,1420,38,395,3525,38,1020, + 36,1021,273,2477,34,1062,31,35,30,32, + 1019,261,29,27,56,1082,109,79,80,111, + 1117,54,1285,1223,1384,1309,3339,2175,230,2228, + 60,230,294,55,295,1611,4810,2670,1046,38, + 1020,36,1021,303,4816,34,1062,31,35,343, + 32,792,2911,276,3349,83,3355,3357,275,274, + 4965,242,228,229,233,228,229,1751,1646,1654, + 389,1021,686,38,1826,389,1021,686,38,1826, + 389,1021,686,38,1826,389,1021,3318,60,240, + 243,246,249,3104,337,2492,324,1783,326,54, + 1814,83,322,1603,427,1640,4121,1148,3306,446, + 294,55,295,1611,428,657,3453,2377,2768,2944, + 3020,3792,3525,38,1020,36,1021,183,2477,34, + 1062,31,35,30,32,1019,261,29,27,56, + 1082,109,79,80,111,1117,3633,1285,1223,1384, + 2178,3525,38,1020,36,1021,1764,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,111,1117,3219,1285,1223,1384,2182, + 3525,38,1020,36,1021,3108,2477,34,1062,31, + 35,30,32,1019,261,29,27,56,1082,109, + 79,80,111,1117,2208,1285,1223,2051,3525,38, + 1020,36,1021,1066,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 111,1117,358,1285,1223,2084,3525,38,1020,36, + 1021,527,2477,34,1062,31,35,30,32,1019, + 261,29,27,56,1082,109,79,80,111,1117, + 3656,1285,1223,2088,3525,38,1020,36,1021,3116, + 2477,34,1062,31,35,30,32,1019,261,29, + 27,56,1082,109,79,80,111,1117,314,1285, + 1223,2130,1504,38,1020,36,1021,3015,4728,34, + 1062,31,35,343,32,3525,38,1020,36,1021, + 1640,2477,34,1062,31,35,30,32,1019,261, + 29,27,56,1082,109,79,80,111,1117,2440, + 1285,2143,686,1818,1826,389,1021,1268,2831,70, + 38,447,1796,1022,3359,4825,3432,2851,38,279, + 324,1783,326,686,1646,296,319,1603,1469,1420, + 38,395,355,2911,273,3742,83,164,862,83, + 2380,2380,3004,1796,4108,1911,38,1020,36,1021, + 4110,4728,34,1062,31,35,343,32,2021,2702, + 347,2849,348,1353,1266,353,294,3894,295,327, + 2970,2128,38,1020,36,1021,3015,4728,34,1062, + 31,35,343,32,3413,344,60,3133,83,230, + 275,274,4831,729,3187,1646,1654,389,1021,1775, + 598,38,447,324,1783,326,4825,328,2194,319, + 1603,3315,1257,1472,4002,355,527,686,1646,1654, + 389,1021,245,228,229,2773,54,394,423,324, + 1783,326,3636,499,2911,319,1603,294,55,295, + 1611,355,1017,3324,369,348,1353,1266,353,54, + 3678,522,83,1430,1284,293,792,1774,393,423, + 294,55,295,1611,337,1372,1668,1031,497,498, + 104,348,1353,1266,353,440,3250,3251,1066,523, + 3525,38,1020,36,1021,1031,2477,34,1062,31, + 35,30,32,1019,261,29,27,56,1082,109, + 79,80,111,1117,1488,1860,3525,38,1020,36, + 1021,3281,2477,34,1062,31,35,30,32,1019, + 261,29,27,56,1082,109,79,80,111,1117, + 3639,1951,1683,38,3196,36,1021,3016,4816,34, + 1062,31,35,343,32,1653,38,1020,36,1021, + 3016,4816,34,1062,31,35,343,32,686,38, + 507,278,1021,2255,3640,230,444,3250,3251,3763, + 686,1646,296,2255,2380,1029,1029,3318,287,2906, + 1841,4002,4002,3307,518,3323,38,279,336,4753, + 324,1783,326,226,3613,3318,319,1603,248,228, + 229,336,518,324,1783,326,2319,2951,986,319, + 1603,1006,1894,294,3901,295,3418,199,214,211, + 521,204,212,213,215,1250,997,2911,2831,2448, + 379,336,336,1022,3778,198,1867,205,206,2380, + 2890,230,2448,3644,1525,686,1818,1826,389,1021, + 3642,216,3521,207,208,209,210,164,226,297, + 298,299,300,3132,950,1646,2595,1587,1021,3454, + 4126,313,3400,4647,251,228,229,273,4214,2387, + 83,3418,3637,214,211,2515,204,212,213,215, + 3517,3643,83,1553,414,3204,54,4204,1065,3866, + 3606,2920,205,206,2380,2890,1223,294,55,295, + 1611,533,2036,333,339,1212,216,1387,207,208, + 209,210,872,226,297,298,299,300,75,2911, + 347,377,1344,275,274,159,60,686,1818,1826, + 389,1021,4880,4214,3228,192,3418,425,214,211, + 3881,204,212,213,215,2380,2855,4602,1352,38, + 507,278,1021,355,3681,445,2255,205,206,273, + 2890,3122,83,60,226,83,3578,4500,1501,4888, + 2907,216,83,207,208,209,210,2380,3223,297, + 298,299,300,348,1353,1266,353,3418,3318,214, + 211,346,204,212,213,215,347,3730,4214,3808, + 3704,3649,686,1646,1654,389,1021,83,205,206, + 76,2890,4085,520,3600,275,274,1352,38,507, + 3076,1021,216,3133,207,208,209,210,202,3737, + 297,298,299,300,54,1810,686,38,507,282, + 1021,1420,38,395,311,294,55,295,51,4214, + 3893,3525,38,1689,1685,1021,3745,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,87,3746,50,3747,3741,3525,38, + 1020,36,1021,37,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 111,1955,3525,38,1020,36,1021,3757,2477,34, + 1062,31,35,30,32,1019,261,29,27,56, + 1082,109,79,80,111,2033,3525,38,1020,36, + 1021,3749,2477,34,1062,31,35,30,32,1019, + 261,29,27,56,1082,109,79,80,111,2041, + 1629,38,1020,36,1021,3705,4816,34,1062,31, + 35,343,32,686,38,507,280,1021,1900,38, + 1020,36,1021,2985,4728,34,1062,31,35,343, + 32,83,2210,177,3755,2255,2720,1022,533,1000, + 38,1020,36,1021,2972,4728,34,1062,31,35, + 343,32,3818,3192,986,3318,337,226,324,1783, + 326,159,159,3617,320,1603,237,261,3638,83, + 355,531,2497,184,2380,3826,321,3090,326,402, + 3257,3761,214,211,3772,203,212,213,215,1, + 173,986,379,347,533,200,666,321,3090,326, + 350,1353,1266,353,525,187,171,172,174,175, + 176,177,178,226,230,3454,2349,3318,159,3777, + 3133,686,38,507,3131,1021,2302,2594,2497,184, + 3252,4107,1559,3610,3833,83,3257,89,214,211, + 3009,203,212,213,215,83,173,238,228,229, + 2925,83,3454,3803,1439,185,3074,220,2911,338, + 339,188,171,172,174,175,176,177,178,3525, + 38,1020,36,1021,2303,2477,34,1062,31,35, + 30,32,1019,261,29,27,56,1082,109,79, + 80,86,3788,3215,3845,2303,335,339,83,83, + 2911,49,2747,3139,3190,725,3787,3760,3525,38, + 1020,36,1021,3489,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 85,3525,38,1020,36,1021,4273,2477,34,1062, + 31,35,30,32,1019,261,29,27,56,1082, + 109,79,80,84,3525,38,1020,36,1021,3844, + 2477,34,1062,31,35,30,32,1019,261,29, + 27,56,1082,109,79,80,83,3525,38,1020, + 36,1021,3809,2477,34,1062,31,35,30,32, + 1019,261,29,27,56,1082,109,79,80,82, + 3525,38,1020,36,1021,3819,2477,34,1062,31, + 35,30,32,1019,261,29,27,56,1082,109, + 79,80,81,3391,38,1020,36,1021,1408,2477, + 34,1062,31,35,30,32,1019,261,29,27, + 56,1082,109,79,80,107,3525,38,1020,36, + 1021,5514,2477,34,1062,31,35,30,32,1019, + 261,29,27,56,1082,109,79,80,113,3525, + 38,1020,36,1021,2911,2477,34,1062,31,35, + 30,32,1019,261,29,27,56,1082,109,79, + 80,112,3668,1818,1826,389,1021,3736,2399,5514, + 5514,5514,2811,3307,3318,236,261,2911,3223,4753, + 4314,2911,83,2831,5514,5514,5514,889,1022,3525, + 38,1020,36,1021,273,2477,34,1062,31,35, + 30,32,1019,261,29,27,56,1082,109,79, + 80,110,164,4355,4586,3318,2911,3003,3525,38, + 1020,36,1021,230,2477,34,1062,31,35,30, + 32,1019,261,29,27,56,1082,109,79,80, + 108,3896,1663,2911,302,276,2380,2380,4002,3163, + 275,274,3206,2911,2380,310,234,228,229,3318, + 5514,5514,2348,3223,3318,226,2702,2380,3318,5514, + 5514,3318,5514,347,864,1646,1654,389,1021,381, + 2911,241,244,247,250,3104,347,2233,3418,3954, + 214,211,1814,204,212,213,215,3694,336,4972, + 613,1029,2380,5514,309,1212,54,4002,4973,205, + 206,305,2890,3797,5514,5514,4437,294,55,295, + 1611,226,1415,493,3318,207,208,209,210,301, + 1930,297,298,299,300,1022,2044,426,1977,4638, + 363,2127,2911,1022,3418,5514,214,211,5514,204, + 212,213,215,1516,2798,2801,265,4117,5514,159, + 5514,533,5514,5514,195,205,206,159,2890,3455, + 201,5514,686,1646,1654,389,1021,166,4478,515, + 226,207,208,209,210,159,5514,297,298,299, + 300,5514,5514,83,5514,2497,184,353,1022,5514, + 5514,5514,533,3257,54,214,211,384,203,212, + 213,215,5514,173,5514,294,55,295,1611,450, + 2778,226,3873,5514,5514,5514,159,5514,3554,171, + 172,174,175,176,177,178,2497,184,436,5514, + 5514,5514,5514,97,3257,3889,214,211,986,203, + 212,213,215,3846,173,3179,38,1020,36,1021, + 3016,4728,34,1062,31,35,343,32,5514,180, + 171,172,174,175,176,177,178,3965,3742,2257, + 1663,5514,2380,2380,1022,2380,4002,2826,5514,5514, + 5514,986,5514,4002,5514,5514,864,1646,1654,389, + 1021,226,2702,5514,2702,2831,5514,5514,159,3454, + 1022,5514,5514,324,1783,326,5514,5514,1254,319, + 1603,5514,5514,5514,3418,5514,214,211,54,204, + 212,213,215,3980,164,1250,336,5514,2380,294, + 55,295,1611,4117,52,205,206,5514,2890,5514, + 2831,5514,3454,2892,339,1022,5514,226,2276,312, + 5514,207,208,209,210,5514,1087,297,298,299, + 300,533,5514,5514,986,5514,499,3400,363,164, + 3418,313,214,211,3793,204,212,213,215,2380, + 226,1516,2798,2801,5514,159,3120,339,5514,5514, + 3517,205,206,5514,2890,166,5514,5514,226,2462, + 3606,496,498,3257,5514,516,3968,207,208,209, + 210,5514,2831,297,298,299,300,1022,5514,99, + 5514,3418,5514,214,211,3454,204,212,213,215, + 5514,5514,1470,441,5514,5514,5514,3872,533,3216, + 5514,164,205,206,2874,2890,5514,5514,5514,686, + 1646,1654,389,1021,5514,5514,217,226,207,208, + 209,210,159,3804,297,298,299,300,5514,3431, + 339,5514,2497,184,529,5514,5514,5514,5514,533, + 3257,54,214,211,5514,203,212,213,215,5514, + 173,5514,294,55,295,1611,5514,2757,226,5514, + 5514,5514,355,159,5514,191,171,172,174,175, + 176,177,178,2497,184,617,3169,5514,5514,5514, + 533,3257,5514,214,211,5514,203,212,213,215, + 5514,173,348,1353,1266,353,5514,5514,5514,226, + 1430,5514,5514,5514,159,5514,3728,171,172,174, + 175,176,177,178,2497,184,705,5514,5514,5514, + 5514,533,3257,5514,214,211,5514,203,212,213, + 215,5514,173,5514,5514,5514,83,5514,5514,5514, + 226,2380,5514,5514,5514,159,5514,194,171,172, + 174,175,176,177,178,2497,184,793,5514,5514, + 347,5514,533,3257,5514,214,211,5514,203,212, + 213,215,5514,173,5514,5514,5514,83,5514,2304, + 5514,226,2380,5514,1022,5514,159,3133,190,171, + 172,174,175,176,177,178,2497,184,881,503, + 5514,347,5514,533,3257,5514,214,211,159,203, + 212,213,215,5514,173,5514,5514,5514,785,5514, + 3804,5514,226,5514,5514,2380,5514,159,3133,197, + 171,172,174,175,176,177,178,2497,184,5514, + 501,5514,5514,5514,2702,3257,5514,214,211,5514, + 203,212,213,215,5514,173,1835,38,3196,36, + 1021,3016,4728,34,1062,31,35,343,32,5514, + 196,171,172,174,175,176,177,178,5514,1919, + 38,1020,36,1021,3016,4728,34,1062,31,35, + 343,32,1569,38,1020,36,1021,3016,4728,34, + 1062,31,35,343,32,5514,2024,5514,5514,5514, + 5514,1022,5514,5514,324,1783,326,5514,499,5514, + 319,1603,1569,38,1020,36,1021,3016,4728,34, + 1062,31,35,343,32,159,1894,324,1783,326, + 5514,1725,5514,319,1603,166,2380,4913,5514,5514, + 324,1783,326,496,498,5514,319,1603,1759,1250, + 5514,5514,5514,5514,4002,226,5514,1046,38,1020, + 36,1021,2773,4816,34,1062,31,35,343,32, + 324,1783,326,5514,5514,5514,319,1603,3439,5514, + 406,3533,774,1646,1654,389,1021,5514,1808,5514, + 5514,5514,3682,2380,4913,314,5514,5514,5514,1300, + 407,5514,2890,3898,337,5514,5514,5514,415,3204, + 5514,5514,226,337,54,324,1783,326,355,5514, + 5514,320,1603,5514,5514,294,55,295,1611,1291, + 52,5514,5514,5514,533,3439,5514,406,774,1646, + 1654,389,1021,5514,877,5514,5514,83,350,1353, + 1266,353,2380,347,5514,5514,1300,407,159,2890, + 5514,5514,2872,774,1646,1654,389,1021,192,5514, + 54,347,5514,2351,2398,5514,5514,5514,1022,1022, + 4602,294,55,295,1611,5514,2556,5514,5514,5514, + 5514,408,410,5514,5514,54,5514,5514,3133,5514, + 2742,5514,159,159,5514,5514,294,55,295,1611, + 530,52,1463,2346,5514,569,5514,4678,5514,2872, + 864,1646,1654,389,1021,2482,774,1646,1654,389, + 1021,5514,5514,5514,5514,774,1646,1654,389,1021, + 5514,774,1646,1654,389,1021,5514,3774,408,411, + 5514,5514,54,5514,5514,5514,5514,5514,54,5514, + 5514,5514,5514,294,55,295,1611,54,52,294, + 55,295,1611,54,2851,5514,5514,5514,294,55, + 295,1611,2388,52,294,55,295,1611,2742,52, + 2908,1646,1654,389,1021,5514,5514,2487,2915,1646, + 1654,389,1021,2492,5514,686,1646,1654,389,1021, + 5514,5514,5514,686,1646,1654,389,1021,5514,5514, + 5514,5514,54,686,1646,1654,389,1021,5514,5514, + 54,5514,5514,294,55,295,1611,54,52,5514, + 5514,294,55,295,1611,54,52,5514,294,55, + 295,1611,2763,3025,5514,54,294,55,295,1611, + 3010,657,5514,5514,5514,1155,294,55,295,1611, + 533,2372,2829,3717,1359,2829,2502,2380,2380,533, + 2380,1022,2071,2147,5514,5514,5514,1022,1022,347, + 2549,5514,5514,5514,159,1022,2702,347,347,2702, + 5514,2596,2643,159,785,159,1022,1022,5514,526, + 5514,159,159,192,5514,1602,3133,5514,2690,159, + 5514,166,166,1022,3133,4602,5514,2737,678,1645, + 159,159,1022,5514,5514,5514,529,5514,5514,5514, + 1688,1728,5514,5514,5514,5514,5514,159,5514,5514, + 5514,5514,5514,5514,5514,5514,159,1817,5514,5514, + 5514,5514,5514,5514,5514,5514,3883,5514,5514,5514, + 363,5514,5514,363,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,1911,2798,2801,3067,2798,2801,3910, + 3972,5514,3807,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,3468,5514,0,5532,42, + 0,5531,42,0,160,532,0,507,33,0, + 448,1046,0,5532,41,0,5531,41,0,2646, + 129,0,1,438,0,452,1128,0,451,1216, + 0,507,44,0,2021,94,0,38,304,0, + 388,296,0,36,389,0,33,388,0,507, + 33,388,0,1077,42,0,1,1129,0,1, + 5786,0,1,5785,0,1,5784,0,1,5783, + 0,1,5782,0,1,5781,0,1,5780,0, + 1,5779,0,1,5778,0,1,5777,0,1, + 5776,0,1,5532,42,0,1,5531,42,0, + 1,1905,0,5746,239,0,5745,239,0,5856, + 239,0,5855,239,0,5773,239,0,5772,239, + 0,5771,239,0,5770,239,0,5769,239,0, + 5768,239,0,5767,239,0,5766,239,0,5786, + 239,0,5785,239,0,5784,239,0,5783,239, + 0,5782,239,0,5781,239,0,5780,239,0, + 5779,239,0,5778,239,0,5777,239,0,5776, + 239,0,5532,42,239,0,5531,42,239,0, + 5555,239,0,38,284,260,0,507,388,0, + 5532,53,0,5531,53,0,2748,235,0,48, + 5553,0,48,40,0,2646,131,0,2646,130, + 0,30,514,0,5848,439,0,1197,439,0, + 1,5555,0,1,42,0,52,40,0,1, + 95,0,1,5555,227,0,1,42,227,0, + 227,413,0,5532,40,0,5531,40,0,5532, + 2,40,0,5531,2,40,0,5532,39,0, + 5531,39,0,5553,50,0,40,50,0,5524, + 404,0,5523,404,0,1,4572,0,1,3879, + 0,1,1077,0,227,412,0,2465,323,0, + 5848,98,0,1197,98,0,1,5848,0,1, + 1197,0,3813,280,0,1,2404,0,1,2769, + 0,5522,1,0,495,3927,0,1,227,0, + 1,227,3357,0,5524,227,0,5523,227,0, + 3537,227,0,160,179,0,296,3599,0,8, + 10,0,227,167,0,227,219,0,227,218, + 0,189,4396,0 + }; + }; + public final static char baseAction[] = BaseAction.baseAction; + public final int baseAction(int index) { return baseAction[index]; } + public final static char lhs[] = baseAction; + public final int lhs(int index) { return lhs[index]; }; + + public interface TermCheck { + public final static byte termCheck[] = {0, + 0,1,2,3,4,5,6,7,8,9, + 10,11,12,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,44,45,46,47,48,0, + 50,51,52,53,54,55,56,57,58,0, + 60,61,62,4,64,65,66,67,68,0, + 1,2,72,4,74,26,76,77,78,79, + 80,81,0,83,84,85,86,87,0,1, + 2,3,4,5,6,7,8,9,10,11, + 12,13,14,15,16,17,18,19,20,21, + 22,23,24,25,26,27,28,29,30,31, + 32,33,34,35,36,37,38,39,40,41, + 42,43,44,45,46,47,48,0,50,51, + 52,53,54,55,56,57,58,0,60,61, + 62,0,64,65,66,67,68,0,0,8, + 72,0,74,6,76,77,78,79,80,81, + 0,83,84,85,86,87,0,1,2,3, + 4,5,6,7,8,9,10,11,12,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 44,45,46,47,48,0,50,51,52,53, + 54,55,56,57,58,0,60,61,62,69, + 64,65,66,67,68,0,88,89,91,92, + 74,6,76,77,78,79,80,81,0,83, + 84,85,86,87,0,1,2,3,4,5, + 6,7,8,9,10,11,12,13,14,15, + 16,17,18,19,20,21,22,23,24,25, + 26,27,28,29,30,31,32,33,34,35, + 36,37,38,39,40,41,42,43,44,45, + 46,47,48,0,50,51,52,53,54,55, + 56,57,58,0,60,61,62,4,64,65, + 66,67,68,0,0,100,91,92,74,6, + 76,77,78,79,80,81,0,83,84,85, + 86,87,0,1,2,3,4,5,6,7, + 8,9,10,11,12,13,14,15,16,17, + 18,19,20,21,22,23,24,25,26,27, + 28,29,30,31,32,33,34,35,36,37, + 38,39,40,41,42,43,44,45,46,47, + 48,0,50,51,52,53,54,55,56,57, + 58,0,60,61,62,102,64,65,66,67, + 68,10,11,0,91,92,74,114,76,77, + 78,79,80,81,100,83,84,85,86,87, + 0,1,2,3,4,5,6,7,8,9, + 10,11,12,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,44,45,46,47,48,0, + 50,51,52,53,54,55,56,57,58,0, + 60,61,62,4,64,65,66,67,68,0, + 0,1,2,0,74,5,76,77,78,79, + 80,81,99,83,84,85,86,87,0,1, + 2,3,4,5,6,7,8,9,10,11, + 12,13,14,15,16,17,18,19,20,21, + 22,23,24,25,26,27,28,29,30,31, + 32,33,34,35,36,37,38,39,40,41, + 42,43,44,45,46,47,48,0,50,51, + 52,53,54,55,56,57,58,74,60,61, + 62,0,64,65,66,67,68,0,1,2, + 0,4,74,3,76,77,78,79,80,81, + 101,83,84,85,86,87,0,1,2,3, + 4,5,6,7,8,9,10,11,12,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 44,45,46,47,48,0,50,51,52,53, + 54,55,56,57,58,0,60,61,62,0, + 64,65,66,67,68,0,1,2,97,98, + 74,26,76,77,78,79,80,81,0,83, + 84,85,86,87,0,1,2,3,4,5, + 6,7,8,9,10,11,12,13,14,15, + 16,17,18,19,20,21,22,23,24,25, + 26,27,28,29,30,31,32,33,34,35, + 36,37,38,39,40,41,42,43,44,45, + 46,47,48,0,50,51,52,53,54,55, + 56,57,58,0,60,61,62,69,64,65, + 66,67,68,0,1,2,97,98,74,26, + 76,77,78,79,80,81,0,83,84,85, + 86,87,0,1,2,3,4,5,6,7, + 8,9,10,11,12,13,14,15,16,17, + 18,19,20,21,22,23,24,25,26,27, + 28,29,30,31,32,33,34,35,36,37, + 38,39,40,41,42,43,44,45,46,47, + 48,0,50,51,52,53,54,55,56,57, + 58,0,60,61,62,69,64,65,66,67, + 68,0,0,0,1,2,74,6,76,77, + 78,79,80,81,12,83,84,85,86,87, + 0,1,2,3,4,5,6,7,8,9, + 10,11,12,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,44,45,46,47,48,0, + 50,51,52,53,54,55,56,57,58,0, + 60,61,62,0,64,65,66,67,68,0, + 1,2,101,4,74,12,76,77,78,79, + 80,81,0,83,84,85,86,87,0,1, + 2,3,4,5,6,7,8,115,10,11, + 12,13,14,44,0,0,47,48,45,50, + 51,52,53,54,55,56,57,58,49,0, + 1,2,3,4,5,0,7,0,1,2, + 5,12,44,45,7,47,48,0,50,51, + 52,53,54,55,56,57,58,59,0,61, + 0,63,4,48,6,50,8,69,70,71, + 72,73,74,75,45,0,1,2,3,4, + 5,6,7,8,70,0,88,89,90,91, + 92,93,94,95,96,97,98,99,100,101, + 102,103,104,105,106,107,108,109,110,111, + 112,113,114,115,116,117,0,1,2,3, + 4,5,6,7,8,9,10,11,12,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 44,45,46,47,48,0,50,51,52,53, + 54,55,56,57,58,90,60,0,118,0, + 64,96,66,67,0,1,2,3,4,5, + 6,7,8,9,10,11,0,13,14,15, + 16,17,18,19,20,21,22,23,24,25, + 26,27,28,29,30,31,32,33,34,35, + 36,37,38,39,40,41,42,43,44,0, + 46,47,48,4,50,51,52,53,54,55, + 56,57,58,0,60,49,69,70,64,0, + 66,67,0,1,2,3,4,5,6,7, + 8,9,10,11,99,13,14,15,16,17, + 18,19,20,21,22,23,24,25,26,27, + 28,29,30,31,32,33,34,35,36,37, + 38,39,40,41,42,43,44,0,46,47, + 48,4,50,51,52,53,54,55,56,57, + 58,0,60,0,1,2,64,0,66,67, + 0,1,2,3,4,5,6,7,8,9, + 10,11,0,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,44,116,46,47,48,0, + 50,51,52,53,54,55,56,57,58,47, + 60,0,1,2,64,0,66,67,0,1, + 2,3,4,5,6,7,8,9,10,11, + 0,13,14,15,16,17,18,19,20,21, + 22,23,24,25,26,27,28,29,30,31, + 32,33,34,35,36,37,38,39,40,41, + 42,43,44,116,46,47,48,0,50,51, + 52,53,54,55,56,57,58,0,60,0, + 1,2,64,0,66,67,0,1,2,3, + 4,5,6,7,8,9,10,11,0,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,0,0, + 44,0,3,47,48,4,50,51,52,53, + 54,55,56,57,58,0,60,0,0,4, + 64,3,66,67,6,0,8,12,10,11, + 12,13,14,0,1,2,3,4,5,6, + 7,8,44,0,76,47,48,0,50,51, + 52,53,54,55,56,57,58,10,11,122, + 45,44,63,45,47,48,0,50,51,52, + 53,54,55,56,57,58,0,59,0,3, + 0,63,0,3,59,3,8,69,70,71, + 72,73,0,75,12,3,63,0,0,1, + 2,3,4,5,71,7,88,89,90,91, + 92,93,94,95,96,97,98,99,100,101, + 102,103,104,105,106,107,108,109,110,111, + 112,113,114,115,116,117,0,71,0,3, + 0,3,6,63,8,63,10,11,12,13, + 14,69,70,0,1,2,59,75,0,1, + 2,3,4,5,6,7,8,0,102,0, + 104,105,106,107,108,109,110,111,112,113, + 114,45,0,1,2,3,4,5,6,7, + 8,0,0,1,2,59,4,0,6,63, + 8,63,49,63,12,69,70,71,72,73, + 41,75,0,1,2,3,4,5,6,7, + 8,63,0,0,88,89,90,91,92,93, + 94,95,96,97,98,99,100,101,102,103, + 104,105,106,107,108,109,110,111,112,113, + 114,115,116,117,0,1,2,3,4,5, + 6,7,8,9,73,0,12,75,71,15, + 16,17,18,19,20,21,22,23,24,25, + 0,1,2,61,0,73,0,95,0,1, + 2,3,4,0,6,9,8,0,44,45, + 46,47,48,49,50,51,52,53,54,55, + 56,57,58,90,60,0,62,0,64,96, + 66,67,42,43,59,0,72,73,0,1, + 2,0,4,5,3,7,82,0,1,2, + 3,4,5,6,7,8,9,63,0,12, + 0,63,15,16,17,18,19,20,21,22, + 23,24,25,70,0,1,2,3,4,5, + 0,7,0,119,120,121,59,49,0,1, + 2,44,45,46,47,48,49,50,51,52, + 53,54,55,56,57,58,0,60,73,62, + 4,64,71,66,67,0,0,1,2,72, + 73,5,0,7,44,10,11,47,48,82, + 50,51,52,53,54,55,56,57,58,0, + 1,2,3,4,5,63,7,73,0,61, + 0,1,2,3,4,5,0,7,0,1, + 2,3,4,5,0,7,119,120,121,0, + 1,2,3,4,5,6,7,8,9,10, + 11,12,13,14,15,16,17,18,19,20, + 21,22,23,24,25,26,27,28,29,30, + 31,32,33,34,35,36,37,38,39,40, + 41,42,43,63,45,46,0,1,2,3, + 4,5,6,7,8,9,10,11,12,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 0,45,46,0,1,2,3,4,5,6, + 7,8,9,10,11,12,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,28,29,30,31,32,33,34,35,36, + 37,38,39,40,41,42,43,0,45,46, + 0,1,2,3,4,5,6,7,8,9, + 10,11,12,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,0,95,46,0,1,2, + 0,4,0,6,0,8,0,0,1,2, + 3,4,5,0,7,0,1,2,12,4, + 5,0,7,0,0,75,0,1,2,3, + 4,5,6,7,8,9,10,11,12,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 63,69,46,0,1,2,70,4,72,6, + 59,8,88,89,0,1,2,0,0,0, + 1,2,3,4,5,6,7,8,9,10, + 11,75,13,14,15,16,17,18,19,20, + 21,22,23,24,25,26,27,28,29,30, + 31,32,33,34,35,36,37,38,39,40, + 41,42,43,49,0,46,0,1,2,3, + 4,5,6,7,8,9,10,11,61,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 0,0,46,0,1,2,3,4,5,6, + 7,8,9,10,11,61,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,28,29,30,31,32,33,34,35,36, + 37,38,39,40,41,42,43,0,0,46, + 0,1,2,3,4,5,6,7,8,9, + 10,11,61,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,0,95,46,0,1,2, + 3,4,5,6,7,8,9,10,11,61, + 13,14,15,16,17,18,19,20,21,22, + 23,24,25,26,27,28,29,30,31,32, + 33,34,35,36,37,38,39,40,41,42, + 43,0,95,46,0,1,2,3,4,5, + 6,7,8,9,10,11,0,13,14,15, + 16,17,18,19,20,21,22,23,24,25, + 26,27,28,29,30,31,32,33,34,35, + 36,37,38,39,40,41,42,43,0,1, + 2,0,4,0,6,0,8,0,1,2, + 59,0,1,2,3,4,5,6,7,8, + 9,10,11,69,13,14,15,16,17,18, + 19,20,21,22,23,24,25,26,27,28, + 29,30,31,32,33,34,35,36,37,38, + 39,40,41,42,43,0,49,46,0,1, + 2,3,4,5,6,7,8,9,10,11, + 69,13,14,15,16,17,18,19,20,21, + 22,23,24,25,26,27,28,29,30,31, + 32,33,34,35,36,37,38,39,40,41, + 42,43,0,0,46,0,1,2,3,4, + 5,6,7,8,9,10,11,0,13,14, + 15,16,17,18,19,20,21,22,23,24, + 25,26,27,28,29,30,31,32,33,34, + 35,36,37,38,39,40,41,42,43,0, + 0,46,0,1,2,3,4,5,6,7, + 8,9,10,11,61,13,14,15,16,17, + 18,19,20,21,22,23,24,25,26,27, + 28,29,30,31,32,33,34,35,36,37, + 38,39,40,41,42,43,0,0,46,0, + 1,2,3,4,5,6,7,8,9,10, + 11,0,13,14,15,16,17,18,19,20, + 21,22,23,24,25,26,27,28,29,30, + 31,32,33,34,35,36,37,38,39,40, + 41,42,43,0,0,46,0,1,2,3, + 4,5,6,7,8,9,10,11,0,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 0,0,46,0,1,2,3,4,5,6, + 7,8,9,10,11,12,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,28,29,30,31,32,33,34,35,36, + 37,38,39,40,41,0,1,2,0,4, + 0,6,0,8,0,1,2,0,4,5, + 12,7,12,63,61,0,1,2,0,4, + 0,1,2,0,0,72,0,1,2,3, + 4,5,6,7,8,9,10,11,12,13, + 14,15,16,17,18,19,20,21,22,23, + 24,25,26,27,28,29,30,31,32,33, + 34,35,36,37,38,39,40,41,0,49, + 119,120,121,75,0,75,61,0,1,2, + 0,0,59,59,0,1,2,61,70,0, + 88,89,12,95,5,88,89,73,72,0, + 1,2,3,4,5,6,7,8,9,10, + 11,0,13,14,15,16,17,18,19,20, + 21,22,23,24,25,26,27,28,29,30, + 31,32,33,34,35,36,37,38,39,40, + 41,42,43,0,1,2,3,4,5,6, + 7,8,9,10,11,75,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,28,29,30,31,32,33,34,35,36, + 37,38,39,40,41,42,43,0,1,2, + 3,4,5,6,7,8,9,10,11,12, + 13,14,15,16,17,18,19,20,21,22, + 23,24,25,26,27,28,29,30,31,32, + 33,34,35,36,37,38,39,40,0,1, + 2,3,4,5,6,7,8,9,10,11, + 0,13,14,15,16,17,18,19,20,21, + 22,23,24,25,26,27,28,29,30,31, + 32,33,34,35,36,37,38,39,40,41, + 0,0,0,3,0,0,0,0,0,0, + 0,4,0,13,14,0,4,0,0,61, + 0,1,2,3,4,5,6,7,8,9, + 10,11,115,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,41,0,63,59,3,59,5,6,0, + 8,59,10,11,69,13,14,59,0,1, + 2,3,4,5,69,7,0,1,2,27, + 12,0,0,0,90,3,90,0,93,94, + 96,0,96,103,42,43,15,16,17,18, + 19,20,21,22,23,24,25,117,0,0, + 118,59,0,45,0,63,118,9,42,43, + 0,69,70,71,12,44,0,0,47,48, + 0,50,51,52,53,54,55,56,57,58, + 88,89,90,91,92,93,94,88,89,97, + 98,99,100,101,102,103,104,105,106,107, + 108,109,110,111,112,113,0,0,59,3, + 0,5,6,65,8,0,10,11,69,13, + 14,0,1,2,72,4,5,12,7,59, + 0,1,2,27,0,5,0,1,2,69, + 4,0,93,94,0,1,2,0,42,43, + 6,0,0,1,2,0,0,0,3,12, + 45,0,0,93,94,59,59,0,0,63, + 49,3,0,0,0,69,70,71,0,49, + 70,3,0,47,0,70,0,3,0,3, + 0,3,45,49,88,89,90,91,92,93, + 94,49,12,97,98,99,100,101,102,103, + 104,105,106,107,108,109,110,111,112,113, + 0,1,2,3,4,5,6,7,8,9, + 10,11,59,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,28,29, + 30,31,32,33,34,35,36,37,38,39, + 40,0,72,0,3,0,0,0,3,0, + 4,0,1,2,3,4,5,6,7,8, + 9,10,11,63,13,14,15,16,17,18, + 19,20,21,22,23,24,25,26,27,28, + 29,30,31,32,33,34,35,36,37,38, + 39,40,41,0,1,2,3,4,5,6, + 7,8,9,10,11,59,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,28,29,30,31,32,33,34,35,36, + 37,38,39,40,0,1,2,3,4,5, + 6,7,8,9,10,11,0,13,14,15, + 16,17,18,19,20,21,22,23,24,25, + 26,27,28,29,30,31,32,33,34,35, + 36,37,38,39,40,0,1,2,3,4, + 5,6,7,8,9,10,11,0,13,14, + 15,16,17,18,19,20,21,22,23,24, + 25,26,27,28,29,30,31,32,33,34, + 35,36,37,38,39,40,0,1,2,0, + 4,0,0,0,0,9,0,1,2,0, + 0,15,16,17,18,19,20,21,22,23, + 24,25,0,1,2,0,0,0,0,0, + 0,0,0,0,3,3,69,70,0,12, + 44,3,0,47,48,0,50,51,52,53, + 54,55,56,57,58,49,60,0,1,2, + 64,4,66,67,63,63,9,0,69,70, + 0,49,15,16,17,18,19,20,21,22, + 23,24,25,0,1,2,3,4,5,6, + 7,8,59,0,49,12,70,70,73,71, + 71,44,75,73,47,48,0,50,51,52, + 53,54,55,56,57,58,49,60,12,0, + 0,64,0,66,67,0,0,44,45,3, + 0,0,49,0,0,0,0,12,0,3, + 9,3,59,73,0,62,0,3,65,0, + 0,68,0,1,2,3,4,5,6,7, + 8,0,12,70,12,82,0,0,1,2, + 3,4,5,6,7,8,0,0,59,12, + 49,75,0,1,2,3,4,5,6,7, + 8,60,0,0,12,45,44,45,0,0, + 75,49,9,73,71,71,71,0,0,60, + 3,44,45,0,62,0,49,65,3,73, + 68,0,0,0,72,3,44,45,0,62, + 69,49,65,0,82,68,3,71,0,72, + 0,0,49,0,62,0,70,65,71,82, + 68,0,0,60,72,0,1,2,3,4, + 5,6,7,8,82,73,0,12,0,71, + 0,1,2,3,4,5,6,7,8,71, + 59,0,12,0,0,0,1,2,3,4, + 5,6,7,8,0,0,0,12,0,44, + 45,0,0,0,49,0,0,0,0,0, + 0,0,0,0,44,45,0,62,0,49, + 65,0,0,68,0,0,0,72,0,44, + 45,0,62,0,49,65,0,82,68,0, + 0,0,72,0,0,0,0,62,0,0, + 65,0,82,68,0,1,2,3,4,5, + 6,7,8,0,0,0,12,82,0,0, + 1,2,3,4,5,6,7,8,0,0, + 0,12,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,44,45, + 0,0,0,49,0,0,0,0,0,0, + 0,0,0,44,45,0,62,0,49,65, + 0,0,68,0,0,0,0,0,0,0, + 0,62,0,0,65,0,82,68,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,82,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0 + }; + }; + public final static byte termCheck[] = TermCheck.termCheck; + public final int termCheck(int index) { return termCheck[index]; } + + public interface TermAction { + public final static char termAction[] = {0, + 5514,5480,5477,5477,5477,5477,5477,5477,5477,1, + 1,1,5490,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,5487,3481,1,1,5514, + 1,1,1,1,1,1,1,1,1,42, + 1,557,2585,5555,1,958,1,1,3326,5514, + 5161,5158,5521,5555,721,3526,3475,3035,2185,3017, + 3327,3986,1,3452,572,3434,3960,3381,8,5499, + 5499,5499,5499,5499,5499,5499,5499,5499,5499,5499, + 5499,5499,5499,5499,5499,5499,5499,5499,5499,5499, + 5499,5499,5499,5499,5499,5499,5499,5499,5499,5499, + 5499,5499,5499,5499,5499,5499,5499,5499,5499,5499, + 5499,5499,5499,5499,5499,5499,5499,5514,5499,5499, + 5499,5499,5499,5499,5499,5499,5499,5514,5499,5499, + 5499,134,5499,5499,5499,5499,5499,118,124,2407, + 5499,5514,5499,3376,5499,5499,5499,5499,5499,5499, + 5514,5499,5499,5499,5499,5499,5514,5480,5477,5477, + 5477,5477,5477,5477,5477,1,1,1,5484,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,5487,3481,1,1,5514,1,1,1,1, + 1,1,1,1,1,138,1,557,2585,2436, + 1,958,1,1,3326,120,589,2715,3352,3328, + 721,3376,3475,3035,2185,3017,3327,3986,5514,3452, + 572,3434,3960,3381,5514,5480,5477,5477,5477,5477, + 5477,5477,5477,1,1,1,5484,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,5487, + 3481,1,1,142,1,1,1,1,1,1, + 1,1,1,5514,1,557,2585,730,1,958, + 1,1,3326,119,139,2314,3352,3328,721,3376, + 3475,3035,2185,3017,3327,3986,5514,3452,572,3434, + 3960,3381,5514,5480,5477,5477,5477,5477,5477,5477, + 5477,1,1,1,5484,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,5487,3481,1, + 1,5514,1,1,1,1,1,1,1,1, + 1,121,1,557,2585,2240,1,958,1,1, + 3326,2946,2920,136,3352,3328,721,4764,3475,3035, + 2185,3017,3327,3986,2314,3452,572,3434,3960,3381, + 5514,5480,5477,5477,5477,5477,5477,5477,5477,1, + 1,1,5484,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,5487,3481,1,1,5514, + 1,1,1,1,1,1,1,1,1,507, + 1,557,2585,5200,1,958,1,1,3326,140, + 5514,5531,5532,1,721,2138,3475,3035,2185,3017, + 3327,3986,2348,3452,572,3434,3960,3381,5514,5480, + 5477,5477,5477,5477,5477,5477,5477,1,1,1, + 5484,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,5487,3481,1,1,5514,1,1, + 1,1,1,1,1,1,1,2828,1,557, + 2585,132,1,958,1,1,3326,5514,5161,5158, + 5514,5555,721,4109,3475,3035,2185,3017,3327,3986, + 2279,3452,572,3434,3960,3381,5514,5480,5477,5477, + 5477,5477,5477,5477,5477,1,1,1,5484,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,5487,3481,1,1,5514,1,1,1,1, + 1,1,1,1,1,5514,1,557,2585,133, + 1,958,1,1,3326,5514,5531,5532,2561,2532, + 721,3558,3475,3035,2185,3017,3327,3986,5514,3452, + 572,3434,3960,3381,5514,5480,5477,5477,5477,5477, + 5477,5477,5477,1,1,1,5484,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,5487, + 3481,1,1,1,1,1,1,1,1,1, + 1,1,1,5514,1,557,2585,2464,1,958, + 1,1,3326,5514,5353,5350,2561,2532,721,3325, + 3475,3035,2185,3017,3327,3986,5514,3452,572,3434, + 3960,3381,5514,5480,5477,5477,5477,5477,5477,5477, + 5477,1,1,1,5484,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,5487,3481,1, + 1,5514,1,1,1,1,1,1,1,1, + 1,141,1,557,2585,2466,1,958,1,1, + 3326,5514,5514,53,5353,5350,721,2209,3475,3035, + 2185,3017,3327,3986,5518,3452,572,3434,3960,3381, + 5514,3357,1,1,1,1,1,1,1,1, + 1,1,5524,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,5523,3481,1,1,5514, + 1,1,1,1,1,1,1,1,1,222, + 1,557,2585,404,1,958,1,1,3326,396, + 5161,5158,2279,5555,721,5429,3475,3035,2185,3017, + 3327,3986,5514,3452,572,3434,3960,3381,5514,5343, + 5343,5343,5343,5343,5343,5343,5343,5517,5343,5343, + 5343,5343,5343,5769,161,340,5772,5855,5432,5856, + 5766,5773,5745,5771,5770,5767,5768,5746,42,1, + 5256,5252,5435,5260,5441,5514,5438,41,5176,5173, + 3085,5524,5343,5343,823,5343,5343,5514,5343,5343, + 5343,5343,5343,5343,5343,5343,5343,5343,42,5343, + 5514,5343,5555,5855,1197,5856,5848,5343,5343,5343, + 5343,5343,5343,5343,5523,5514,5161,5158,4572,1905, + 1077,1197,3879,5848,1304,114,5343,5343,5343,5343, + 5343,5343,5343,5343,5343,5343,5343,5343,5343,5343, + 5343,5343,5343,5343,5343,5343,5343,5343,5343,5343, + 5343,5343,5343,5343,5343,5343,5514,5477,5477,5477, + 5477,5477,5477,5477,5477,1,1,1,5502,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,5502,5674,1,1,137,1,1,1,1, + 1,1,1,1,1,3746,1,30,3534,5514, + 1,3769,1,1,5514,1,1,1,1,1, + 1,1,1,1,1,1,40,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 5674,1,1,389,1,1,1,1,1,1, + 1,1,1,5514,1,5553,5371,5371,1,5514, + 1,1,5514,1,1,1,1,1,1,1, + 1,1,1,1,2348,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,5514,5674,1, + 1,3463,1,1,1,1,1,1,1,1, + 1,5514,1,290,5531,5532,1,5514,1,1, + 5514,1,1,1,1,1,1,1,1,1, + 1,1,430,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,5157,5674,1,1,5514, + 1,1,1,1,1,1,1,1,1,5943, + 1,39,5420,5417,1,5514,1,1,5514,1, + 1,1,1,1,1,1,1,1,1,1, + 5514,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,5164,5674,1,1,189,1,1, + 1,1,1,1,1,1,1,5514,1,396, + 5531,5532,1,5514,1,1,42,5161,5158,4955, + 1905,3301,3631,3879,3654,2043,3608,3569,5514,3700, + 3677,5778,5776,5785,5784,5780,5781,5779,5782,5783, + 5786,5777,5537,932,913,966,5539,925,630,937, + 5540,5538,883,5533,5535,5536,5534,1261,223,1, + 5769,5514,4272,5772,5855,3051,5856,5766,5773,5745, + 5771,5770,5767,5768,5746,38,5911,224,389,5197, + 864,5203,5912,5913,5203,5514,5203,5197,5203,5203, + 5203,5203,5203,370,5256,5252,2785,5260,1077,1, + 3879,1,5769,5514,3659,5772,5855,123,5856,5766, + 5773,5745,5771,5770,5767,5768,5746,2946,2920,5511, + 5197,5769,1821,5203,5772,5855,142,5856,5766,5773, + 5745,5771,5770,5767,5768,5746,5514,5203,135,2748, + 351,5203,1,1802,1154,4272,2407,5203,5203,5203, + 5203,5203,94,5203,345,5194,1821,5514,1,5256, + 5252,4572,5260,1077,1085,3879,5203,5203,5203,5203, + 5203,5203,5203,5203,5203,5203,5203,5203,5203,5203, + 5203,5203,5203,5203,5203,5203,5203,5203,5203,5203, + 5203,5203,5203,5203,5203,5203,388,1778,323,5206, + 452,5447,5206,1821,5206,1821,5206,5206,5206,5206, + 5206,345,345,5514,9878,9878,1939,345,349,5161, + 5158,2785,1905,1077,1197,3879,5848,5514,2240,528, + 1735,1692,1649,1606,1563,1520,1477,1434,1391,1348, + 4764,5206,316,5256,5252,4572,5260,1077,5459,3879, + 5456,5514,1,5383,5383,5209,5380,291,1197,5206, + 5848,1821,5553,5185,366,5206,5206,5206,5206,5206, + 3279,5206,5514,5256,5252,4572,5260,1077,5459,3879, + 5456,1821,5514,117,5206,5206,5206,5206,5206,5206, + 5206,5206,5206,5206,5206,5206,5206,5206,5206,5206, + 5206,5206,5206,5206,5206,5206,5206,5206,5206,5206, + 5206,5206,5206,5206,5514,5396,5396,227,5392,227, + 227,227,227,1,1862,5514,5400,366,1958,1, + 1,1,1,1,1,1,1,1,1,1, + 5514,5531,5532,1328,451,2052,308,366,349,42, + 42,4272,5555,510,1197,5821,5848,5514,1,227, + 5923,1,1,495,1,1,1,1,1,1, + 1,1,1,3746,1,5514,1732,5514,1,3769, + 1,1,3723,625,2776,424,413,227,5514,5161, + 5158,317,1905,5213,4023,3879,6008,5514,5396,5396, + 227,5392,227,227,227,227,1,5188,5514,5444, + 5514,1821,1,1,1,1,1,1,1,1, + 1,1,1,825,1,5256,5252,4572,5260,1077, + 225,3879,352,5945,5946,5947,3222,576,5514,5531, + 5532,1,227,5923,1,1,495,1,1,1, + 1,1,1,1,1,1,5514,1,3023,1732, + 3141,1,1218,1,1,122,5514,5531,5532,412, + 227,1077,5514,3879,5769,2946,2920,5772,5855,6008, + 5856,5766,5773,5745,5771,5770,5767,5768,5746,1, + 5256,5252,5435,5260,5441,1821,5438,2052,5514,3535, + 1,5256,5252,2785,5260,1077,5514,3879,1,5256, + 5252,4572,5260,1077,5514,3879,5945,5946,5947,5514, + 1,1,1,1,1,1,1,1,1,1, + 1,5524,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1821,5523,5674,5514,1,1,1, + 1,1,1,1,1,1,1,1,167,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 361,167,5674,5514,1,1,1,1,1,1, + 1,1,1,1,1,167,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,5514,167,5674, + 5514,1,1,1,1,1,1,1,1,1, + 1,1,167,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,128,5874,5674,438,1,1, + 5514,1,5514,5182,5514,5182,5514,1,5256,5252, + 2785,5260,1077,5514,3879,5514,5161,5158,5522,1905, + 1077,33,3879,5514,5514,167,5514,1,1,1, + 1,1,1,1,1,1,1,1,167,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1821,2467,5674,439,42,42,961,5555,5521,5377, + 5167,5374,589,2715,48,5362,5362,5514,5514,5514, + 1,1,1,1,1,1,1,1,1,1, + 1,167,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,5359,5514,728,5514,1,1,1, + 1,1,1,1,1,1,1,1,2131,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,5674,5514,1,1,1,1,1,1, + 1,1,1,1,1,557,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,5514,5674, + 5514,1,1,1,1,1,1,1,1,1, + 1,1,3551,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,5514,5876,5674,5514,1,1, + 1,1,1,1,1,1,1,1,1,3598, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,5514,3811,5674,1,5256,5252,4955,5260,3301, + 3631,3879,3654,5216,3608,3569,5514,3700,3677,5243, + 5249,5222,5225,5237,5234,5240,5231,5228,5219,5246, + 5537,932,913,966,5539,925,630,937,5540,5538, + 883,5533,5535,5536,5534,1261,42,42,95,1, + 1,5514,1,5514,5389,5514,5389,40,5386,5386, + 801,5514,1,1,1,1,1,1,1,1, + 1,1,1,511,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,5514,3198,5674,5514,1, + 1,1,1,1,1,1,1,1,1,1, + 6020,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,5514,5514,5674,5514,1,1,1,1, + 1,1,1,1,1,1,1,5514,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,5514, + 5514,5674,5514,1,1,1,1,1,1,1, + 1,1,1,1,5496,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,5514,5514,5674,5514, + 1,1,1,1,1,1,1,1,1,1, + 1,5514,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,5514,5514,5674,5514,1,1,1, + 1,1,1,1,1,1,1,1,5514,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 103,5514,5674,42,5161,5158,4955,1905,3301,3631, + 3879,3654,1129,3608,3569,5522,3700,3677,5778,5776, + 5785,5784,5780,5781,5779,5782,5783,5786,5777,5537, + 932,913,966,5539,925,630,937,5540,5538,883, + 5533,5535,5536,5534,1261,98,42,42,1,5555, + 1,5453,127,5450,5514,5161,5158,126,1905,1077, + 366,3879,165,5008,3812,5514,5161,5158,365,5555, + 5514,5406,5403,448,33,5521,42,5161,5158,4955, + 1905,3301,3631,3879,3654,1129,3608,3569,5522,3700, + 3677,5778,5776,5785,5784,5780,5781,5779,5782,5783, + 5786,5777,5537,932,913,966,5539,925,630,937, + 5540,5538,883,5533,5535,5536,5534,1261,5514,5553, + 5945,5946,5947,366,5514,165,1630,5514,9483,9159, + 5514,5514,5170,507,5514,9483,9159,3812,985,5514, + 589,2715,5520,366,3177,589,2715,420,5521,144, + 5161,5158,4955,1905,3301,3631,3879,3654,1129,3608, + 3569,5514,3700,3677,5778,5776,5785,5784,5780,5781, + 5779,5782,5783,5786,5777,5537,932,913,966,5539, + 925,630,937,5540,5538,883,5533,5535,5536,5534, + 1261,42,42,1,5256,5252,4955,5260,3301,3631, + 3879,3654,5216,3608,3569,5519,3700,3677,5243,5249, + 5222,5225,5237,5234,5240,5231,5228,5219,5246,5537, + 932,913,966,5539,925,630,937,5540,5538,883, + 5533,5535,5536,5534,1261,42,42,42,5161,5158, + 4955,1905,3301,3631,3879,3654,1129,3608,3569,5518, + 3700,3677,5778,5776,5785,5784,5780,5781,5779,5782, + 5783,5786,5777,5537,932,913,966,5539,925,630, + 937,5540,5538,883,5533,5535,5536,5534,42,5161, + 5158,4955,1905,3301,3631,3879,3654,1129,3608,3569, + 5514,3700,3677,5778,5776,5785,5784,5780,5781,5779, + 5782,5783,5786,5777,5537,932,913,966,5539,925, + 630,937,5540,5538,883,5533,5535,5536,5534,1261, + 78,5514,378,3068,116,129,115,395,517,5514, + 5514,5200,53,5582,5583,5514,5532,5514,44,3812, + 42,5161,5158,4955,1905,3301,3631,3879,3654,1129, + 3608,3569,5517,3700,3677,5778,5776,5785,5784,5780, + 5781,5779,5782,5783,5786,5777,5537,932,913,966, + 5539,925,630,937,5540,5538,883,5533,5535,5536, + 5534,1261,1,4763,2674,581,507,5977,5971,125, + 5975,5532,5969,5970,5179,6000,6001,5191,1,5256, + 5252,4572,5260,1077,5963,3879,5514,5353,5350,5978, + 316,221,235,5514,3746,5356,3746,5514,2618,2590, + 3769,5514,3769,658,1556,1560,5778,5776,5785,5784, + 5780,5781,5779,5782,5783,5786,5777,731,308,131, + 3534,5980,5514,316,5514,538,3534,5821,3723,625, + 5514,5981,6002,5979,5522,5769,5514,5514,5772,5855, + 130,5856,5766,5773,5745,5771,5770,5767,5768,5746, + 5991,5990,6003,5972,5973,5996,5997,589,2715,5994, + 5995,5974,5976,5998,5999,6004,5984,5985,5986,5982, + 5983,5992,5993,5988,5987,5989,5514,388,2674,581, + 289,5977,5971,3176,5975,5514,5969,5970,5365,6000, + 6001,5514,5161,5158,5521,1905,5213,5524,3879,2674, + 40,5386,5386,5978,5514,5386,430,42,42,5368, + 5555,5514,2618,2590,40,5386,5386,5514,1556,1560, + 2209,5514,5514,5413,5409,1,5514,5514,3469,5524, + 5523,5514,5514,2618,2590,5980,5347,5514,5514,538, + 1004,4966,5514,1,5514,5981,6002,5979,5514,3267, + 1000,4980,5514,5943,5514,4536,5514,4991,5514,4992, + 1,3813,5523,5553,5991,5990,6003,5972,5973,5996, + 5997,5553,5471,5994,5995,5974,5976,5998,5999,6004, + 5984,5985,5986,5982,5983,5992,5993,5988,5987,5989, + 42,5161,5158,4955,1905,3301,3631,3879,3654,1129, + 3608,3569,507,3700,3677,5778,5776,5785,5784,5780, + 5781,5779,5782,5783,5786,5777,5537,932,913,966, + 5539,925,630,937,5540,5538,883,5533,5535,5536, + 5534,5514,5521,5514,4135,106,53,5514,4180,5514, + 5531,42,5161,5158,4955,1905,3301,3631,3879,3654, + 1129,3608,3569,1377,3700,3677,5778,5776,5785,5784, + 5780,5781,5779,5782,5783,5786,5777,5537,932,913, + 966,5539,925,630,937,5540,5538,883,5533,5535, + 5536,5534,1261,42,5161,5158,4459,1905,3301,3631, + 3879,3654,1129,3608,3569,5531,3700,3677,5778,5776, + 5785,5784,5780,5781,5779,5782,5783,5786,5777,5537, + 932,913,966,5539,925,630,937,5540,5538,883, + 5533,5535,5536,5534,42,5161,5158,4955,1905,3301, + 3631,3879,3654,1129,3608,3569,5514,3700,3677,5778, + 5776,5785,5784,5780,5781,5779,5782,5783,5786,5777, + 5537,932,913,966,5539,925,630,937,5540,5538, + 883,5533,5535,5536,5534,42,5161,5158,4955,1905, + 3301,3631,3879,3654,1129,3608,3569,5514,3700,3677, + 5778,5776,5785,5784,5780,5781,5779,5782,5783,5786, + 5777,5537,932,913,966,5539,925,630,937,5540, + 5538,883,5533,5535,5536,5534,5514,5161,5158,5514, + 5555,325,102,5514,5514,1861,50,5426,5426,5514, + 5514,5778,5776,5785,5784,5780,5781,5779,5782,5783, + 5786,5777,40,5386,5386,5514,422,5514,373,371, + 442,5514,280,5514,2465,5462,3871,2775,5514,5520, + 5769,4252,5514,5772,5855,52,5856,5766,5773,5745, + 5771,5770,5767,5768,5746,5423,5911,239,5336,5332, + 864,5340,5912,5913,1821,1997,1861,5514,3607,2775, + 5514,5553,5323,5329,5302,5305,5317,5314,5320,5311, + 5308,5299,5326,1,5477,5477,227,5477,227,227, + 227,227,2779,443,2998,227,3803,4737,5914,1130, + 1173,5287,5519,2749,5278,5272,1,5269,5296,5275, + 5266,5281,5284,5293,5290,5263,3083,5911,5520,5514, + 5514,864,5514,5912,5913,1,5514,6800,227,4963, + 5514,1,5474,416,502,500,5514,524,5514,3496, + 5465,3146,3484,2091,5514,2585,5514,4719,745,5514, + 179,3326,1,5477,5477,227,5477,227,227,227, + 227,5514,5493,2840,5505,6008,38,1,5477,5477, + 227,5477,227,227,227,227,315,5514,3212,5505, + 3247,5519,1,5477,5477,227,5477,227,227,227, + 227,5468,5514,1,5508,5493,6800,227,5514,5514, + 524,5474,5465,5696,2146,4416,4457,5514,504,3291, + 4196,6800,227,5514,2585,5514,5474,745,4964,4027, + 3326,2,5514,5514,219,3892,6800,227,5514,2585, + 4163,5474,745,5514,6008,3326,5017,3213,5514,219, + 5514,5514,3247,5514,2585,5514,4559,745,3213,6008, + 3326,5514,5514,5468,218,1,5477,5477,227,5477, + 227,227,227,227,6008,5695,5514,5505,5514,1915, + 1,5477,5477,227,5477,227,227,227,227,807, + 40,5514,5505,5514,5514,1,5477,5477,227,5477, + 227,227,227,227,5514,5514,5514,227,5514,6800, + 227,5514,5514,5514,5474,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,6800,227,5514,2585,5514,5474, + 745,5514,5514,3326,5514,5514,5514,219,5514,6800, + 227,5514,2585,5514,5474,745,5514,6008,3326,5514, + 5514,5514,219,5514,5514,5514,5514,2585,5514,5514, + 745,5514,6008,3326,1,5477,5477,227,5477,227, + 227,227,227,5514,5514,5514,227,6008,5514,1, + 5477,5477,227,5477,227,227,227,227,5514,5514, + 5514,227,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,6800,227, + 5514,5514,5514,5474,5514,5514,5514,5514,5514,5514, + 5514,5514,5514,6800,227,5514,2585,5514,5474,745, + 5514,5514,3326,5514,5514,5514,5514,5514,5514,5514, + 5514,2585,5514,5514,745,5514,6008,3326,5514,5514, + 5514,5514,5514,5514,5514,5514,5514,5514,5514,5514, + 5514,6008 + }; + }; + public final static char termAction[] = TermAction.termAction; + public final int termAction(int index) { return termAction[index]; } + + public interface Asb { + public final static char asb[] = {0, + 1078,67,696,67,61,1074,483,483,483,483, + 57,1074,509,483,913,509,1115,679,1117,697, + 697,697,697,697,697,697,697,697,819,825, + 830,827,834,832,839,837,841,840,842,200, + 843,696,1078,29,29,29,29,736,208,1, + 506,29,322,435,509,509,1,944,509,435, + 435,188,680,741,28,601,59,271,278,1078, + 802,802,1023,1023,208,1078,697,697,697,697, + 697,697,697,697,697,697,697,697,697,697, + 697,697,697,697,697,696,696,696,696,696, + 696,696,696,696,696,696,1078,697,435,983, + 983,983,983,149,435,1,194,789,800,911, + 800,451,800,908,800,784,800,800,57,736, + 322,322,1,697,194,281,399,389,388,325, + 57,1117,322,28,696,734,600,733,736,735, + 733,435,322,827,827,825,825,825,832,832, + 832,832,830,830,837,834,834,840,839,841, + 499,842,1074,1074,1074,1074,736,736,983,519, + 982,506,736,502,105,736,455,149,454,273, + 911,266,736,736,736,149,983,188,322,858, + 435,401,403,736,601,697,29,823,153,435, + 59,736,736,735,601,696,1078,1078,1078,1078, + 1074,1074,680,198,502,105,455,274,455,149, + 455,266,266,736,149,736,435,472,381,392, + 403,149,734,435,823,194,600,736,59,734, + 435,435,435,435,208,208,502,501,440,736, + 105,499,151,246,489,105,455,455,443,736, + 266,440,438,439,736,361,696,390,390,253, + 253,736,397,194,69,435,736,824,824,823, + 1078,153,251,59,435,435,502,601,483,733, + 371,491,730,1074,458,447,736,440,697,736, + 361,696,696,403,736,601,435,401,381,361, + 336,208,697,322,736,251,734,120,734,455, + 455,730,863,194,736,476,697,499,261,443, + 56,736,468,403,361,435,322,736,864,120, + 734,455,911,57,491,730,600,697,697,57, + 468,435,468,982,483,375,375,864,911,660, + 458,736,1074,736,1074,461,468,120,608,120, + 981,981,485,661,57,736,208,736,404,461, + 487,985,1065,1074,909,644,120,29,29,485, + 660,499,697,499,864,1074,1074,1074,661,1074, + 736,1030,864,864,1065,736,911,659,435,393, + 463,562,983,1065,487,607,911,559,911,57, + 982,102,1074,652,499,661,679,679,677,739, + 679,864,864,1065,557,485,29,463,608,607, + 608,864,260,863,435,607,607,57,607,736, + 100,69,435,730,435,1030,864,1074,435,485, + 607,696,869,730,864,440,607,607,736,607, + 736,375,435,435,349,661,557,661,864,1030, + 1078,661,658,440,435,867,440,736,440,864, + 981,911,911,774,696,659,1076,864,435,867, + 864,733,661,435,1076,864,439,661,435,867, + 661 + }; + }; + public final static char asb[] = Asb.asb; + public final int asb(int index) { return asb[index]; } + + public interface Asr { + public final static byte asr[] = {0, + 28,42,29,30,43,7,31,32,33,34, + 41,35,36,37,38,39,26,13,14,8, + 6,10,11,5,27,69,40,3,51,15, + 16,60,48,17,64,52,44,18,53,54, + 19,20,55,56,21,22,57,66,58,9, + 67,23,24,50,25,47,1,2,4,0, + 12,73,115,75,45,70,116,0,51,15, + 16,48,17,64,52,44,18,53,54,19, + 20,55,56,21,22,57,66,58,9,67, + 23,47,24,50,25,1,2,4,95,60, + 0,68,65,118,82,7,119,120,121,62, + 12,3,8,6,5,73,72,45,46,51, + 15,16,60,48,17,64,52,44,18,53, + 54,19,20,55,56,21,22,57,66,58, + 9,67,23,47,24,50,25,4,1,2, + 49,0,96,90,10,11,91,92,88,89, + 59,93,94,97,98,99,100,101,102,114, + 73,95,71,104,105,106,107,108,109,110, + 111,112,113,115,72,45,116,12,69,70, + 75,3,63,1,2,8,4,6,0,69, + 73,95,70,115,72,45,116,12,75,15, + 16,28,42,17,29,30,18,19,20,43, + 31,21,22,32,33,34,41,35,36,23, + 24,25,37,38,39,26,3,13,14,8, + 6,10,11,27,40,7,1,2,4,9, + 5,0,74,61,69,73,95,75,63,3, + 12,70,45,71,0,1,2,12,72,0, + 12,45,4,59,61,73,0,59,4,0, + 42,43,3,9,29,33,31,28,36,16, + 25,15,21,19,20,22,23,18,17,24, + 37,40,38,39,26,35,30,34,5,7, + 4,13,14,8,6,10,11,27,32,1, + 2,115,12,0,15,16,17,18,19,20, + 21,22,23,24,25,51,48,52,44,53, + 54,55,56,57,58,47,50,45,12,75, + 7,1,2,63,3,8,6,5,4,0, + 48,41,50,12,69,95,71,70,75,0, + 61,73,74,0,69,71,70,1,2,0, + 8,6,7,5,4,1,2,3,63,69, + 71,95,75,12,70,0,5,7,3,63, + 6,8,95,51,15,16,60,48,17,64, + 52,44,18,53,54,19,20,55,56,21, + 22,57,66,58,9,67,23,47,24,50, + 25,1,2,4,75,12,0,71,70,72, + 12,0,1,2,47,4,119,120,121,0, + 49,1,2,4,61,73,0,61,70,0, + 48,50,74,3,61,73,45,41,69,71, + 70,12,75,95,0,73,12,63,3,71, + 70,45,59,0,118,0,26,0,45,12, + 5,7,3,1,2,4,6,8,73,0, + 41,48,7,50,5,1,2,4,74,12, + 61,73,95,115,75,72,45,116,63,3, + 117,96,103,90,13,14,8,6,10,11, + 91,92,88,89,59,93,94,97,98,99, + 100,101,102,114,104,105,106,107,108,109, + 110,111,112,113,69,70,71,0,61,71, + 0,68,51,15,16,60,48,17,64,52, + 82,44,18,53,54,19,20,55,65,56, + 21,22,57,66,58,9,67,23,62,47, + 24,50,25,12,3,8,4,45,61,6, + 7,1,2,5,49,0,72,60,48,17, + 64,52,18,53,54,19,20,55,56,21, + 22,57,66,58,67,23,47,24,50,25, + 16,15,51,12,3,8,6,45,62,68, + 82,44,49,7,1,2,5,4,9,65, + 0,82,119,120,121,49,73,118,122,72, + 74,62,65,68,77,79,86,84,76,81, + 83,85,87,61,78,80,12,45,46,64, + 60,66,67,51,56,57,44,55,54,47, + 52,48,50,53,58,41,42,43,9,29, + 33,31,28,36,16,25,15,21,19,20, + 22,23,18,17,24,37,40,38,39,26, + 35,30,34,13,14,10,11,27,32,8, + 6,3,4,7,5,1,2,0,76,0, + 42,43,13,14,10,11,27,32,37,40, + 38,39,26,35,30,34,16,25,15,21, + 19,20,22,23,18,17,24,9,29,33, + 31,28,36,8,6,3,63,5,7,1, + 2,4,0,9,64,60,66,67,16,25, + 15,21,19,20,22,23,18,17,24,74, + 61,4,5,2,1,50,47,58,57,56, + 7,55,54,53,44,52,48,51,117,103, + 13,14,63,3,96,90,6,91,92,10, + 11,89,88,59,93,94,97,98,8,99, + 100,101,69,95,75,116,71,104,105,106, + 107,108,109,110,111,112,113,73,115,72, + 102,114,70,45,12,0,12,72,42,43, + 41,13,14,8,6,10,11,5,27,32, + 3,7,37,40,38,39,26,35,30,34, + 16,25,15,21,19,20,22,23,18,17, + 24,9,29,33,31,28,36,4,1,2, + 61,0,51,15,16,60,48,17,64,52, + 44,18,53,54,19,20,55,56,21,22, + 57,66,58,9,67,23,47,24,50,25, + 1,2,4,43,42,10,11,6,91,92, + 99,8,100,5,27,59,107,108,104,105, + 106,112,111,113,89,88,109,110,97,98, + 93,94,101,102,13,14,90,103,3,63, + 71,70,69,0,60,48,17,64,52,18, + 53,54,19,20,55,56,21,22,57,66, + 58,9,67,23,47,24,50,25,16,15, + 51,12,3,8,6,45,62,65,68,82, + 44,59,7,4,49,5,1,2,0,15, + 16,28,42,17,29,30,18,19,20,43, + 31,21,22,32,33,34,41,35,36,9, + 23,24,25,37,38,39,26,13,14,10, + 11,27,40,46,12,8,6,45,5,7, + 1,2,4,3,0,12,75,15,16,28, + 17,29,30,18,19,20,31,21,22,32, + 33,34,41,35,36,9,23,24,25,37, + 38,39,26,3,13,14,8,6,10,11, + 27,4,40,46,5,7,1,2,43,42, + 0 + }; + }; + public final static byte asr[] = Asr.asr; + public final int asr(int index) { return asr[index]; } + + public interface Nasb { + public final static char nasb[] = {0, + 154,11,32,11,11,11,11,11,11,11, + 108,11,11,11,198,11,142,226,129,32, + 32,140,32,32,32,32,32,32,11,11, + 11,11,11,11,11,11,11,11,11,32, + 11,32,172,137,137,137,137,129,94,92, + 15,4,77,232,11,11,92,200,11,232, + 232,132,1,32,20,123,11,11,11,172, + 11,11,22,22,94,172,32,32,32,32, + 32,32,32,32,32,32,32,32,32,32, + 32,32,32,32,32,32,32,32,32,32, + 32,32,32,32,32,32,172,32,232,11, + 11,11,11,66,232,30,107,181,182,11, + 182,127,182,9,182,175,11,11,108,129, + 77,77,30,32,107,73,132,64,64,11, + 108,129,77,137,81,151,39,150,152,129, + 150,232,77,11,11,11,11,11,11,11, + 11,11,11,11,11,11,11,11,11,11, + 11,11,11,11,11,11,27,152,11,11, + 11,223,129,92,92,143,92,206,92,11, + 11,92,206,129,10,11,11,221,77,11, + 232,193,92,129,123,32,137,92,59,232, + 11,10,129,10,123,32,172,172,172,172, + 11,11,30,11,125,214,92,92,57,122, + 57,92,45,152,122,27,232,11,86,11, + 195,121,27,232,47,223,39,10,11,27, + 232,232,232,232,94,94,92,125,53,129, + 204,11,11,69,162,214,57,57,117,27, + 45,53,11,11,27,92,32,11,11,64, + 64,129,86,107,195,232,27,43,43,11, + 172,223,11,11,232,232,125,123,11,108, + 92,103,88,11,11,219,206,53,32,45, + 125,32,32,92,10,123,232,193,146,92, + 11,94,32,77,10,11,151,92,206,92, + 18,148,204,107,129,11,32,11,79,184, + 186,152,92,195,125,232,77,10,204,195, + 151,18,115,97,88,148,123,32,32,108, + 71,232,92,11,11,84,84,204,115,12, + 11,206,11,206,11,92,71,195,188,92, + 11,11,92,157,97,152,94,152,230,125, + 11,188,163,11,10,69,195,137,137,101, + 169,11,32,11,204,11,11,11,170,11, + 10,202,204,204,92,10,37,11,232,232, + 92,92,11,103,11,92,11,11,11,108, + 11,55,11,11,11,170,136,136,209,11, + 136,204,204,88,11,92,137,71,188,92, + 188,204,62,11,232,110,92,108,92,206, + 11,137,232,88,232,211,204,11,232,101, + 110,81,32,88,204,53,188,110,206,110, + 10,84,232,232,92,170,11,170,204,211, + 172,170,55,53,232,92,53,10,53,204, + 11,37,37,86,32,11,211,204,232,49, + 204,150,170,232,211,204,53,170,232,49, + 170 + }; + }; + public final static char nasb[] = Nasb.nasb; + public final int nasb(int index) { return nasb[index]; } + + public interface Nasr { + public final static char nasr[] = {0, + 3,13,8,151,149,123,148,147,6,1, + 0,5,66,0,5,190,0,157,0,174, + 0,6,2,8,140,0,4,3,0,51, + 5,6,8,2,13,0,57,0,67,139, + 138,0,141,0,125,0,179,0,13,2, + 8,6,66,0,117,0,115,0,5,178, + 0,181,0,70,0,137,67,0,154,0, + 127,0,13,2,8,6,81,0,187,0, + 5,29,0,114,0,102,101,65,6,2, + 8,5,0,5,104,0,168,6,167,0, + 159,0,2,65,8,5,97,6,0,109, + 5,47,71,0,158,0,6,132,188,0, + 137,2,67,0,61,0,3,6,1,48, + 0,101,102,5,0,118,5,51,0,6, + 13,8,2,3,0,102,101,65,56,6, + 8,2,0,5,173,0,5,47,39,180, + 0,40,6,2,8,5,156,0,66,47, + 72,5,39,0,1,6,123,119,120,121, + 13,94,0,6,164,132,0,5,47,71, + 82,0,6,97,24,5,0,5,51,170, + 0,5,39,40,0,1,62,0,47,50, + 5,107,0,5,47,71,68,6,131,0, + 102,101,6,56,0,5,51,39,0,51, + 5,36,0 + }; + }; + public final static char nasr[] = Nasr.nasr; + public final int nasr(int index) { return nasr[index]; } + + public interface TerminalIndex { + public final static char terminalIndex[] = {0, + 115,116,2,32,14,11,81,10,102,12, + 13,117,8,9,50,54,62,70,76,77, + 88,89,104,107,109,114,15,57,63,69, + 86,90,92,96,99,101,111,112,113,46, + 97,60,80,68,122,123,106,56,95,108, + 49,66,72,75,78,85,91,100,20,55, + 3,105,1,65,79,93,103,48,21,45, + 34,121,31,98,120,110,51,52,58,59, + 61,67,71,73,74,87,94,18,19,7, + 16,17,22,23,33,5,24,25,26,27, + 28,29,6,35,36,37,38,39,40,41, + 42,43,44,30,119,124,4,53,82,83, + 84,64,118 + }; + }; + public final static char terminalIndex[] = TerminalIndex.terminalIndex; + public final int terminalIndex(int index) { return terminalIndex[index]; } + + public interface NonterminalIndex { + public final static char nonterminalIndex[] = {0, + 131,136,138,239,0,0,137,235,135,0, + 134,0,146,0,133,0,0,145,150,0, + 0,151,160,181,161,162,163,164,153,165, + 166,139,167,168,169,127,170,0,132,129, + 171,0,198,144,0,141,0,140,0,178, + 154,0,0,0,0,157,174,0,205,0, + 188,0,148,202,206,128,0,179,0,207, + 0,173,0,0,0,0,0,0,0,177, + 126,130,149,0,0,0,0,0,0,0, + 0,0,0,187,0,0,203,213,159,209, + 210,211,0,0,0,0,0,208,180,0, + 0,0,212,0,0,0,242,176,190,191, + 192,193,194,196,197,200,0,215,218,220, + 221,0,238,0,241,0,0,142,143,147, + 0,156,0,172,0,182,183,184,185,186, + 189,0,195,0,199,204,0,216,217,0, + 222,225,227,229,0,232,233,234,0,236, + 237,240,125,0,152,0,0,155,158,175, + 201,214,219,0,223,224,226,228,230,231, + 243,244,0,0,0,0,0,0,0 + }; + }; + public final static char nonterminalIndex[] = NonterminalIndex.nonterminalIndex; + public final int nonterminalIndex(int index) { return nonterminalIndex[index]; } + + public interface ScopePrefix { + public final static char scopePrefix[] = { + 138,572,591,359,523,539,550,561,339,71, + 244,258,280,286,292,42,269,384,422,474, + 146,580,367,20,51,77,114,174,275,298, + 309,320,250,264,27,495,349,320,599,27, + 196,223,1,14,61,93,128,303,316,325, + 332,440,467,519,609,613,617,84,7,84, + 128,402,418,431,451,510,431,483,530,546, + 557,568,186,373,56,56,135,201,204,56, + 218,239,204,204,56,336,446,464,471,135, + 632,97,211,406,458,56,103,103,211,56, + 393,211,156,91,444,621,628,621,628,65, + 412,121,91,91,228 + }; + }; + public final static char scopePrefix[] = ScopePrefix.scopePrefix; + public final int scopePrefix(int index) { return scopePrefix[index]; } + + public interface ScopeSuffix { + public final static char scopeSuffix[] = { + 18,5,5,346,5,5,5,5,346,59, + 119,82,119,119,119,48,255,390,428,480, + 152,67,354,25,25,82,119,179,119,119, + 314,314,255,88,38,500,354,586,604,32, + 190,190,5,18,5,82,119,307,307,307, + 82,119,221,5,5,5,221,630,11,88, + 132,346,346,346,455,500,435,487,534,534, + 534,534,190,377,59,59,5,5,207,209, + 221,5,242,242,209,82,449,5,221,5, + 5,100,329,409,461,492,106,110,214,514, + 396,504,159,82,82,623,623,625,625,67, + 414,123,181,166,230 + }; + }; + public final static char scopeSuffix[] = ScopeSuffix.scopeSuffix; + public final int scopeSuffix(int index) { return scopeSuffix[index]; } + + public interface ScopeLhs { + public final static char scopeLhs[] = { + 68,18,18,76,18,18,18,18,76,164, + 86,49,93,92,121,69,54,76,75,20, + 68,18,76,3,7,161,119,68,91,121, + 120,122,55,49,134,140,76,18,18,134, + 103,58,136,79,167,161,129,120,120,122, + 50,57,179,18,18,18,18,12,117,161, + 129,76,75,75,38,140,75,20,18,18, + 18,18,103,76,168,164,181,101,108,60, + 70,59,156,80,122,77,73,143,179,177, + 17,161,122,118,22,140,130,130,56,140, + 76,140,68,161,74,138,48,138,48,167, + 118,119,68,68,58 + }; + }; + public final static char scopeLhs[] = ScopeLhs.scopeLhs; + public final int scopeLhs(int index) { return scopeLhs[index]; } + + public interface ScopeLa { + public final static byte scopeLa[] = { + 118,75,75,75,75,75,75,75,75,1, + 72,45,72,72,72,69,1,75,122,75, + 61,3,45,69,69,45,72,61,72,72, + 1,1,1,1,69,4,45,1,1,69, + 75,75,75,118,75,45,72,1,1,1, + 45,72,115,75,75,75,115,1,75,1, + 70,75,75,75,73,4,75,3,69,69, + 69,69,75,45,1,1,75,75,3,1, + 115,75,1,1,1,45,73,75,115,75, + 75,1,49,71,75,5,1,1,6,1, + 76,49,74,45,45,4,4,4,4,3, + 1,61,1,1,3 + }; + }; + public final static byte scopeLa[] = ScopeLa.scopeLa; + public final int scopeLa(int index) { return scopeLa[index]; } + + public interface ScopeStateSet { + public final static char scopeStateSet[] = { + 87,249,249,110,249,249,249,249,110,63, + 23,99,23,23,157,87,101,110,110,249, + 87,249,110,183,225,96,157,87,23,157, + 157,157,101,99,56,140,110,249,249,56, + 149,71,33,110,37,96,311,157,157,157, + 12,40,69,249,249,249,249,229,7,96, + 311,110,110,110,281,140,110,249,249,249, + 249,249,149,110,37,63,1,149,151,71, + 145,71,66,76,157,110,110,60,69,143, + 249,96,157,3,250,140,157,157,124,140, + 110,140,87,96,110,121,161,121,161,37, + 3,157,87,87,71 + }; + }; + public final static char scopeStateSet[] = ScopeStateSet.scopeStateSet; + public final int scopeStateSet(int index) { return scopeStateSet[index]; } + + public interface ScopeRhs { + public final static char scopeRhs[] = {0, + 315,3,41,0,127,0,314,3,118,0, + 127,174,0,128,180,74,0,217,0,292, + 128,59,127,0,21,0,294,128,59,49, + 0,21,55,0,34,133,0,21,55,0, + 0,294,128,59,49,194,0,21,130,0, + 292,128,59,131,0,185,129,0,139,0, + 227,3,291,0,291,0,2,0,127,0, + 185,129,255,254,255,0,132,190,171,129, + 0,129,0,190,171,129,0,135,129,0, + 170,0,308,128,170,0,128,170,0,223, + 129,0,171,246,0,138,0,0,0,136, + 0,0,0,307,128,61,253,0,128,0, + 253,0,3,0,0,128,0,306,128,61, + 0,45,128,0,152,3,0,128,281,280, + 128,74,279,170,0,280,128,74,279,170, + 0,216,0,217,0,279,170,0,98,0, + 0,216,0,217,0,204,98,0,0,216, + 0,217,0,280,128,279,170,0,216,0, + 204,0,0,216,0,234,128,3,0,127, + 0,0,0,0,0,234,128,3,224,0, + 231,3,0,220,128,0,209,0,149,0, + 171,129,0,11,0,0,0,222,63,0, + 126,0,234,128,3,182,0,182,0,2, + 0,0,127,0,0,0,0,0,203,3, + 0,202,0,233,128,61,26,44,0,185, + 129,65,62,0,144,129,0,132,185,129, + 277,62,0,185,129,277,62,0,185,129, + 71,124,65,0,233,128,61,65,0,233, + 128,61,166,65,0,233,128,61,125,65, + 0,275,128,61,124,64,0,275,128,61, + 64,0,185,129,64,0,136,0,190,185, + 129,246,0,138,0,185,129,246,0,190, + 171,129,9,0,171,129,9,0,95,138, + 0,268,128,170,0,162,86,0,230,163, + 230,173,3,83,0,127,173,0,230,173, + 3,83,0,129,0,127,173,0,230,163, + 230,163,230,3,83,0,230,163,230,3, + 83,0,230,3,83,0,129,0,129,0, + 127,173,0,162,3,76,195,81,0,127, + 129,0,195,81,0,110,2,132,127,129, + 0,241,3,76,0,203,174,0,34,171, + 0,174,0,177,34,171,0,241,3,87, + 0,195,159,241,3,85,0,64,173,0, + 241,3,85,0,127,173,64,173,0,303, + 128,61,0,162,0,222,78,0,31,0, + 162,114,160,0,31,171,0,186,3,0, + 127,151,0,227,3,0,222,63,302,0, + 162,63,0,186,3,297,43,129,0,127, + 0,0,297,43,129,0,2,148,127,0, + 0,14,149,0,126,49,171,129,0,32, + 14,149,0,95,138,32,14,149,0,206, + 185,129,0,149,32,14,149,0,162,3, + 36,0,162,3,69,186,59,28,0,186, + 59,28,0,21,2,132,127,0,162,3, + 69,186,59,31,0,186,59,31,0,162, + 3,69,186,59,33,0,186,59,33,0, + 162,3,69,186,59,29,0,186,59,29, + 0,227,3,126,190,171,129,9,0,126, + 190,171,129,9,0,138,2,0,127,0, + 227,3,125,260,171,129,9,0,260,171, + 129,9,0,136,2,0,127,0,227,3, + 136,0,227,3,141,0,162,63,141,0, + 262,0,32,0,32,142,0,169,0,135, + 0,162,3,0 + }; + }; + public final static char scopeRhs[] = ScopeRhs.scopeRhs; + public final int scopeRhs(int index) { return scopeRhs[index]; } + + public interface ScopeState { + public final static char scopeState[] = {0, + 1250,0,4964,4719,3146,0,1525,2925,997,2907, + 0,4478,4437,4396,4355,4314,4273,4196,4027,3986, + 3489,3433,3190,3139,4214,3074,3009,4163,4107,3927, + 3871,0,2720,2515,1774,0,2840,2749,0,4478, + 4437,4396,3206,3003,4355,4314,4273,4027,721,3986, + 3489,3433,3435,3013,0,4500,2775,4108,0,1994, + 744,0,3803,3023,0,3418,3439,0,882,0, + 3418,4647,2448,3400,3439,2811,4559,4602,4085,2985, + 4536,4572,2972,2785,2702,0,3190,3139,4214,3074, + 3009,4163,4107,3927,3871,4678,4621,0,4678,4621, + 3190,3139,4214,3074,3009,4163,4107,3927,3871,4478, + 4437,4396,4355,4314,4273,4027,3986,3489,3433,0, + 3463,730,0,2985,4647,3016,2448,3400,4110,2972, + 4117,3015,3931,3872,4638,2848,1065,620,0,731, + 658,0,625,0,1783,1603,1353,1266,3400,4638, + 2811,2785,2702,4272,3133,0,3792,533,2380,0, + 4888,4880,4831,4825,4816,4810,4753,4728,4913,4903, + 4895,4289,4672,4126,4002,3904,2834,2399,3104,2857, + 2477,0,4888,4880,2492,2487,4831,4825,3177,2482, + 4816,4810,3085,2742,4753,3521,4728,3413,3286,4913, + 3267,2138,3198,2998,2044,4903,3252,4895,792,4289, + 4672,4126,2036,4002,671,3904,1077,2834,2399,3792, + 3104,2380,2857,2477,2388,2228,1066,1905,807,2811, + 4559,4602,4085,2985,3418,4647,4536,2448,3400,4572, + 2972,2785,3439,2702,1004,576,731,658,630,3848, + 3819,2240,2279,2348,2314,2561,2532,2407,2715,589, + 2674,2646,2618,2590,3376,3352,3328,2946,2920,3769, + 3746,3723,3700,3677,3654,3631,3608,3569,3301,932, + 1915,2185,2146,2091,2052,1997,1173,1130,1958,1085, + 825,1862,1821,749,685,1778,1735,1692,1649,1606, + 1563,1520,1477,1434,1391,1348,533,1304,1261,1022, + 961,889,1218,0 + }; + }; + public final static char scopeState[] = ScopeState.scopeState; + public final int scopeState(int index) { return scopeState[index]; } + + public interface InSymb { + public final static char inSymb[] = {0, + 0,296,128,46,267,36,28,31,33,29, + 9,136,125,127,7,131,4,3,129,32, + 27,5,11,10,6,8,14,13,141,146, + 149,148,151,150,154,153,157,156,158,41, + 160,70,3,59,59,59,59,129,3,59, + 174,128,63,3,42,43,59,7,125,186, + 162,174,128,42,43,171,169,124,125,3, + 126,125,103,117,3,63,90,96,11,10, + 92,91,6,94,93,69,59,88,89,8, + 98,97,100,99,101,113,112,111,110,109, + 108,107,106,105,104,71,114,102,162,186, + 186,186,186,171,227,128,128,269,270,253, + 271,246,272,64,273,274,124,125,9,129, + 63,63,128,159,128,63,3,225,224,136, + 9,129,63,297,3,190,4,49,5,129, + 49,227,162,148,148,146,146,146,150,150, + 150,150,149,149,153,151,151,156,154,157, + 162,158,69,69,69,69,190,260,292,134, + 295,220,129,6,61,171,237,129,126,125, + 124,61,129,129,185,171,292,220,222,160, + 231,128,3,129,171,204,3,298,174,152, + 262,190,129,185,171,73,3,3,3,3, + 126,125,70,171,128,128,126,125,128,185, + 128,61,128,185,171,49,234,235,147,236, + 128,171,49,186,128,128,4,5,206,49, + 162,162,162,162,3,3,6,184,307,129, + 191,254,194,62,170,309,128,128,73,190, + 128,275,248,276,190,159,71,231,203,188, + 182,129,3,128,70,234,190,159,299,302, + 63,179,4,126,227,227,128,171,49,277, + 279,128,3,182,311,255,129,275,71,70, + 128,71,71,3,185,171,203,128,220,159, + 126,3,63,162,5,4,190,59,129,74, + 128,220,308,128,129,125,73,286,203,70, + 254,185,228,128,128,227,222,5,132,128, + 185,128,280,73,70,220,171,73,71,255, + 128,234,228,294,49,9,60,132,280,61, + 290,129,291,129,41,159,128,70,69,59, + 237,237,281,128,70,185,3,185,3,128, + 44,49,170,68,65,62,128,71,71,128, + 303,80,78,1,162,87,85,83,81,76, + 84,86,79,77,170,65,74,46,227,315, + 228,26,59,128,3,61,166,124,125,65, + 294,282,118,12,222,73,3,3,3,195, + 3,124,162,128,124,180,70,128,128,61, + 69,268,203,278,26,128,61,71,61,129, + 69,3,241,174,241,173,230,76,241,128, + 128,3,71,70,159,233,232,128,129,128, + 185,60,95,314,174,159,203,159,230,163, + 3,159,282,233,152,61,233,185,233,167, + 237,159,159,128,71,195,163,230,162,128, + 167,71,122,230,163,159,306,159,230,70, + 159 + }; + }; + public final static char inSymb[] = InSymb.inSymb; + public final int inSymb(int index) { return inSymb[index]; } + + public interface Name { + public final static String name[] = { + "", + "[", + "(", + "{", + ".", + ".*", + "->", + "->*", + "++", + "--", + "&", + "*", + "+", + "-", + "~", + "!", + "/", + "%", + ">>", + "<<", + "<", + ">", + "<=", + ">=", + "==", + "!=", + "^", + "|", + "&&", + "||", + "?", + ":", + "::", + "...", + "=", + "*=", + "/=", + "%=", + "+=", + "-=", + ">>=", + "<<=", + "&=", + "^=", + "|=", + ",", + "0", + "$empty", + "asm", + "auto", + "bool", + "break", + "case", + "catch", + "char", + "class", + "const", + "const_cast", + "continue", + "default", + "delete", + "do", + "double", + "dynamic_cast", + "else", + "enum", + "explicit", + "export", + "extern", + "false", + "float", + "for", + "friend", + "goto", + "if", + "inline", + "int", + "long", + "mutable", + "namespace", + "new", + "operator", + "private", + "protected", + "public", + "register", + "reinterpret_cast", + "return", + "short", + "signed", + "sizeof", + "static", + "static_cast", + "struct", + "switch", + "template", + "this", + "throw", + "try", + "true", + "typedef", + "typeid", + "typename", + "union", + "unsigned", + "using", + "virtual", + "void", + "volatile", + "wchar_t", + "while", + "integer", + "floating", + "charconst", + "stringlit", + "identifier", + "Completion", + "EndOfCompletion", + "Invalid", + "RightBracket", + "RightParen", + "RightBrace", + "SemiColon", + "ERROR_TOKEN", + "EOF_TOKEN", + "no_sizeof_type_name_start", + "]", + ")", + "}", + ";", + "declaration", + "identifier_token", + "expression", + "id_expression", + "qualified_or_unqualified_name", + "unqualified_id_name", + "identifier_name", + "operator_function_id_name", + "template_id_name", + "class_name", + "nested_name_specifier", + "class_or_namespace_name", + "nested_name_specifier_with_tem" + + "plate", + "class_or_namespace_name_with_t" + + "emplate", + "namespace_name", + "postfix_expression", + "simple_type_specifier", + "pseudo_destructor_name", + "type_id", + "type_name", + "unary_expression", + "cast_expression", + "new_type_id", + "expression_list", + "type_specifier_seq", + "new_declarator", + "new_pointer_operators", + "ptr_operator", + "new_array_expressions", + "constant_expression", + "pm_expression", + "multiplicative_expression", + "additive_expression", + "shift_expression", + "relational_expression", + "equality_expression", + "and_expression", + "exclusive_or_expression", + "inclusive_or_expression", + "logical_and_expression", + "logical_or_expression", + "assignment_expression", + "expression_list_actual", + "statement", + "compound_statement", + "statement_seq", + "condition", + "declarator", + "simple_declaration", + "function_definition", + "declaration_seq", + "declaration_specifiers", + "simple_declaration_specifiers", + "class_declaration_specifiers", + "elaborated_declaration_specifi" + + "ers", + "enum_declaration_specifiers", + "type_name_declaration_specifie" + + "rs", + "no_type_declaration_specifier", + "cv_qualifier", + "no_type_declaration_specifiers", + "class_specifier", + "elaborated_type_specifier", + "enum_specifier", + "type_name_specifier", + "class_keyword", + "enumerator_list", + "enumerator_definition", + "enumerator", + "original_namespace_name", + "init_declarator_list", + "init_declarator", + "initializer", + "direct_declarator", + "ptr_operator_seq", + "function_declarator", + "basic_direct_declarator", + "array_direct_declarator", + "array_modifier", + "abstract_declarator", + "direct_abstract_declarator", + "basic_direct_abstract_declarat" + + "or", + "array_direct_abstract_declarat" + + "or", + "parameter_declaration_list", + "parameter_declaration", + "parameter_init_declarator", + "parameter_initializer", + "function_body", + "handler_seq", + "initializer_clause", + "initializer_list", + "class_head", + "access_specifier_keyword", + "member_declaration", + "member_declarator_list", + "member_declaration_list", + "member_declarator", + "constant_initializer", + "bit_field_declarator", + "base_specifier_list", + "base_specifier", + "conversion_type_id", + "conversion_declarator", + "mem_initializer_list", + "mem_initializer", + "mem_initializer_name", + "operator_id_name", + "overloadable_operator", + "template_parameter_list", + "template_parameter", + "template_identifier", + "template_argument_list", + "template_argument", + "handler", + "exception_declaration", + "type_id_list" + }; + }; + public final static String name[] = Name.name; + public final String name(int index) { return name[index]; } + + public final static int + ERROR_SYMBOL = 46, + SCOPE_UBOUND = 114, + SCOPE_SIZE = 115, + MAX_NAME_LENGTH = 37; + + public final int getErrorSymbol() { return ERROR_SYMBOL; } + public final int getScopeUbound() { return SCOPE_UBOUND; } + public final int getScopeSize() { return SCOPE_SIZE; } + public final int getMaxNameLength() { return MAX_NAME_LENGTH; } + + public final static int + NUM_STATES = 521, + NT_OFFSET = 123, + LA_STATE_OFFSET = 6046, + MAX_LA = 2147483647, + NUM_RULES = 532, + NUM_NONTERMINALS = 199, + NUM_SYMBOLS = 322, + SEGMENT_SIZE = 8192, + START_STATE = 3432, + IDENTIFIER_SYMBOL = 0, + EOFT_SYMBOL = 116, + EOLT_SYMBOL = 116, + ACCEPT_ACTION = 5157, + ERROR_ACTION = 5514; + + public final static boolean BACKTRACK = true; + + public final int getNumStates() { return NUM_STATES; } + public final int getNtOffset() { return NT_OFFSET; } + public final int getLaStateOffset() { return LA_STATE_OFFSET; } + public final int getMaxLa() { return MAX_LA; } + public final int getNumRules() { return NUM_RULES; } + public final int getNumNonterminals() { return NUM_NONTERMINALS; } + public final int getNumSymbols() { return NUM_SYMBOLS; } + public final int getSegmentSize() { return SEGMENT_SIZE; } + public final int getStartState() { return START_STATE; } + public final int getStartSymbol() { return lhs[0]; } + public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; } + public final int getEoftSymbol() { return EOFT_SYMBOL; } + public final int getEoltSymbol() { return EOLT_SYMBOL; } + public final int getAcceptAction() { return ACCEPT_ACTION; } + public final int getErrorAction() { return ERROR_ACTION; } + public final boolean isValidForParser() { return isValidForParser; } + public final boolean getBacktrack() { return BACKTRACK; } + + public final int originalState(int state) { + return -baseCheck[state]; + } + public final int asi(int state) { + return asb[originalState(state)]; + } + public final int nasi(int state) { + return nasb[originalState(state)]; + } + public final int inSymbol(int state) { + return inSymb[originalState(state)]; + } + + public final int ntAction(int state, int sym) { + return baseAction[state + sym]; + } + + public final int tAction(int state, int sym) { + int i = baseAction[state], + k = i + sym; + return termAction[termCheck[k] == sym ? k : i]; + } + public final int lookAhead(int la_state, int sym) { + int k = la_state + sym; + return termAction[termCheck[k] == sym ? k : la_state]; + } +} diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParsersym.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParsersym.java new file mode 100644 index 00000000000..b772247397a --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPSizeofExpressionParsersym.java @@ -0,0 +1,270 @@ +/******************************************************************************* +* Copyright (c) 2006, 2008 IBM Corporation and others. +* All rights reserved. This program and the accompanying materials +* are made available under the terms of the Eclipse Public License v1.0 +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl_v10.html +* +* Contributors: +* IBM Corporation - initial API and implementation +*********************************************************************************/ + +// This file was generated by LPG + +package org.eclipse.cdt.internal.core.dom.lrparser.cpp; + +public interface CPPSizeofExpressionParsersym { + public final static int + TK_asm = 68, + TK_auto = 51, + TK_bool = 15, + TK_break = 77, + TK_case = 78, + TK_catch = 118, + TK_char = 16, + TK_class = 60, + TK_const = 48, + TK_const_cast = 28, + TK_continue = 79, + TK_default = 80, + TK_delete = 42, + TK_do = 81, + TK_double = 17, + TK_dynamic_cast = 29, + TK_else = 122, + TK_enum = 64, + TK_explicit = 52, + TK_export = 82, + TK_extern = 44, + TK_false = 30, + TK_float = 18, + TK_for = 83, + TK_friend = 53, + TK_goto = 84, + TK_if = 85, + TK_inline = 54, + TK_int = 19, + TK_long = 20, + TK_mutable = 55, + TK_namespace = 65, + TK_new = 43, + TK_operator = 7, + TK_private = 119, + TK_protected = 120, + TK_public = 121, + TK_register = 56, + TK_reinterpret_cast = 31, + TK_return = 86, + TK_short = 21, + TK_signed = 22, + TK_sizeof = 32, + TK_static = 57, + TK_static_cast = 33, + TK_struct = 66, + TK_switch = 87, + TK_template = 49, + TK_this = 34, + TK_throw = 41, + TK_try = 74, + TK_true = 35, + TK_typedef = 58, + TK_typeid = 36, + TK_typename = 9, + TK_union = 67, + TK_unsigned = 23, + TK_using = 62, + TK_virtual = 47, + TK_void = 24, + TK_volatile = 50, + TK_wchar_t = 25, + TK_while = 76, + TK_integer = 37, + TK_floating = 38, + TK_charconst = 39, + TK_stringlit = 26, + TK_identifier = 1, + TK_Completion = 2, + TK_EndOfCompletion = 12, + TK_Invalid = 123, + TK_LeftBracket = 63, + TK_LeftParen = 3, + TK_LeftBrace = 61, + TK_Dot = 117, + TK_DotStar = 96, + TK_Arrow = 103, + TK_ArrowStar = 90, + TK_PlusPlus = 13, + TK_MinusMinus = 14, + TK_And = 8, + TK_Star = 6, + TK_Plus = 10, + TK_Minus = 11, + TK_Tilde = 5, + TK_Bang = 27, + TK_Slash = 91, + TK_Percent = 92, + TK_RightShift = 88, + TK_LeftShift = 89, + TK_LT = 59, + TK_GT = 69, + TK_LE = 93, + TK_GE = 94, + TK_EQ = 97, + TK_NE = 98, + TK_Caret = 99, + TK_Or = 100, + TK_AndAnd = 101, + TK_OrOr = 102, + TK_Question = 114, + TK_Colon = 73, + TK_ColonColon = 4, + TK_DotDotDot = 95, + TK_Assign = 71, + TK_StarAssign = 104, + TK_SlashAssign = 105, + TK_PercentAssign = 106, + TK_PlusAssign = 107, + TK_MinusAssign = 108, + TK_RightShiftAssign = 109, + TK_LeftShiftAssign = 110, + TK_AndAssign = 111, + TK_CaretAssign = 112, + TK_OrAssign = 113, + TK_Comma = 70, + TK_zero = 40, + TK_RightBracket = 115, + TK_RightParen = 75, + TK_RightBrace = 72, + TK_SemiColon = 45, + TK_ERROR_TOKEN = 46, + TK_EOF_TOKEN = 116; + + public final static String orderedTerminalSymbols[] = { + "", + "identifier", + "Completion", + "LeftParen", + "ColonColon", + "Tilde", + "Star", + "operator", + "And", + "typename", + "Plus", + "Minus", + "EndOfCompletion", + "PlusPlus", + "MinusMinus", + "bool", + "char", + "double", + "float", + "int", + "long", + "short", + "signed", + "unsigned", + "void", + "wchar_t", + "stringlit", + "Bang", + "const_cast", + "dynamic_cast", + "false", + "reinterpret_cast", + "sizeof", + "static_cast", + "this", + "true", + "typeid", + "integer", + "floating", + "charconst", + "zero", + "throw", + "delete", + "new", + "extern", + "SemiColon", + "ERROR_TOKEN", + "virtual", + "const", + "template", + "volatile", + "auto", + "explicit", + "friend", + "inline", + "mutable", + "register", + "static", + "typedef", + "LT", + "class", + "LeftBrace", + "using", + "LeftBracket", + "enum", + "namespace", + "struct", + "union", + "asm", + "GT", + "Comma", + "Assign", + "RightBrace", + "Colon", + "try", + "RightParen", + "while", + "break", + "case", + "continue", + "default", + "do", + "export", + "for", + "goto", + "if", + "return", + "switch", + "RightShift", + "LeftShift", + "ArrowStar", + "Slash", + "Percent", + "LE", + "GE", + "DotDotDot", + "DotStar", + "EQ", + "NE", + "Caret", + "Or", + "AndAnd", + "OrOr", + "Arrow", + "StarAssign", + "SlashAssign", + "PercentAssign", + "PlusAssign", + "MinusAssign", + "RightShiftAssign", + "LeftShiftAssign", + "AndAssign", + "CaretAssign", + "OrAssign", + "Question", + "RightBracket", + "EOF_TOKEN", + "Dot", + "catch", + "private", + "protected", + "public", + "else", + "Invalid" + }; + + public final static boolean isValidForParser = true; +}