diff --git a/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml b/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml index 6801241a2d6..869eec9fa0b 100644 --- a/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml +++ b/lrparser/org.eclipse.cdt.core.lrparser/grammar/build.xml @@ -88,6 +88,10 @@ + + + + diff --git a/lrparser/org.eclipse.cdt.core.lrparser/grammar/cpp/CPPTemplateTypeParameterParser.g b/lrparser/org.eclipse.cdt.core.lrparser/grammar/cpp/CPPTemplateTypeParameterParser.g new file mode 100644 index 00000000000..a36efe511ce --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/grammar/cpp/CPPTemplateTypeParameterParser.g @@ -0,0 +1,47 @@ +----------------------------------------------------------------------------------- +-- 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 + +-- This parser is a bit of a hack. + +-- There are ambiguities between type_parameter and parameter_declaration +-- when parsing a template_parameter. + +-- I believe the correct disambiguation is to simply favor type_parameter +-- over parameter_declaration. + +-- I have tried to resolve this by refactoring the grammar file so that +-- the parser will give precedence to type_parameter, but I have failed. + +-- So the hacky solution is to reparse the tokens as a type_parameter and if +-- it succeeds, throw away the paramter_declaration and use the type_parameter +-- in its place. + + +$Import + CPPGrammar.g +$End + +$Start + type_parameter_start +$End + +$Rules + + type_parameter_start + ::= type_parameter + | ERROR_TOKEN + /. $Build consumeDeclarationProblem(); $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/cpp/CPPBuildASTParserAction.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/cpp/CPPBuildASTParserAction.java index 0acea2842a8..b32c8208d41 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 @@ -96,6 +96,7 @@ import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPNoCastExpressionParser; import org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPNoFunctionDeclaratorParser; 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.lrparser.cpp.CPPTemplateTypeParameterParser; import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTQualifiedName; import org.eclipse.cdt.internal.core.dom.parser.cpp.OverloadableOperator; @@ -148,14 +149,22 @@ public class CPPBuildASTParserAction extends BuildASTParserAction { return new CPPNoCastExpressionParser(parser.getOrderedTerminalSymbols()); } - @Override protected IParser getSizeofExpressionParser() { return new CPPSizeofExpressionParser(parser.getOrderedTerminalSymbols()); } + protected IParser getTemplateTypeParameterParser() { + return new CPPTemplateTypeParameterParser(parser.getOrderedTerminalSymbols()); + } + protected IParser getNoFunctionDeclaratorParser() { + return new CPPNoFunctionDeclaratorParser(parser.getOrderedTerminalSymbols()); + } + + + /** * new_expression * ::= dcolon_opt 'new' new_placement_opt new_type_id new_array_expressions_op new_initializer_opt @@ -1264,13 +1273,14 @@ public class CPPBuildASTParserAction extends BuildASTParserAction { if(!(declarator instanceof IASTFunctionDeclarator)) return; - IParser secondaryParser = new CPPNoFunctionDeclaratorParser(parser.getOrderedTerminalSymbols()); + IParser secondaryParser = getNoFunctionDeclaratorParser(); IASTNode alternateDeclarator = runSecondaryParser(secondaryParser); if(alternateDeclarator == null || alternateDeclarator instanceof IASTProblemDeclaration) return; astStack.pop(); + // TODO create node factory method for this IASTNode ambiguityNode = new CPPASTAmbiguousDeclarator(declarator, (IASTDeclarator)alternateDeclarator); setOffsetAndLength(ambiguityNode); @@ -1751,55 +1761,23 @@ public class CPPBuildASTParserAction extends BuildASTParserAction { * This method detects the incorrect parse, throws away the incorrect AST fragment, * and replaces it with the correct AST fragment. * - * Yes its a hack, but it took way less time to just do this than to refactor the grammar. - * - * TODO: there are more ambiguities with templates, maybe some double parsing is in order. + * Yes its a hack. */ public void consumeTemplateParamterDeclaration() { if(TRACE_ACTIONS) DebugUtil.printMethodTrace(); - List ruleTokens = parser.getRuleTokens(); + IParser typeParameterParser = getTemplateTypeParameterParser(); + IASTNode alternate = runSecondaryParser(typeParameterParser); - if(matchTokens(ruleTokens, tokenMap, TK_class)) { - astStack.pop(); - astStack.push(null); - consumeSimpleTypeTemplateParameter(false); - } - else if(matchTokens(ruleTokens, tokenMap, TK_class, TK_identifier)) { - astStack.pop(); - astStack.push(createName(ruleTokens.get(1))); - consumeSimpleTypeTemplateParameter(false); - } - else if(matchTokens(ruleTokens, tokenMap, TK_class, TK_Assign, TK_identifier)) { - astStack.pop(); - IASTName typeName = createName(ruleTokens.get(3)); - fixTemplateParameterDeclarationWithInitializer(null, typeName); - } - else if(matchTokens(ruleTokens, tokenMap, TK_class, TK_identifier, TK_Assign, TK_identifier)) { - astStack.pop(); - IASTName name = createName(ruleTokens.get(1)); - IASTName typeName = createName(ruleTokens.get(3)); - fixTemplateParameterDeclarationWithInitializer(name, typeName); - } + if(alternate == null || alternate instanceof IASTProblemDeclaration) + return; + + astStack.pop(); // throw away the incorrect AST + astStack.push(alternate); // replace it with the correct AST if(TRACE_AST_STACK) System.out.println(astStack); } - - - /** - * Manually create the AST for a template parameter with initializer. - */ - private void fixTemplateParameterDeclarationWithInitializer(IASTName name, IASTName typeName) { - astStack.push(name); - ICPPASTNamedTypeSpecifier namedTypeSpecifier = nodeFactory.newCPPNamedTypeSpecifier(typeName, false); - setOffsetAndLength(namedTypeSpecifier, offset(typeName), length(typeName)); - IASTDeclarator declarator = nodeFactory.newDeclarator(nodeFactory.newName()); - IASTTypeId typeId = nodeFactory.newTypeId(namedTypeSpecifier, declarator); - setOffsetAndLength(typeId, offset(typeName), length(typeName)); - astStack.push(typeId); - consumeSimpleTypeTemplateParameter(true); - } - + /** diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParser.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParser.java new file mode 100644 index 00000000000..01a20b60843 --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParser.java @@ -0,0 +1,2291 @@ +/******************************************************************************* +* 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.action.ITokenMap; +import org.eclipse.cdt.core.dom.lrparser.action.TokenMap; + +public class CPPTemplateTypeParameterParser extends PrsStream implements RuleAction , IParserActionTokenProvider, IParser +{ + private static ParseTable prs = new CPPTemplateTypeParameterParserprs(); + 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 CPPTemplateTypeParameterParser(LexStream lexStream) + { + super(lexStream); + + try + { + super.remapTerminalSymbols(orderedTerminalSymbols(), CPPTemplateTypeParameterParserprs.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(" " + CPPTemplateTypeParameterParsersym.orderedTerminalSymbols[id.intValue()]); + } + System.out.println(); + } + catch(UndefinedEofSymbolException e) + { + throw new Error(new UndefinedEofSymbolException + ("The Lexer does not implement the Eof symbol " + + CPPTemplateTypeParameterParsersym.orderedTerminalSymbols[CPPTemplateTypeParameterParserprs.EOFT_SYMBOL])); + } + } + + public String[] orderedTerminalSymbols() { return CPPTemplateTypeParameterParsersym.orderedTerminalSymbols; } + public String getTokenKindName(int kind) { return CPPTemplateTypeParameterParsersym.orderedTerminalSymbols[kind]; } + public int getEOFTokenKind() { return CPPTemplateTypeParameterParserprs.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 CPPTemplateTypeParameterParserprs.java with -BACKTRACK option")); + } + catch (BadParseSymFileException e) + { + throw new Error(new BadParseSymFileException("Bad Parser Symbol File -- CPPTemplateTypeParameterParsersym.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 CPPTemplateTypeParameterParser() { // 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(); +} + +public String[] getOrderedTerminalSymbols() { + return CPPTemplateTypeParameterParsersym.orderedTerminalSymbols; +} + +public String getName() { + return "CPPTemplateTypeParameterParser"; //$NON-NLS-1$ +} + + + +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, CPPTemplateTypeParameterParsersym.TK_EOF_TOKEN)); +} + +public CPPTemplateTypeParameterParser(String[] mapFrom) { // constructor + tokenMap = new TokenMap(CPPTemplateTypeParameterParsersym.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 ::= ~ identifier_token + // + case 37: { action.builder. + consumeDestructorName(); break; + } + + // + // Rule 38: unqualified_id_name ::= ~ template_id_name + // + case 38: { action.builder. + consumeDestructorNameTemplateId(); break; + } + + // + // Rule 39: identifier_name ::= identifier_token + // + case 39: { action.builder. + consumeIdentifierName(); break; + } + + // + // Rule 40: template_opt ::= template + // + case 40: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 41: template_opt ::= $Empty + // + case 41: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 42: dcolon_opt ::= :: + // + case 42: { action.builder. + consumeToken(); break; + } + + // + // Rule 43: dcolon_opt ::= $Empty + // + case 43: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 44: qualified_id_name ::= dcolon_opt nested_name_specifier template_opt unqualified_id_name + // + case 44: { action.builder. + consumeQualifiedId(true); break; + } + + // + // Rule 45: qualified_id_name ::= :: identifier_name + // + case 45: { action.builder. + consumeGlobalQualifiedId(); break; + } + + // + // Rule 46: qualified_id_name ::= :: operator_function_id_name + // + case 46: { action.builder. + consumeGlobalQualifiedId(); break; + } + + // + // Rule 47: qualified_id_name ::= :: template_id_name + // + case 47: { action.builder. + consumeGlobalQualifiedId(); break; + } + + // + // Rule 48: nested_name_specifier ::= class_or_namespace_name :: nested_name_specifier_with_template + // + case 48: { action.builder. + consumeNestedNameSpecifier(true); break; + } + + // + // Rule 49: nested_name_specifier ::= class_or_namespace_name :: + // + case 49: { action.builder. + consumeNestedNameSpecifier(false); break; + } + + // + // Rule 50: nested_name_specifier_with_template ::= class_or_namespace_name_with_template :: nested_name_specifier_with_template + // + case 50: { action.builder. + consumeNestedNameSpecifier(true); break; + } + + // + // Rule 51: nested_name_specifier_with_template ::= class_or_namespace_name_with_template :: + // + case 51: { action.builder. + consumeNestedNameSpecifier(false); break; + } + + // + // Rule 52: class_or_namespace_name_with_template ::= template_opt class_or_namespace_name + // + case 52: { action.builder. + consumeNameWithTemplateKeyword(); break; + } + + // + // Rule 54: nested_name_specifier_opt ::= $Empty + // + case 54: { 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: postfix_expression ::= typeid ( type_id ) + // + case 75: { action.builder. + consumeExpressionTypeId(ICPPASTTypeIdExpression.op_typeid); break; + } + + // + // Rule 76: pseudo_destructor_name ::= dcolon_opt nested_name_specifier_opt type_name :: destructor_type_name + // + case 76: { action.builder. + consumePsudoDestructorName(true); break; + } + + // + // Rule 77: pseudo_destructor_name ::= dcolon_opt nested_name_specifier template template_id_name :: destructor_type_name + // + case 77: { action.builder. + consumePsudoDestructorName(true); break; + } + + // + // Rule 78: pseudo_destructor_name ::= dcolon_opt nested_name_specifier_opt destructor_type_name + // + case 78: { action.builder. + consumePsudoDestructorName(false); break; + } + + // + // Rule 79: destructor_type_name ::= ~ identifier_token + // + case 79: { action.builder. + consumeDestructorName(); break; + } + + // + // Rule 80: destructor_type_name ::= ~ template_id_name + // + case 80: { action.builder. + consumeDestructorNameTemplateId(); break; + } + + // + // Rule 84: unary_expression ::= ++ cast_expression + // + case 84: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_prefixIncr); break; + } + + // + // Rule 85: unary_expression ::= -- cast_expression + // + case 85: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_prefixDecr); break; + } + + // + // Rule 86: unary_expression ::= & cast_expression + // + case 86: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_amper); break; + } + + // + // Rule 87: unary_expression ::= * cast_expression + // + case 87: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_star); break; + } + + // + // Rule 88: unary_expression ::= + cast_expression + // + case 88: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_plus); break; + } + + // + // Rule 89: unary_expression ::= - cast_expression + // + case 89: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_minus); break; + } + + // + // Rule 90: unary_expression ::= ~ cast_expression + // + case 90: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_tilde); break; + } + + // + // Rule 91: unary_expression ::= ! cast_expression + // + case 91: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_not); break; + } + + // + // Rule 92: unary_expression ::= sizeof unary_expression + // + case 92: { action.builder. + consumeExpressionUnaryOperator(IASTUnaryExpression.op_sizeof); break; + } + + // + // Rule 93: unary_expression ::= sizeof ( type_id ) + // + case 93: { action.builder. + consumeExpressionTypeId(ICPPASTTypeIdExpression.op_sizeof); break; + } + + // + // Rule 94: new_expression ::= dcolon_opt new new_placement_opt new_type_id new_array_expressions_opt new_initializer_opt + // + case 94: { action.builder. + consumeExpressionNew(true); break; + } + + // + // Rule 95: new_expression ::= dcolon_opt new new_placement_opt ( type_id ) new_array_expressions_opt new_initializer_opt + // + case 95: { action.builder. + consumeExpressionNew(false); break; + } + + // + // Rule 97: new_placement_opt ::= $Empty + // + case 97: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 98: new_type_id ::= type_specifier_seq + // + case 98: { action.builder. + consumeTypeId(false); break; + } + + // + // Rule 99: new_type_id ::= type_specifier_seq new_declarator + // + case 99: { action.builder. + consumeTypeId(true); break; + } + + // + // Rule 100: new_declarator ::= new_pointer_operators + // + case 100: { action.builder. + consumeNewDeclarator(); break; + } + + // + // Rule 109: new_initializer_opt ::= $Empty + // + case 109: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 110: delete_expression ::= dcolon_opt delete cast_expression + // + case 110: { action.builder. + consumeExpressionDelete(false); break; + } + + // + // Rule 111: delete_expression ::= dcolon_opt delete [ ] cast_expression + // + case 111: { action.builder. + consumeExpressionDelete(true); break; + } + + // + // Rule 113: cast_expression ::= ( type_id ) cast_expression + // + case 113: { action.builder. + consumeExpressionCast(ICPPASTCastExpression.op_cast); break; + } + + // + // Rule 115: pm_expression ::= pm_expression .* cast_expression + // + case 115: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_pmdot); break; + } + + // + // Rule 116: pm_expression ::= pm_expression ->* cast_expression + // + case 116: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_pmarrow); break; + } + + // + // Rule 118: multiplicative_expression ::= multiplicative_expression * pm_expression + // + case 118: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_multiply); break; + } + + // + // Rule 119: multiplicative_expression ::= multiplicative_expression / pm_expression + // + case 119: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_divide); break; + } + + // + // Rule 120: multiplicative_expression ::= multiplicative_expression % pm_expression + // + case 120: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_modulo); break; + } + + // + // Rule 122: additive_expression ::= additive_expression + multiplicative_expression + // + case 122: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_plus); break; + } + + // + // Rule 123: additive_expression ::= additive_expression - multiplicative_expression + // + case 123: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_minus); break; + } + + // + // Rule 125: shift_expression ::= shift_expression << additive_expression + // + case 125: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftLeft); break; + } + + // + // Rule 126: shift_expression ::= shift_expression >> additive_expression + // + case 126: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftRight); break; + } + + // + // Rule 128: relational_expression ::= relational_expression < shift_expression + // + case 128: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessThan); break; + } + + // + // Rule 129: relational_expression ::= relational_expression > shift_expression + // + case 129: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterThan); break; + } + + // + // Rule 130: relational_expression ::= relational_expression <= shift_expression + // + case 130: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessEqual); break; + } + + // + // Rule 131: relational_expression ::= relational_expression >= shift_expression + // + case 131: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterEqual); break; + } + + // + // Rule 133: equality_expression ::= equality_expression == relational_expression + // + case 133: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_equals); break; + } + + // + // Rule 134: equality_expression ::= equality_expression != relational_expression + // + case 134: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_notequals); break; + } + + // + // Rule 136: and_expression ::= and_expression & equality_expression + // + case 136: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAnd); break; + } + + // + // Rule 138: exclusive_or_expression ::= exclusive_or_expression ^ and_expression + // + case 138: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXor); break; + } + + // + // Rule 140: inclusive_or_expression ::= inclusive_or_expression | exclusive_or_expression + // + case 140: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOr); break; + } + + // + // Rule 142: logical_and_expression ::= logical_and_expression && inclusive_or_expression + // + case 142: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalAnd); break; + } + + // + // Rule 144: logical_or_expression ::= logical_or_expression || logical_and_expression + // + case 144: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalOr); break; + } + + // + // Rule 146: conditional_expression ::= logical_or_expression ? expression : assignment_expression + // + case 146: { action.builder. + consumeExpressionConditional(); break; + } + + // + // Rule 147: throw_expression ::= throw + // + case 147: { action.builder. + consumeExpressionThrow(false); break; + } + + // + // Rule 148: throw_expression ::= throw assignment_expression + // + case 148: { action.builder. + consumeExpressionThrow(true); break; + } + + // + // Rule 151: assignment_expression ::= logical_or_expression = assignment_expression + // + case 151: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_assign); break; + } + + // + // Rule 152: assignment_expression ::= logical_or_expression *= assignment_expression + // + case 152: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_multiplyAssign); break; + } + + // + // Rule 153: assignment_expression ::= logical_or_expression /= assignment_expression + // + case 153: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_divideAssign); break; + } + + // + // Rule 154: assignment_expression ::= logical_or_expression %= assignment_expression + // + case 154: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_moduloAssign); break; + } + + // + // Rule 155: assignment_expression ::= logical_or_expression += assignment_expression + // + case 155: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_plusAssign); break; + } + + // + // Rule 156: assignment_expression ::= logical_or_expression -= assignment_expression + // + case 156: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_minusAssign); break; + } + + // + // Rule 157: assignment_expression ::= logical_or_expression >>= assignment_expression + // + case 157: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftRightAssign); break; + } + + // + // Rule 158: assignment_expression ::= logical_or_expression <<= assignment_expression + // + case 158: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftLeftAssign); break; + } + + // + // Rule 159: assignment_expression ::= logical_or_expression &= assignment_expression + // + case 159: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAndAssign); break; + } + + // + // Rule 160: assignment_expression ::= logical_or_expression ^= assignment_expression + // + case 160: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXorAssign); break; + } + + // + // Rule 161: assignment_expression ::= logical_or_expression |= assignment_expression + // + case 161: { action.builder. + consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOrAssign); break; + } + + // + // Rule 163: expression_list ::= expression_list_actual + // + case 163: { action.builder. + consumeExpressionList(); break; + } + + // + // Rule 167: expression_list_opt ::= $Empty + // + case 167: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 169: expression_opt ::= $Empty + // + case 169: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 172: constant_expression_opt ::= $Empty + // + case 172: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 181: statement ::= ERROR_TOKEN + // + case 181: { action.builder. + consumeStatementProblem(); break; + } + + // + // Rule 182: labeled_statement ::= identifier : statement + // + case 182: { action.builder. + consumeStatementLabeled(); break; + } + + // + // Rule 183: labeled_statement ::= case constant_expression : + // + case 183: { action.builder. + consumeStatementCase(); break; + } + + // + // Rule 184: labeled_statement ::= default : + // + case 184: { action.builder. + consumeStatementDefault(); break; + } + + // + // Rule 185: expression_statement ::= expression ; + // + case 185: { action.builder. + consumeStatementExpression(); break; + } + + // + // Rule 186: expression_statement ::= ; + // + case 186: { action.builder. + consumeStatementNull(); break; + } + + // + // Rule 187: compound_statement ::= { statement_seq } + // + case 187: { action.builder. + consumeStatementCompoundStatement(true); break; + } + + // + // Rule 188: compound_statement ::= { } + // + case 188: { action.builder. + consumeStatementCompoundStatement(false); break; + } + + // + // Rule 191: selection_statement ::= if ( condition ) statement + // + case 191: { action.builder. + consumeStatementIf(false); break; + } + + // + // Rule 192: selection_statement ::= if ( condition ) statement else statement + // + case 192: { action.builder. + consumeStatementIf(true); break; + } + + // + // Rule 193: selection_statement ::= switch ( condition ) statement + // + case 193: { action.builder. + consumeStatementSwitch(); break; + } + + // + // Rule 195: condition ::= type_specifier_seq declarator = assignment_expression + // + case 195: { action.builder. + consumeConditionDeclaration(); break; + } + + // + // Rule 197: condition_opt ::= $Empty + // + case 197: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 198: iteration_statement ::= while ( condition ) statement + // + case 198: { action.builder. + consumeStatementWhileLoop(); break; + } + + // + // Rule 199: iteration_statement ::= do statement while ( expression ) ; + // + case 199: { action.builder. + consumeStatementDoLoop(); break; + } + + // + // Rule 200: iteration_statement ::= for ( for_init_statement condition_opt ; expression_opt ) statement + // + case 200: { action.builder. + consumeStatementForLoop(); break; + } + + // + // Rule 202: for_init_statement ::= simple_declaration_with_declspec + // + case 202: { action.builder. + consumeStatementDeclaration(); break; + } + + // + // Rule 203: jump_statement ::= break ; + // + case 203: { action.builder. + consumeStatementBreak(); break; + } + + // + // Rule 204: jump_statement ::= continue ; + // + case 204: { action.builder. + consumeStatementContinue(); break; + } + + // + // Rule 205: jump_statement ::= return expression ; + // + case 205: { action.builder. + consumeStatementReturn(true); break; + } + + // + // Rule 206: jump_statement ::= return ; + // + case 206: { action.builder. + consumeStatementReturn(false); break; + } + + // + // Rule 207: jump_statement ::= goto identifier_token ; + // + case 207: { action.builder. + consumeStatementGoto(); break; + } + + // + // Rule 208: declaration_statement ::= block_declaration + // + case 208: { action.builder. + consumeStatementDeclarationWithDisambiguation(); break; + } + + // + // Rule 209: declaration_statement ::= function_definition + // + case 209: { action.builder. + consumeStatementDeclaration(); break; + } + + // + // Rule 226: simple_declaration ::= declaration_specifiers_opt init_declarator_list_opt ; + // + case 226: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 227: simple_declaration_with_declspec ::= declaration_specifiers init_declarator_list_opt ; + // + case 227: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 228: declaration_specifiers ::= simple_declaration_specifiers + // + case 228: { action.builder. + consumeDeclarationSpecifiersSimple(); break; + } + + // + // Rule 229: declaration_specifiers ::= class_declaration_specifiers + // + case 229: { action.builder. + consumeDeclarationSpecifiersComposite(); break; + } + + // + // Rule 230: declaration_specifiers ::= elaborated_declaration_specifiers + // + case 230: { action.builder. + consumeDeclarationSpecifiersComposite(); break; + } + + // + // Rule 231: declaration_specifiers ::= enum_declaration_specifiers + // + case 231: { action.builder. + consumeDeclarationSpecifiersComposite(); break; + } + + // + // Rule 232: declaration_specifiers ::= type_name_declaration_specifiers + // + case 232: { action.builder. + consumeDeclarationSpecifiersTypeName(); break; + } + + // + // Rule 233: declaration_specifiers_opt ::= $Empty + // + case 233: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 238: no_type_declaration_specifier ::= friend + // + case 238: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 239: no_type_declaration_specifier ::= typedef + // + case 239: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 259: storage_class_specifier ::= auto + // + case 259: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 260: storage_class_specifier ::= register + // + case 260: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 261: storage_class_specifier ::= static + // + case 261: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 262: storage_class_specifier ::= extern + // + case 262: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 263: storage_class_specifier ::= mutable + // + case 263: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 264: function_specifier ::= inline + // + case 264: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 265: function_specifier ::= virtual + // + case 265: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 266: function_specifier ::= explicit + // + case 266: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 267: simple_type_specifier ::= char + // + case 267: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 268: simple_type_specifier ::= wchar_t + // + case 268: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 269: simple_type_specifier ::= bool + // + case 269: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 270: simple_type_specifier ::= short + // + case 270: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 271: simple_type_specifier ::= int + // + case 271: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 272: simple_type_specifier ::= long + // + case 272: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 273: simple_type_specifier ::= signed + // + case 273: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 274: simple_type_specifier ::= unsigned + // + case 274: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 275: simple_type_specifier ::= float + // + case 275: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 276: simple_type_specifier ::= double + // + case 276: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 277: simple_type_specifier ::= void + // + case 277: { action.builder. + consumeDeclSpecToken(); break; + } + + // + // Rule 280: type_name_specifier ::= dcolon_opt nested_name_specifier_opt type_name + // + case 280: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 281: type_name_specifier ::= dcolon_opt nested_name_specifier template template_id_name + // + case 281: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 282: type_name_specifier ::= typename dcolon_opt nested_name_specifier identifier_name + // + case 282: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 283: type_name_specifier ::= typename dcolon_opt nested_name_specifier template_opt template_id_name + // + case 283: { action.builder. + consumeQualifiedId(true); break; + } + + // + // Rule 285: elaborated_type_specifier ::= class_keyword dcolon_opt nested_name_specifier_opt identifier_name + // + case 285: { action.builder. + consumeTypeSpecifierElaborated(false); break; + } + + // + // Rule 286: elaborated_type_specifier ::= class_keyword dcolon_opt nested_name_specifier_opt template_opt template_id_name + // + case 286: { action.builder. + consumeTypeSpecifierElaborated(true); break; + } + + // + // Rule 287: elaborated_type_specifier ::= enum dcolon_opt nested_name_specifier_opt identifier_name + // + case 287: { action.builder. + consumeTypeSpecifierElaborated(false); break; + } + + // + // Rule 288: enum_specifier ::= enum { enumerator_list_opt } + // + case 288: { action.builder. + consumeTypeSpecifierEnumeration(false); break; + } + + // + // Rule 289: enum_specifier ::= enum identifier_token { enumerator_list_opt } + // + case 289: { action.builder. + consumeTypeSpecifierEnumeration(true); break; + } + + // + // Rule 294: enumerator_definition ::= identifier_token + // + case 294: { action.builder. + consumeEnumerator(false); break; + } + + // + // Rule 295: enumerator_definition ::= identifier_token = constant_expression + // + case 295: { 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 304: namespace_alias_definition ::= namespace identifier_token = dcolon_opt nested_name_specifier_opt namespace_name ; + // + case 304: { action.builder. + consumeNamespaceAliasDefinition(); break; + } + + // + // Rule 305: using_declaration ::= using typename_opt dcolon_opt nested_name_specifier_opt unqualified_id_name ; + // + case 305: { action.builder. + consumeUsingDeclaration(); break; + } + + // + // Rule 306: typename_opt ::= typename + // + case 306: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 307: typename_opt ::= $Empty + // + case 307: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 308: using_directive ::= using namespace dcolon_opt nested_name_specifier_opt namespace_name ; + // + case 308: { action.builder. + consumeUsingDirective(); break; + } + + // + // Rule 309: asm_definition ::= asm ( stringlit ) ; + // + case 309: { action.builder. + consumeDeclarationASM(); break; + } + + // + // Rule 310: linkage_specification ::= extern stringlit { declaration_seq_opt } + // + case 310: { action.builder. + consumeLinkageSpecification(); break; + } + + // + // Rule 311: linkage_specification ::= extern stringlit declaration + // + case 311: { action.builder. + consumeLinkageSpecification(); break; + } + + // + // Rule 316: init_declarator_complete ::= init_declarator + // + case 316: { action.builder. + consumeInitDeclaratorComplete(); 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 ::= nested_name_specifier template_opt unqualified_id_name + // + case 344: { action.builder. + consumeQualifiedId(true); 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: basic_direct_abstract_declarator ::= ( ) + // + case 355: { action.builder. + consumeAbstractDeclaratorEmpty(); break; + } + + // + // Rule 356: array_direct_abstract_declarator ::= array_modifier + // + case 356: { action.builder. + consumeDirectDeclaratorArrayDeclarator(false); break; + } + + // + // Rule 357: array_direct_abstract_declarator ::= array_direct_abstract_declarator array_modifier + // + case 357: { action.builder. + consumeDirectDeclaratorArrayDeclarator(true); break; + } + + // + // Rule 358: array_direct_abstract_declarator ::= basic_direct_abstract_declarator array_modifier + // + case 358: { action.builder. + consumeDirectDeclaratorArrayDeclarator(true); break; + } + + // + // Rule 359: function_direct_abstract_declarator ::= basic_direct_abstract_declarator ( parameter_declaration_clause ) cv_qualifier_seq_opt exception_specification_opt + // + case 359: { action.builder. + consumeDirectDeclaratorFunctionDeclarator(true); break; + } + + // + // Rule 360: function_direct_abstract_declarator ::= ( parameter_declaration_clause ) cv_qualifier_seq_opt exception_specification_opt + // + case 360: { action.builder. + consumeDirectDeclaratorFunctionDeclarator(false); break; + } + + // + // Rule 361: parameter_declaration_clause ::= parameter_declaration_list_opt ... + // + case 361: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 362: parameter_declaration_clause ::= parameter_declaration_list_opt + // + case 362: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 363: parameter_declaration_clause ::= parameter_declaration_list , ... + // + case 363: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 369: abstract_declarator_opt ::= $Empty + // + case 369: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 370: parameter_declaration ::= declaration_specifiers parameter_init_declarator + // + case 370: { action.builder. + consumeParameterDeclaration(); break; + } + + // + // Rule 371: parameter_declaration ::= declaration_specifiers + // + case 371: { action.builder. + consumeParameterDeclarationWithoutDeclarator(); break; + } + + // + // Rule 373: parameter_init_declarator ::= declarator = parameter_initializer + // + case 373: { action.builder. + consumeDeclaratorWithInitializer(true); break; + } + + // + // Rule 375: parameter_init_declarator ::= abstract_declarator = parameter_initializer + // + case 375: { action.builder. + consumeDeclaratorWithInitializer(true); break; + } + + // + // Rule 376: parameter_init_declarator ::= = parameter_initializer + // + case 376: { action.builder. + consumeDeclaratorWithInitializer(false); break; + } + + // + // Rule 377: parameter_initializer ::= assignment_expression + // + case 377: { action.builder. + consumeInitializer(); break; + } + + // + // Rule 378: function_definition ::= declaration_specifiers_opt function_declarator ctor_initializer_list_opt function_body + // + case 378: { action.builder. + consumeFunctionDefinition(false); break; + } + + // + // Rule 379: function_definition ::= declaration_specifiers_opt function_declarator try ctor_initializer_list_opt function_body handler_seq + // + case 379: { action.builder. + consumeFunctionDefinition(true); break; + } + + // + // Rule 382: initializer ::= ( expression_list ) + // + case 382: { action.builder. + consumeInitializerConstructor(); break; + } + + // + // Rule 383: initializer_clause ::= assignment_expression + // + case 383: { action.builder. + consumeInitializer(); break; + } + + // + // Rule 384: initializer_clause ::= { initializer_list , } + // + case 384: { action.builder. + consumeInitializerList(); break; + } + + // + // Rule 385: initializer_clause ::= { initializer_list } + // + case 385: { action.builder. + consumeInitializerList(); break; + } + + // + // Rule 386: initializer_clause ::= { } + // + case 386: { action.builder. + consumeInitializerList(); break; + } + + // + // Rule 391: class_specifier ::= class_head { member_declaration_list_opt } + // + case 391: { action.builder. + consumeClassSpecifier(); break; + } + + // + // Rule 392: class_head ::= class_keyword identifier_name_opt base_clause_opt + // + case 392: { action.builder. + consumeClassHead(false); break; + } + + // + // Rule 393: class_head ::= class_keyword template_id_name base_clause_opt + // + case 393: { action.builder. + consumeClassHead(false); break; + } + + // + // Rule 394: class_head ::= class_keyword nested_name_specifier identifier_name base_clause_opt + // + case 394: { action.builder. + consumeClassHead(true); break; + } + + // + // Rule 395: class_head ::= class_keyword nested_name_specifier template_id_name base_clause_opt + // + case 395: { action.builder. + consumeClassHead(true); break; + } + + // + // Rule 397: identifier_name_opt ::= $Empty + // + case 397: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 401: visibility_label ::= access_specifier_keyword : + // + case 401: { action.builder. + consumeVisibilityLabel(); break; + } + + // + // Rule 402: member_declaration ::= declaration_specifiers_opt member_declarator_list ; + // + case 402: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 403: member_declaration ::= declaration_specifiers_opt ; + // + case 403: { action.builder. + consumeDeclarationSimple(false); break; + } + + // + // Rule 406: member_declaration ::= dcolon_opt nested_name_specifier template_opt unqualified_id_name ; + // + case 406: { action.builder. + consumeMemberDeclarationQualifiedId(); break; + } + + // + // Rule 411: member_declaration ::= ERROR_TOKEN + // + case 411: { action.builder. + consumeDeclarationProblem(); break; + } + + // + // Rule 419: member_declarator ::= declarator constant_initializer + // + case 419: { action.builder. + consumeMemberDeclaratorWithInitializer(); break; + } + + // + // Rule 420: member_declarator ::= bit_field_declarator : constant_expression + // + case 420: { action.builder. + consumeBitField(true); break; + } + + // + // Rule 421: member_declarator ::= : constant_expression + // + case 421: { action.builder. + consumeBitField(false); break; + } + + // + // Rule 422: bit_field_declarator ::= identifier_name + // + case 422: { action.builder. + consumeDirectDeclaratorIdentifier(); break; + } + + // + // Rule 423: constant_initializer ::= = constant_expression + // + case 423: { action.builder. + consumeInitializer(); break; + } + + // + // Rule 429: base_specifier ::= dcolon_opt nested_name_specifier_opt class_name + // + case 429: { action.builder. + consumeBaseSpecifier(false, false); break; + } + + // + // Rule 430: base_specifier ::= virtual access_specifier_keyword_opt dcolon_opt nested_name_specifier_opt class_name + // + case 430: { action.builder. + consumeBaseSpecifier(true, true); break; + } + + // + // Rule 431: base_specifier ::= access_specifier_keyword virtual dcolon_opt nested_name_specifier_opt class_name + // + case 431: { action.builder. + consumeBaseSpecifier(true, true); break; + } + + // + // Rule 432: base_specifier ::= access_specifier_keyword dcolon_opt nested_name_specifier_opt class_name + // + case 432: { action.builder. + consumeBaseSpecifier(true, false); break; + } + + // + // Rule 433: access_specifier_keyword ::= private + // + case 433: { action.builder. + consumeAccessKeywordToken(); break; + } + + // + // Rule 434: access_specifier_keyword ::= protected + // + case 434: { action.builder. + consumeAccessKeywordToken(); break; + } + + // + // Rule 435: access_specifier_keyword ::= public + // + case 435: { action.builder. + consumeAccessKeywordToken(); break; + } + + // + // Rule 437: access_specifier_keyword_opt ::= $Empty + // + case 437: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 439: conversion_function_id_name ::= conversion_function_id < template_argument_list_opt > + // + case 439: { action.builder. + consumeTemplateId(); break; + } + + // + // Rule 440: conversion_function_id ::= operator conversion_type_id + // + case 440: { action.builder. + consumeConversionName(); break; + } + + // + // Rule 441: conversion_type_id ::= type_specifier_seq conversion_declarator + // + case 441: { action.builder. + consumeTypeId(true); break; + } + + // + // Rule 442: conversion_type_id ::= type_specifier_seq + // + case 442: { action.builder. + consumeTypeId(false); break; + } + + // + // Rule 443: conversion_declarator ::= ptr_operator_seq + // + case 443: { action.builder. + consumeDeclaratorWithPointer(false); break; + } + + // + // Rule 449: mem_initializer ::= mem_initializer_name ( expression_list_opt ) + // + case 449: { action.builder. + consumeConstructorChainInitializer(); break; + } + + // + // Rule 450: mem_initializer_name ::= dcolon_opt nested_name_specifier_opt class_name + // + case 450: { action.builder. + consumeQualifiedId(false); break; + } + + // + // Rule 453: operator_function_id_name ::= operator_id_name < template_argument_list_opt > + // + case 453: { action.builder. + consumeTemplateId(); break; + } + + // + // Rule 454: operator_id_name ::= operator overloadable_operator + // + case 454: { action.builder. + consumeOperatorName(); break; + } + + // + // Rule 497: template_declaration ::= export_opt template < template_parameter_list > declaration + // + case 497: { action.builder. + consumeTemplateDeclaration(); break; + } + + // + // Rule 498: export_opt ::= export + // + case 498: { action.builder. + consumePlaceHolder(); break; + } + + // + // Rule 499: export_opt ::= $Empty + // + case 499: { action.builder. + consumeEmpty(); break; + } + + // + // Rule 503: template_parameter ::= parameter_declaration + // + case 503: { action.builder. + consumeTemplateParamterDeclaration(); break; + } + + // + // Rule 504: type_parameter ::= class identifier_name_opt + // + case 504: { action.builder. + consumeSimpleTypeTemplateParameter(false); break; + } + + // + // Rule 505: type_parameter ::= class identifier_name_opt = type_id + // + case 505: { action.builder. + consumeSimpleTypeTemplateParameter(true); break; + } + + // + // Rule 506: type_parameter ::= typename identifier_name_opt + // + case 506: { action.builder. + consumeSimpleTypeTemplateParameter(false); break; + } + + // + // Rule 507: type_parameter ::= typename identifier_name_opt = type_id + // + case 507: { action.builder. + consumeSimpleTypeTemplateParameter(true); break; + } + + // + // Rule 508: type_parameter ::= template < template_parameter_list > class identifier_name_opt + // + case 508: { action.builder. + consumeTemplatedTypeTemplateParameter(false); break; + } + + // + // Rule 509: type_parameter ::= template < template_parameter_list > class identifier_name_opt = id_expression + // + case 509: { action.builder. + consumeTemplatedTypeTemplateParameter(true); break; + } + + // + // Rule 510: template_id_name ::= identifier_name < template_argument_list_opt > + // + case 510: { action.builder. + consumeTemplateId(); break; + } + + // + // Rule 518: explicit_instantiation ::= template declaration + // + case 518: { action.builder. + consumeTemplateExplicitInstantiation(); break; + } + + // + // Rule 519: explicit_specialization ::= template < > declaration + // + case 519: { action.builder. + consumeTemplateExplicitSpecialization(); break; + } + + // + // Rule 520: try_block ::= try compound_statement handler_seq + // + case 520: { action.builder. + consumeStatementTryBlock(); break; + } + + // + // Rule 523: handler ::= catch ( exception_declaration ) compound_statement + // + case 523: { action.builder. + consumeStatementCatchHandler(false); break; + } + + // + // Rule 524: handler ::= catch ( ... ) compound_statement + // + case 524: { action.builder. + consumeStatementCatchHandler(true); break; + } + + // + // Rule 525: exception_declaration ::= type_specifier_seq declarator + // + case 525: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 526: exception_declaration ::= type_specifier_seq abstract_declarator + // + case 526: { action.builder. + consumeDeclarationSimple(true); break; + } + + // + // Rule 527: exception_declaration ::= type_specifier_seq + // + case 527: { action.builder. + consumeDeclarationSimple(false); break; + } + + // + // Rule 535: type_parameter_start ::= ERROR_TOKEN + // + case 535: { action.builder. + consumeDeclarationProblem(); break; + } + + + default: + break; + } + return; + } +} + diff --git a/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParserprs.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParserprs.java new file mode 100644 index 00000000000..ce4349f1f33 --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParserprs.java @@ -0,0 +1,2567 @@ +/******************************************************************************* +* 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 CPPTemplateTypeParameterParserprs implements lpg.lpgjavaruntime.ParseTable, CPPTemplateTypeParameterParsersym { + + 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,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,2,1,1, + 0,1,0,4,2,2,2,3,2,3, + 2,2,1,0,1,1,4,4,4,8, + 8,3,3,4,4,3,3,2,2,7, + 7,7,7,4,4,5,6,3,2,2, + 1,1,1,2,2,2,2,2,2,2, + 2,2,4,7,9,3,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,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,1,0,5,7,8, + 1,1,2,2,3,2,3,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,2,1,0,4,4,2,2,2, + 2,2,0,1,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,3, + 4,4,5,2,4,5,4,5,6,1, + 3,1,0,1,3,1,1,1,1,1, + 6,6,5,7,6,1,0,6,5,6, + 4,1,3,1,0,1,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,4,1,2,1,1,2,3, + 1,1,1,3,2,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,1,2,1,0,1,3,1,2,3, + 2,1,2,2,1,0,1,3,3,5, + 5,4,1,1,1,1,0,1,5,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,3,1,0,1,1,1,2,4,4, + 1,2,5,5,3,3,1,4,3,1, + 0,1,3,1,1,-131,0,0,0,-423, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-191,0, + 0,0,0,0,0,0,-83,0,-54,0, + 0,0,0,0,-2,0,0,-102,0,0, + 0,-87,0,0,0,0,0,0,-196,0, + 0,-157,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-127,0,0,0,0,0, + 0,0,-3,0,0,0,-380,0,0,-7, + 0,0,0,0,0,0,0,-261,0,0, + 0,-175,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-304,-219,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,-177,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-8,0,0,0,0, + 0,-44,0,0,0,0,0,0,-56,0, + 0,0,-6,-325,0,0,0,0,0,-178, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -12,0,-16,0,0,0,0,0,-19,0, + 0,0,0,-30,0,0,0,-283,0,0, + 0,0,0,0,-106,0,0,0,0,-92, + -137,0,0,0,-20,0,0,0,0,0, + 0,0,0,0,-1,0,-4,0,0,-27, + -182,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-28,0,0,0,0,0,-40,0,-33, + 0,0,0,0,0,-5,0,0,0,0, + 0,0,0,-133,0,-298,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-31,0,-85,0, + 0,0,0,-217,0,0,0,0,0,-198, + 0,0,0,-214,0,0,0,0,0,0, + -271,0,0,0,0,0,0,-206,-307,0, + 0,0,0,-36,0,0,0,0,0,0, + 0,0,-489,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-176,0,0,0,0, + 0,0,0,0,0,0,0,-460,0,-368, + 0,0,0,-48,0,0,-374,0,0,0, + -475,-338,-512,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-22,0,0,0,0, + 0,0,0,0,0,-218,0,0,0,0, + 0,-43,0,0,-60,0,0,0,-23,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-49,0,0, + -18,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-378,0,0,0,0,0,-253,0,0, + 0,0,0,-46,0,0,0,-258,0,-290, + -86,0,0,0,0,-81,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-259,0, + 0,0,0,0,0,0,0,0,-273,0, + 0,0,0,-89,0,0,0,0,0,-248, + 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, + -93,0,0,0,0,-24,0,0,-208,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-50, + 0,0,0,0,0,-51,0,-25,0,0, + -440,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-410,0,0,0,0,-52,0, + 0,0,-21,0,0,0,-363,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-53,0,-55,0,0,0,-276, + 0,0,0,-310,-138,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-99,0, + -193,-199,0,0,0,-379,0,0,0,0, + 0,0,0,0,0,0,-333,0,0,0, + -68,-396,0,0,0,0,0,0,-265,0, + -69,-79,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-345,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-315,0, + -70,0,0,-160,0,0,0,-71,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-72,0,0,0, + 0,0,0,0,-73,0,-90,0,0,0, + 0,0,0,0,0,-161,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-134,0, + 0,0,0,0,0,0,0,0,-98,0, + 0,0,0,0,-74,0,0,-162,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-75,0, + 0,0,0,0,-464,0,-375,0,0,-163, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-286,0,0,0,0,0,0,0, + -76,0,-104,0,0,0,0,-77,0,0, + 0,-164,0,0,0,-78,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-293,0,0,0,0,0, + 0,0,-80,0,-105,0,0,0,0,-84, + -88,0,0,-165,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,-94,0,-107,0,0,0, + 0,-95,-96,0,0,-166,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-97,0,-109,0, + 0,0,0,-110,-111,0,0,-167,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -116,0,0,0,0,0,0,0,-119,0, + -112,0,0,0,0,-128,-136,0,0,-168, + 0,0,0,-184,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, + -186,0,-189,0,0,0,0,-202,-203,0, + 0,-169,0,0,0,-204,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-205,0,0,0,0,0, + 0,0,-210,0,-190,0,0,0,0,-211, + -212,0,0,-170,0,0,0,-213,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,-227,0,-194,0,0,0, + 0,-228,-229,0,0,-284,0,0,0,-230, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-231,0, + 0,0,0,0,0,0,-232,0,-255,0, + 0,0,0,-233,-234,0,0,-294,0,0, + 0,-235,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -236,0,0,0,0,0,0,0,-237,0, + -326,0,0,0,-340,0,-449,0,0,-516, + 0,0,0,-395,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-238,0,0,0,0,0,0,0, + -239,0,0,0,0,0,-192,0,0,0, + 0,-314,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-240,0,0,0,0,0, + 0,0,-241,0,-242,0,0,0,-343,0, + 0,0,-243,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-244, + 0,0,0,0,0,-221,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-247, + -383,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-249,0,-250,0,0,0,-384,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -251,0,0,0,0,0,0,0,-252,0, + -254,0,0,0,-223,0,0,0,-262,0, + 0,0,0,0,0,0,0,-180,-263,-393, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-264,0,0,0,0,0,0,0, + -274,0,-275,0,0,0,-452,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-278, + 0,0,0,0,0,0,0,-279,0,0, + 0,0,0,-377,0,0,0,-511,-280,0, + 0,0,0,0,-350,0,0,0,-172,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-281,0,0,0,0,0,0,0,-257, + 0,0,0,0,-369,-159,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-302,0, + 0,0,0,0,0,0,-303,0,-158,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-308,0,0,0,0,0,0,-154,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-408,0,0,0,0,0,-155,0,0, + 0,-309,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -313,0,0,0,0,-156,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-320,0, + 0,0,0,-148,0,0,0,-321,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-327,0,0,0, + -149,0,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,-150,0,0, + 0,-443,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -342,0,0,0,-151,0,0,0,-344,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-360,0,0, + 0,-13,0,0,0,0,-364,0,0,0, + 0,0,-197,0,0,0,-14,0,0,0, + -181,0,-365,-297,-465,-152,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,-491,0,0,0,0,-289,0,0,0, + 0,-101,-100,0,0,0,0,-370,0,0, + -129,0,0,-373,0,0,0,0,-322,0, + 0,0,-390,0,0,-518,-311,0,0,0, + -513,0,0,0,0,0,0,0,0,-130, + -422,0,0,0,0,0,0,-461,-183,-482, + -47,0,-409,0,0,-398,0,0,0,-32, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-9,0,0,-391,0,0,0,-401,0, + 0,0,0,0,0,-442,-403,-404,0,0, + 0,0,0,-405,0,0,0,0,0,0, + 0,0,0,-282,0,0,0,0,-216,0, + 0,-400,0,0,0,0,0,0,0,0, + 0,0,-407,0,0,0,0,0,-45,0, + 0,0,0,0,0,0,0,-153,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-411,0,0,0,-426,-268,-35,0,0, + 0,-126,0,-91,0,0,-29,0,0,0, + 0,-413,0,-424,-108,0,0,0,0,-451, + -439,0,0,-299,0,0,0,-495,-295,0, + 0,0,0,0,0,-115,0,0,0,-453, + 0,0,0,0,0,0,0,0,-296,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-139,0,-433,0,0,0,0, + 0,-454,0,0,-200,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-348, + -38,0,0,0,0,0,0,-201,0,0, + 0,0,-438,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-385,0, + 0,0,0,0,0,0,-359,0,0,-455, + -456,0,0,-15,0,0,0,0,-300,0, + 0,0,0,0,0,0,-457,0,0,0, + 0,0,0,0,0,0,-266,0,0,0, + 0,0,0,0,0,0,0,-349,0,0, + -269,0,0,0,-445,0,-118,-117,0,-207, + 0,0,0,0,0,0,0,0,0,0, + -225,0,-305,0,0,-514,0,0,0,0, + 0,0,0,-323,0,0,0,0,0,0, + 0,-173,0,0,0,0,-37,-459,-499,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-220,0,0,-476,0,0,0, + 0,0,-446,0,-355,0,0,0,0,-414, + 0,0,0,-477,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,-462, + -330,0,0,0,0,-478,0,0,-39,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-113,0,0,0,-26, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-450,-140,-483,0,0,0,0,0, + 0,-487,-497,0,0,0,0,0,0,0, + 0,-505,0,0,-224,0,0,0,0,0, + -171,0,0,0,0,0,0,0,0,-174, + 0,0,0,0,-245,-517,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-332,0,0,-335,0,0, + -337,0,0,0,0,0,0,0,0,0, + 0,0,0,-143,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-463,0,-144,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,-306,0,0,0,0,0,0, + 0,0,0,0,0,-316,0,0,0,0, + -58,0,0,0,-246,0,-434,0,0,-10, + -458,0,-468,0,0,-471,-291,-34,-328,0, + 0,0,-324,-41,-329,0,0,0,0,-472, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -351,-352,0,0,0,0,0,0,0,0, + 0,0,0,0,-353,-42,0,0,0,0, + 0,-479,-195,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-416,-188,0,0,0,0,0,-103,0, + 0,0,0,-354,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-317,0,-346,-270,0,-504, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-356,0,0,0, + 0,0,0,0,0,0,0,0,0,-358, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-506,0,0, + 0,0,0,0,0,0,-272,0,0,0, + -448,0,0,0,0,0,0,0,0,0, + 0,-215,0,0,0,-292,0,0,0,-376, + 0,0,0,0,0,0,0,-331,0,0, + 0,0,0,0,0,0,0,0,0,0, + -366,0,0,-318,0,-510,0,0,0,0, + 0,0,0,0,0,0,-367,0,0,0, + 0,0,0,0,0,0,0,0,0,-473, + 0,0,0,0,-179,0,0,-399,0,0, + -406,0,0,0,0,0,-388,0,0,0, + 0,0,0,0,0,0,0,0,0,-515, + 0,0,0,0,0,0,0,0,0,0, + -256,0,0,-389,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-417,0, + -521,0,0,0,0,-415,0,0,0,-357, + 0,0,0,-11,0,0,0,0,0,0, + -392,0,0,0,0,0,0,0,-394,0, + -402,0,0,0,0,0,0,0,0,0, + 0,-418,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-425,0,0,-524,0, + 0,0,0,0,0,0,0,0,0,-121, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-222,0,0,0,0,0,0,-421, + 0,0,0,0,-427,-428,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,-362,0,0,0,-429,0,0,0,0, + 0,-432,0,0,0,0,0,-470,0,0, + 0,0,0,0,0,0,0,0,0,-145, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-146,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-147,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-334,-500, + 0,0,0,-474,-372,0,0,0,0,-437, + 0,0,0,0,0,-485,0,-61,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-466,0,0,0,0,0,0,0, + 0,-371,0,0,-17,0,-486,0,0,-469, + 0,0,0,0,0,0,-488,0,-490,0, + 0,0,-120,0,0,-507,0,0,-492,0, + 0,0,0,0,0,0,-312,0,0,0, + 0,-494,0,-519,0,0,0,0,0,0, + 0,0,0,0,-420,0,0,-341,0,0, + -496,0,0,0,0,0,0,0,0,0, + 0,-122,0,0,0,0,0,0,0,-498, + 0,0,0,0,0,0,0,0,0,-336, + 0,0,0,-501,0,0,0,0,-502,0, + 0,0,0,0,0,0,0,-431,0,-503, + 0,0,0,0,0,-520,-522,0,0,0, + 0,0,0,0,0,0,0,0,-135,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-347,0,0,0,0,0,0,-523, + 0,0,0,0,0,0,0,0,0,0, + -444,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,-123,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-114,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,-435,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-62,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -63,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-64,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-65,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-66,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-67,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -132,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-141,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,-142,0,0,0,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,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,-287,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + -508,0,0,0,0,0,0,0,0,0, + 0,-59,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-381,0,0,0,0,0,0,0, + 0,0,0,0,-480,0,0,0,0,-125, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-441,0,0,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, + -382,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,-124,0,0,0, + 0,-267,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 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,-386,0,0, + 0,0,0,0,0,-436,0,0,0,0, + 0,-387,0,0,0,-412,0,0,0,-430, + 0,0,0,-447,0,0,0,0,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,0,0,0, + 0,0,-319,0,0,0,0,0,-260,0, + 0,0,0,0,-481,-484,0,0,0,0, + 0,0,0,0,0,-277,0,0,0,-285, + 0,0,0,0,0,0,0,0,0,0, + 0,0,-288,0,0,0,0,0,0,0, + 0,-467,0,0,0,0,-361,0,0,-509, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,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[] = { + 169,4,53,72,72,31,31,64,64,38, + 38,192,192,193,193,194,194,1,1,15, + 15,15,15,15,15,15,15,16,16,16, + 14,11,11,8,8,8,8,8,8,2, + 65,65,5,5,12,12,12,12,44,44, + 133,133,134,61,61,42,17,17,17,17, + 17,17,17,17,17,17,17,17,17,17, + 17,17,17,17,17,17,135,135,135,116, + 116,18,18,18,18,18,18,18,18,18, + 18,18,18,18,19,19,170,170,171,171, + 172,138,138,139,139,136,136,140,137,137, + 20,20,21,21,22,22,22,24,24,24, + 24,25,25,25,26,26,26,27,27,27, + 27,27,28,28,28,29,29,30,30,32, + 32,34,34,35,35,36,36,41,41,40, + 40,40,40,40,40,40,40,40,40,40, + 40,40,39,33,141,141,98,98,173,173, + 93,195,195,74,74,74,74,74,74,74, + 74,74,75,75,75,70,70,59,59,174, + 174,76,76,76,104,104,175,175,77,77, + 77,176,176,78,78,78,78,78,79,79, + 73,73,73,73,73,73,73,48,48,48, + 48,48,105,105,106,106,49,177,23,23, + 23,23,23,47,47,88,88,88,88,88, + 148,148,143,143,143,143,143,144,144,144, + 145,145,145,146,146,146,147,147,147,89, + 89,89,89,89,90,90,90,13,13,13, + 13,13,13,13,13,13,13,13,101,120, + 120,120,120,120,120,118,118,118,119,119, + 150,150,149,149,122,122,151,83,83,84, + 84,86,87,85,51,46,152,152,52,50, + 82,82,153,153,142,142,123,124,124,71, + 71,154,154,62,62,62,57,57,56,63, + 63,68,68,55,55,55,91,91,100,99, + 99,60,60,58,58,54,54,43,102,102, + 102,94,94,94,95,95,96,96,96,97, + 97,107,107,107,109,109,108,108,196,196, + 92,92,179,179,179,179,179,126,45,45, + 156,178,178,127,127,127,127,180,180,37, + 37,117,128,128,128,128,110,110,121,121, + 121,158,159,159,159,159,159,159,159,159, + 159,159,183,183,181,181,182,182,160,160, + 160,160,161,184,112,111,111,185,185,162, + 162,162,162,103,103,103,186,186,9,9, + 10,187,187,188,163,155,155,164,164,165, + 166,166,6,6,7,167,167,167,167,167, + 167,167,167,167,167,167,167,167,167,167, + 167,167,167,167,167,167,167,167,167,167, + 167,167,167,167,167,167,167,167,167,167, + 167,167,167,167,167,167,167,66,69,69, + 168,168,130,130,113,113,113,113,113,113, + 3,131,131,129,129,114,114,114,81,67, + 80,157,157,115,115,189,189,189,132,132, + 125,125,190,190,169,169,881,39,1868,1861, + 2119,3522,34,820,31,35,852,30,32,1860, + 29,27,56,1391,112,82,83,114,1401,769, + 1448,1441,1475,1467,1559,1525,1608,2417,1601,329, + 1616,1643,149,278,4440,381,164,150,1131,39, + 907,36,861,3409,34,820,343,35,852,1071, + 39,287,2204,39,907,36,237,3311,34,820, + 31,35,852,30,32,1346,29,27,56,1391, + 112,82,83,114,1401,1947,1448,1441,1475,1467, + 1559,1525,2055,1149,240,235,236,1891,39,451, + 993,3150,4606,337,324,1268,326,279,65,331, + 320,1226,1171,39,907,36,356,642,34,820, + 344,35,852,247,250,253,256,2941,329,1171, + 39,907,36,3990,944,34,820,44,35,852, + 392,425,350,1036,1059,353,404,1853,1457,3328, + 2848,3067,3129,3334,3376,1339,39,907,36,2607, + 3311,34,820,31,35,852,2154,32,1346,29, + 27,56,1391,112,82,83,114,1401,347,1448, + 1441,1475,1467,1559,1525,1608,1350,1601,318,1616, + 1643,149,1891,39,284,515,150,4096,2984,1989, + 39,1776,47,30,1064,46,820,2742,1128,516, + 1339,39,907,36,2607,3311,34,820,31,35, + 852,2154,32,1346,29,27,56,1391,112,82, + 83,114,1401,347,1448,1441,1475,1467,1559,1525, + 1608,1599,1601,602,1616,1643,149,333,339,1367, + 515,150,454,2984,1071,1727,1693,38,1071,39, + 2488,444,2842,2862,516,1071,39,1855,1813,511, + 2417,938,39,907,36,1380,3723,34,820,31, + 35,852,63,32,2152,2463,2181,946,39,396, + 1707,1339,39,907,36,2607,3311,34,820,31, + 35,852,2154,32,1346,29,27,56,1391,112, + 82,83,114,1401,347,1448,1441,1475,1467,1559, + 1525,1608,1956,1601,511,1616,1643,149,1537,1735, + 1257,515,150,3146,2984,3409,946,39,396,2189, + 2977,2181,496,2588,681,516,1611,39,907,36, + 2607,3311,34,820,31,35,852,2154,32,1346, + 29,27,56,1391,112,82,83,114,1401,347, + 1448,1441,1475,1467,1559,1525,1608,2187,1601,30, + 1616,1643,149,3062,857,336,515,150,2607,2984, + 1071,39,1693,281,1891,39,284,630,534,4680, + 516,1071,39,1693,286,511,67,347,2325,1849, + 39,907,36,3958,1096,34,820,343,35,852, + 2191,578,2181,1406,39,907,36,1130,3311,34, + 820,31,35,852,30,32,1346,29,27,56, + 1391,112,82,83,114,1401,716,1448,1441,1475, + 1467,1559,1525,1608,575,1601,1992,1616,1643,149, + 512,788,3150,383,150,324,1268,326,1071,3866, + 2139,319,1226,2774,946,39,396,2474,2764,2758, + 2653,2002,1848,1475,39,907,36,386,3311,34, + 820,31,35,852,30,32,1346,29,27,56, + 1391,112,82,83,114,1401,1289,1448,1441,1475, + 1467,1559,1525,1608,914,1601,30,1616,1643,149, + 1229,1180,2233,383,150,2204,39,907,36,421, + 3311,34,820,31,35,852,30,32,1346,29, + 27,56,1391,112,82,83,91,384,150,3327, + 387,1785,39,907,36,2647,3311,34,820,31, + 35,852,30,32,1346,29,27,56,1391,112, + 82,83,114,1401,358,1448,1441,1475,1467,1559, + 1525,1608,1848,1601,1769,1616,1643,149,1666,48, + 2120,377,150,3409,1257,360,522,357,1457,3409, + 1770,30,530,3850,1981,3200,1785,39,907,36, + 388,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1401,2611, + 1448,1441,1475,1467,1559,1525,1608,1376,1601,2611, + 1616,1643,149,337,30,445,377,150,685,336, + 1071,39,1052,390,1785,39,907,36,1128,3311, + 34,820,31,35,852,30,32,1346,29,27, + 56,1391,112,82,83,114,1401,376,1448,1441, + 1475,1467,1559,1525,1608,3028,1601,55,1616,1643, + 149,1295,52,391,377,150,509,338,339,1785, + 39,907,36,288,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 114,1401,495,1448,1441,1475,1467,1559,1525,1608, + 2279,1601,375,1616,1643,149,2390,2703,1468,164, + 150,1724,39,907,36,445,3311,34,820,31, + 35,852,30,32,1346,29,27,56,1391,112, + 82,83,114,1401,329,1448,1441,1475,1467,1559, + 1525,1608,99,1601,2686,1616,1643,149,2916,2465, + 373,383,150,1678,39,907,36,2102,3311,34, + 820,31,35,852,30,32,1346,29,27,56, + 1391,112,82,83,114,1401,330,1448,1441,1475, + 1467,1559,1525,1608,2547,1601,590,1616,1650,170, + 1071,39,1693,283,1184,1276,39,907,36,4043, + 3723,34,820,31,35,852,62,32,188,1295, + 1853,769,1601,39,907,36,2420,4676,34,820, + 31,35,852,30,32,332,509,1171,39,907, + 36,2574,2139,34,820,2335,35,852,381,1597, + 354,1736,1544,39,907,36,567,3311,34,820, + 31,35,852,30,32,1346,29,27,56,1391, + 112,82,83,114,1401,1573,1448,1441,1475,1467, + 1559,1525,1608,76,1601,380,1616,1643,149,1071, + 2241,1043,148,150,1785,39,907,36,1242,3311, + 34,820,31,35,852,30,32,1346,29,27, + 56,1391,112,82,83,114,1401,1949,1448,1441, + 1475,1467,1559,1525,1608,29,1601,30,1616,1643, + 149,740,393,425,161,150,1785,39,907,36, + 66,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1401,861, + 1448,1441,1475,1467,1559,1525,1608,359,1601,30, + 1616,1643,149,821,530,332,160,150,1785,39, + 907,36,378,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,114, + 1401,658,1448,1441,1475,1467,1559,1525,1608,1765, + 1601,291,1616,1643,149,1071,3172,2157,159,150, + 1785,39,907,36,659,3311,34,820,31,35, + 852,30,32,1346,29,27,56,1391,112,82, + 83,114,1401,2329,1448,1441,1475,1467,1559,1525, + 1608,678,1601,30,1616,1643,149,678,326,419, + 158,150,1785,39,907,36,137,3311,34,820, + 31,35,852,30,32,1346,29,27,56,1391, + 112,82,83,114,1401,1980,1448,1441,1475,1467, + 1559,1525,1608,1284,1601,30,1616,1643,149,3403, + 992,597,157,150,1785,39,907,36,659,3311, + 34,820,31,35,852,30,32,1346,29,27, + 56,1391,112,82,83,114,1401,861,1448,1441, + 1475,1467,1559,1525,1608,685,1601,30,1616,1643, + 149,559,773,2576,156,150,1785,39,907,36, + 659,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1401,658, + 1448,1441,1475,1467,1559,1525,1608,1102,1601,1398, + 1616,1643,149,1371,1979,1958,155,150,1785,39, + 907,36,1387,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,114, + 1401,966,1448,1441,1475,1467,1559,1525,1608,1385, + 1601,30,1616,1643,149,3383,2585,1218,154,150, + 1785,39,907,36,854,3311,34,820,31,35, + 852,30,32,1346,29,27,56,1391,112,82, + 83,114,1401,513,1448,1441,1475,1467,1559,1525, + 1608,62,1601,30,1616,1643,149,2847,164,692, + 153,150,1785,39,907,36,868,3311,34,820, + 31,35,852,30,32,1346,29,27,56,1391, + 112,82,83,114,1401,1107,1448,1441,1475,1467, + 1559,1525,1608,1223,1601,2653,1616,1643,149,3021, + 777,2448,152,150,1785,39,907,36,2391,3311, + 34,820,31,35,852,30,32,1346,29,27, + 56,1391,112,82,83,114,1401,1777,1448,1441, + 1475,1467,1559,1525,1608,2333,1601,30,1616,1643, + 149,3507,1858,2525,151,150,1785,39,907,36, + 2529,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1401,73, + 1448,1441,1475,1467,1559,1525,1608,156,1601,30, + 1616,1643,149,2874,205,249,165,150,1785,39, + 907,36,1151,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,114, + 1401,1459,1448,1441,1475,1467,1559,1525,1608,1889, + 1601,1257,1616,1643,149,2344,3409,1840,146,150, + 2110,39,907,36,2102,3311,34,820,31,35, + 852,30,32,1346,29,27,56,1391,112,82, + 83,114,1401,2328,1448,1441,1475,1467,1559,1525, + 1608,2732,1601,402,1616,1643,149,2004,39,285, + 195,150,2204,39,907,36,3752,3311,34,820, + 31,35,852,30,32,1346,29,27,56,1391, + 112,82,83,114,1401,1018,1448,1441,1475,1467, + 1559,1525,1608,596,1601,766,1616,1650,170,2204, + 39,907,36,1042,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 114,1401,931,1448,1441,1475,1467,1559,1525,1608, + 313,1601,521,1616,1650,170,1601,39,907,36, + 77,4676,34,820,31,35,852,65,32,100, + 1831,2204,39,907,36,295,3311,34,820,31, + 35,852,30,32,1346,29,27,56,1391,112, + 82,83,114,1401,1011,1448,1441,1475,1467,1559, + 1525,1608,1529,1601,1733,1616,1650,170,2204,39, + 907,36,421,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,114, + 1401,1689,1448,1441,1475,1467,1559,1525,1608,1752, + 1601,1903,1616,1650,170,1657,39,907,36,1074, + 4676,34,820,31,35,852,64,32,2417,2661, + 2204,39,907,36,420,3311,34,820,31,35, + 852,30,32,1346,29,27,56,1391,112,82, + 83,114,1401,1623,1448,1441,1475,1467,1559,1525, + 1608,1486,1601,1887,1616,1650,170,2250,39,907, + 36,423,3311,34,820,31,35,852,30,32, + 1346,29,27,56,1391,112,82,83,114,1401, + 2000,1448,1441,1475,1467,1559,1525,1608,2070,1601, + 458,1616,1650,170,1171,39,907,36,2717,2259, + 34,820,2422,35,852,1071,39,1052,390,2204, + 39,907,36,3682,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 114,1401,2299,1448,1441,1475,1467,1559,1525,1608, + 30,1601,429,2100,2989,241,2204,39,907,36, + 3126,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1401,2090, + 1448,1441,1475,1467,1559,1525,1608,2676,2065,2204, + 39,907,36,406,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 114,1401,2524,1448,1441,1475,1467,1559,2063,2204, + 39,907,36,522,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 114,1401,241,1448,1441,1475,1467,1979,2204,39, + 907,36,2245,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,114, + 1401,2611,1448,1441,1475,2013,2204,39,907,36, + 305,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1401,2651, + 1448,1441,1475,2021,2204,39,907,36,2684,3311, + 34,820,31,35,852,30,32,1346,29,27, + 56,1391,112,82,83,114,1401,2530,1448,1441, + 1929,2204,39,907,36,289,3311,34,820,31, + 35,852,30,32,1346,29,27,56,1391,112, + 82,83,114,1401,2139,1448,1441,1937,2204,39, + 907,36,2611,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,114, + 1401,1857,1448,1441,1944,2204,39,907,36,2569, + 3311,34,820,31,35,852,30,32,1346,29, + 27,56,1391,112,82,83,114,1401,1216,1448, + 1441,1945,1119,39,907,36,860,2696,34,820, + 343,35,852,2004,39,282,303,2296,39,1052, + 390,2417,2799,2698,2334,2420,2204,39,907,36, + 242,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1401,30, + 1448,1952,1719,536,278,3150,2607,30,324,1268, + 326,734,1461,1295,319,1226,2607,3409,1542,328, + 356,1295,347,805,2726,347,530,237,1350,2433, + 39,282,162,2727,3917,2592,2650,865,2690,1180, + 1229,2420,2984,457,327,4010,348,1036,1059,353, + 1295,241,4347,2661,779,240,235,236,417,1295, + 417,2458,1229,2420,536,3027,2734,336,279,162, + 1180,39,907,36,2652,168,34,820,343,35, + 852,28,788,3961,247,250,253,256,2941,226, + 1939,162,355,162,3650,944,206,3907,186,2922, + 524,355,2542,578,364,1064,2607,50,2120,1555, + 3328,2848,3067,3129,3334,3376,241,2647,2701,2699, + 1784,1803,380,3150,2404,2592,324,1268,326,356, + 201,370,319,1226,1071,39,1693,2479,356,2417, + 436,2653,1267,39,907,36,3958,3409,34,820, + 343,35,852,1773,309,348,1036,1059,353,1140, + 39,1052,390,1369,348,1036,1059,353,2204,39, + 907,36,1369,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,114, + 1401,3999,1448,1971,503,3150,55,336,324,1268, + 326,1651,2565,1761,319,1226,2511,769,1106,4017, + 2607,4369,2301,540,1087,502,1229,1833,3585,3762, + 2886,2607,2753,3018,2691,1842,39,1052,390,234, + 2685,30,500,4490,1457,1229,2878,202,505,30, + 347,3402,536,3121,2588,166,1071,39,1052,390, + 2728,211,220,3855,210,217,218,219,221,30, + 2854,347,55,3538,3910,312,316,1651,237,53, + 771,162,212,214,2301,2233,177,194,1229,222, + 536,4565,241,278,2691,1295,2027,213,215,216, + 297,298,299,300,1128,2864,249,235,236,234, + 329,1061,39,1734,1729,4588,2865,166,1295,162, + 3030,4061,2542,2555,186,2922,75,2607,395,425, + 185,209,220,3855,208,217,218,219,221,1071, + 39,1052,390,3225,339,175,234,2697,55,74, + 2762,2767,196,1651,2749,795,174,280,1124,1457, + 189,173,176,177,178,179,180,2771,211,220, + 3855,210,217,218,219,221,432,1249,39,907, + 36,3294,3185,34,820,343,35,852,329,212, + 214,769,2233,4602,454,2631,222,1461,1011,2607, + 1295,2607,3409,3409,213,215,216,297,298,299, + 300,2417,441,2156,440,403,2420,1012,234,1128, + 2592,1687,356,3926,2549,39,1693,281,4061,3323, + 3150,59,1527,321,2392,326,2607,1247,2772,1840, + 211,220,3855,210,217,218,219,221,348,1036, + 1059,353,336,337,1295,2592,346,2773,335,339, + 3163,212,214,2663,2233,2301,356,2607,222,1229, + 1071,39,1052,390,89,523,213,215,216,297, + 298,299,300,57,94,93,234,108,3028,364, + 241,1457,350,1036,1059,353,2733,237,166,1916, + 4061,3326,394,425,2699,1784,1803,431,211,220, + 3855,210,217,218,219,221,1140,39,1052,390, + 1071,39,1052,390,364,252,235,236,204,212, + 214,3043,2233,1,30,1255,222,536,1229,3205, + 1784,1803,2735,2777,213,215,216,297,298,299, + 300,1128,2761,55,521,1295,234,55,1651,237, + 53,30,1651,3597,582,1229,162,162,4061,3340, + 1527,186,2922,3041,2607,1295,1418,589,209,220, + 3855,208,217,218,219,221,58,255,235,236, + 3551,339,175,2592,162,30,2288,187,30,1000, + 2073,30,3530,174,5226,1112,2879,190,173,176, + 177,178,179,180,2204,39,907,36,5226,3311, + 34,820,31,35,852,30,32,1346,29,27, + 56,1391,112,82,83,114,1401,241,1887,2204, + 39,907,36,5226,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 114,1401,364,1895,983,39,2561,36,3958,3409, + 34,820,343,35,852,203,30,3315,1784,1803, + 1229,2303,39,1052,390,1295,5226,1997,39,451, + 30,265,4606,2611,2607,536,2611,1295,1855,1071, + 2597,1693,80,1295,1976,2549,39,1693,2613,162, + 2611,244,5226,347,234,3361,2899,3150,55,336, + 324,1268,326,1651,162,1509,319,1226,96,186, + 2922,1295,1295,2984,3480,1425,209,220,3855,208, + 217,218,219,221,507,1295,2360,39,1052,390, + 175,2799,353,2018,2241,4490,536,310,237,243, + 302,174,73,72,237,3165,173,176,177,178, + 179,180,2697,953,301,234,71,2607,4659,1071, + 39,1052,390,278,1295,162,245,235,236,5226, + 186,2922,258,235,236,5226,234,209,220,3855, + 208,217,218,219,221,30,237,1665,1665,1229, + 441,175,3937,3937,536,70,55,5226,638,407, + 3007,1651,174,1811,416,2569,182,173,176,177, + 178,179,180,234,241,235,236,2301,162,408, + 409,1229,2233,162,3362,5226,1985,279,186,2922, + 30,448,2842,2862,2745,209,220,3855,208,217, + 218,219,221,248,251,254,257,2941,529,175, + 166,5226,536,5226,944,290,2199,2018,2241,5226, + 174,1071,39,296,193,173,176,177,178,179, + 180,234,2322,39,1052,390,996,39,1052,390, + 2543,162,1169,2243,2607,5226,186,2922,1457,95, + 1354,1354,108,209,220,3855,208,217,218,219, + 221,30,5226,2592,30,1392,617,175,1229,55, + 536,410,412,278,1651,3624,1593,30,174,5226, + 5226,2534,3206,173,176,177,178,179,180,234, + 1071,39,296,2886,1159,1257,4532,162,2645,162, + 3409,329,3955,3375,186,2922,4610,1295,1128,428, + 427,209,220,3855,208,217,218,219,221,5226, + 1591,39,907,36,860,175,34,820,343,35, + 852,1148,503,2432,1295,2607,174,2507,61,290, + 198,173,176,177,178,179,180,3567,339,1295, + 336,705,78,502,2592,536,1071,39,1052,390, + 1071,39,1693,2673,30,60,2451,2243,2607,5226, + 500,2301,3854,3150,234,1229,324,1268,326,2417, + 107,30,319,1226,162,2846,1118,347,356,186, + 2922,525,2417,430,5226,5226,209,220,3855,208, + 217,218,219,221,166,5226,1295,2984,2793,793, + 175,5226,5226,536,348,1036,1059,353,505,5226, + 30,174,526,365,2607,192,173,176,177,178, + 179,180,234,2468,39,1052,390,2756,5226,5226, + 30,3919,162,347,2953,30,30,186,2922,3025, + 3093,103,5226,5226,209,220,3855,208,217,218, + 219,221,1882,2984,104,5226,329,3409,175,3639, + 55,4614,30,5226,1818,1651,1987,1635,30,174, + 5226,5226,953,200,173,176,177,178,179,180, + 2204,39,907,36,3526,3311,34,820,31,35, + 852,30,32,1346,29,27,56,1391,112,82, + 83,114,1902,2204,39,907,36,3752,3311,34, + 820,31,35,852,30,32,1346,29,27,56, + 1391,112,82,83,114,1903,2204,39,907,36, + 5226,3311,34,820,31,35,852,30,32,1346, + 29,27,56,1391,112,82,83,114,1910,2707, + 2539,5226,5226,2607,241,1912,39,907,36,2782, + 2609,34,820,343,35,852,241,5226,2204,1727, + 907,1777,234,3311,34,820,31,35,852,30, + 32,1346,29,27,56,1391,112,82,83,90, + 102,528,308,1295,211,220,3855,210,217,218, + 219,221,2479,5226,207,2542,2607,241,3150,2607, + 1295,321,2392,326,385,212,214,30,2233,241, + 5226,3069,519,30,449,234,241,536,2592,1295, + 213,215,216,297,298,299,300,2544,39,1052, + 390,382,1295,5226,241,205,347,211,220,3855, + 210,217,218,219,221,2739,162,304,1257,2607, + 3440,30,2948,3409,2676,4391,2984,5226,212,214, + 5226,2233,30,3498,55,518,2607,2925,234,1651, + 1295,53,227,213,215,216,297,298,299,300, + 2468,39,1052,390,1295,347,5226,503,2295,1295, + 211,220,3855,210,217,218,219,221,2783,3043, + 2648,3556,2607,336,3610,2984,1295,1295,502,5226, + 5226,212,214,5226,2233,2681,1819,55,311,30, + 3046,234,1651,536,53,501,213,215,216,297, + 298,299,300,2544,39,1052,390,4050,3699,4501, + 241,2284,347,211,220,3855,210,217,218,219, + 221,2587,162,5226,5226,2607,5226,5226,2690,5226, + 5226,5226,2984,5226,212,214,5226,2233,30,5226, + 55,497,2607,3084,234,1651,5226,53,199,213, + 215,216,297,298,299,300,1071,39,1052,390, + 5226,347,5226,5226,2969,5226,211,220,3855,210, + 217,218,219,221,5226,5226,1071,39,1052,390, + 5226,2984,5226,5226,5226,5226,5226,212,214,5226, + 2233,5226,1826,55,223,5226,5226,5226,1651,5226, + 2603,5226,213,215,216,297,298,299,300,2204, + 39,907,36,450,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 89,2204,39,907,36,5226,3311,34,820,31, + 35,852,30,32,1346,29,27,56,1391,112, + 82,83,88,2204,39,907,36,5226,3311,34, + 820,31,35,852,30,32,1346,29,27,56, + 1391,112,82,83,87,2204,39,907,36,5226, + 3311,34,820,31,35,852,30,32,1346,29, + 27,56,1391,112,82,83,86,2204,39,907, + 36,5226,3311,34,820,31,35,852,30,32, + 1346,29,27,56,1391,112,82,83,85,2204, + 39,907,36,5226,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 84,2061,39,907,36,5226,3311,34,820,31, + 35,852,30,32,1346,29,27,56,1391,112, + 82,83,110,2204,39,907,36,5226,3311,34, + 820,31,35,852,30,32,1346,29,27,56, + 1391,112,82,83,116,2204,39,907,36,5226, + 3311,34,820,31,35,852,30,32,1346,29, + 27,56,1391,112,82,83,115,2204,39,907, + 36,5226,3311,34,820,31,35,852,30,32, + 1346,29,27,56,1391,112,82,83,113,2204, + 39,907,36,5226,3311,34,820,31,35,852, + 30,32,1346,29,27,56,1391,112,82,83, + 111,1521,39,907,36,3958,5226,34,820,343, + 35,852,2158,39,907,36,5226,3311,34,820, + 31,35,852,30,32,1346,29,27,56,1391, + 92,82,83,1453,39,2561,36,3958,5226,34, + 820,343,35,852,5226,30,5226,5226,5226,536, + 1071,39,1052,390,3150,5226,5226,324,1268,326, + 5226,5226,5226,319,1226,5226,5226,5226,347,5226, + 5226,5226,540,1849,39,907,36,3958,162,34, + 820,343,35,852,194,5226,3150,55,4565,324, + 1268,326,1651,5226,938,319,1226,5226,5226,5226, + 1233,39,907,36,1425,3409,34,820,343,35, + 852,1233,39,907,36,5226,3409,34,820,343, + 35,852,5226,5226,312,316,3150,5226,5226,324, + 1268,326,5226,5226,5226,319,1226,30,5226,5226, + 5226,2607,1029,3944,540,5226,2607,4659,5226,3929, + 5226,5226,5226,3150,2864,337,324,1268,326,5226, + 347,5226,322,1226,3150,234,337,324,1268,326, + 5226,5226,5226,320,1226,1849,39,907,36,3958, + 2984,34,820,343,35,852,5226,638,407,3007, + 5226,1845,5226,417,2569,5226,313,316,2544,39, + 1052,390,5226,5226,5226,5226,2301,5226,408,409, + 1229,2233,2544,39,1052,390,2544,39,1052,390, + 2580,39,1052,390,2626,39,1052,390,3150,5226, + 5226,324,1268,326,5226,55,5226,319,1226,166, + 1651,5226,53,5226,5226,2199,3182,5226,5226,55, + 5226,2332,5226,55,1651,2607,53,55,1651,3100, + 53,55,1651,30,53,5226,1651,1229,53,1071, + 39,1052,390,3646,347,30,30,4116,5226,536, + 536,3511,529,5226,5226,3580,1071,39,1052,390, + 1071,39,1052,390,2984,5226,162,5226,347,347, + 410,413,3414,30,3893,532,55,2607,162,162, + 5226,1651,30,1677,194,194,2607,30,4565,4565, + 30,1229,5226,55,1229,5226,347,55,1651,5226, + 1509,5226,1651,5226,2669,347,5226,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,2984,5226,5226,5226, + 162,5226,5226,162,5226,2984,3669,3333,5226,4016, + 5226,5226,5226,5226,5226,5226,533,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5226,5226,3942, + 3980,5226,5226,5226,5226,5226,5226,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5226,5226,5226, + 5226,3860,5226,0,817,1,0,866,1,0, + 1,2,5244,0,1,2,5243,0,43,5244, + 0,43,5243,0,1131,323,0,452,1174,0, + 438,1477,0,1519,33,0,5232,1,0,5231, + 1,0,5465,246,0,5464,246,0,5568,246, + 0,5567,246,0,5492,246,0,5491,246,0, + 5490,246,0,5489,246,0,5488,246,0,5487, + 246,0,5486,246,0,5485,246,0,5503,246, + 0,5502,246,0,5501,246,0,5500,246,0, + 5499,246,0,5498,246,0,5497,246,0,5496, + 246,0,5495,246,0,5494,246,0,5493,246, + 0,43,246,5244,0,43,246,5243,0,5268, + 246,0,1519,389,0,54,5244,0,54,5243, + 0,42,5244,0,42,5243,0,2538,132,0, + 1,442,0,456,2208,0,455,2611,0,39, + 37,0,5268,1,0,43,1,0,43,2, + 5244,0,43,2,5243,0,1519,45,0,1046, + 97,0,36,38,0,43,784,0,49,5266, + 0,49,41,0,1,569,0,1,5503,0, + 1,5502,0,1,5501,0,1,5500,0,1, + 5499,0,1,5498,0,1,5497,0,1,5496, + 0,1,5495,0,1,5494,0,1,5493,0, + 43,1,5244,0,43,1,5243,0,729,1, + 0,499,2209,0,5268,233,1,0,43,233, + 1,0,233,415,0,41,5244,0,41,5243, + 0,242,2852,0,390,36,0,36,390,0, + 389,33,0,33,389,0,5244,54,0,5243, + 54,0,2538,134,0,2538,133,0,30,517, + 0,5560,443,0,1603,443,0,5236,405,0, + 5235,405,0,1,939,0,1,784,0,1, + 2857,0,233,414,0,53,41,0,1,98, + 0,41,53,0,5266,51,0,51,41,0, + 1,5560,0,1,1603,0,43,1,2,5244, + 0,43,1,2,5243,0,41,5244,2,0, + 41,5243,2,0,5244,40,0,5243,40,0, + 499,3902,0,233,1,0,5560,101,0,1603, + 101,0,39,79,0,283,3095,0,5234,1, + 0,233,225,0,233,1,2890,0,5236,233, + 0,5235,233,0,233,224,0,3104,233,0, + 8,10,0,191,3641,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,0,0, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,44,45,46,47,0,49, + 50,51,52,53,54,55,56,57,58,59, + 60,0,62,63,0,65,66,6,68,69, + 70,71,0,9,74,11,76,77,78,79, + 80,81,82,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,88,89,30,31, + 32,33,34,35,36,37,38,39,40,41, + 42,43,44,45,46,47,0,49,50,51, + 52,53,54,55,56,57,58,59,60,0, + 62,63,3,65,66,0,68,69,70,71, + 88,89,74,0,76,77,78,79,80,81, + 82,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,0,0,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 44,45,46,47,61,49,50,51,52,53, + 54,55,56,57,58,59,60,101,62,63, + 0,65,66,88,89,69,70,71,0,9, + 74,11,76,77,78,79,80,81,82,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,88,89,30,31,32,33,34,35, + 36,37,38,39,40,41,42,43,44,45, + 46,47,0,49,50,51,52,53,54,55, + 56,57,58,59,60,0,62,63,0,65, + 66,0,4,69,70,71,88,89,74,8, + 76,77,78,79,80,81,82,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, + 0,0,30,31,32,33,34,35,36,37, + 38,39,40,41,42,43,44,45,46,47, + 0,49,50,51,52,53,54,55,56,57, + 58,59,60,101,62,63,0,65,66,0, + 0,69,70,71,99,9,74,11,76,77, + 78,79,80,81,82,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,48,0, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,44,45,46,47,0,49, + 50,51,52,53,54,55,56,57,58,59, + 60,121,62,63,0,65,66,0,0,69, + 70,71,0,9,74,11,76,77,78,79, + 80,81,82,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,48,0,30,31, + 32,33,34,35,36,37,38,39,40,41, + 42,43,44,45,46,47,64,49,50,51, + 52,53,54,55,56,57,58,59,60,0, + 62,63,3,65,66,0,0,69,70,71, + 4,0,74,8,76,77,78,79,80,81, + 82,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,0,0,30,31,32,33, + 34,35,36,37,38,39,40,41,42,43, + 44,45,46,47,63,49,50,51,52,53, + 54,55,56,57,58,59,60,0,62,63, + 0,65,66,3,0,69,70,71,0,0, + 74,0,76,77,78,79,80,81,82,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,48,0,30,31,32,33,34,35, + 36,37,38,39,40,41,42,43,44,45, + 46,47,61,49,50,51,52,53,54,55, + 56,57,58,59,60,0,62,63,0,65, + 66,0,0,69,70,71,0,100,74,3, + 76,77,78,79,80,81,82,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, + 48,0,30,31,32,33,34,35,36,37, + 38,39,40,41,42,43,44,45,46,47, + 72,49,50,51,52,53,54,55,56,57, + 58,59,60,0,62,63,0,65,66,3, + 0,69,70,71,0,100,74,0,76,77, + 78,79,80,81,82,83,84,85,86,87, + 0,1,2,3,4,5,6,7,8,29, + 10,0,12,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,0,0, + 30,31,32,33,34,35,36,37,38,39, + 40,41,42,43,44,45,46,47,61,49, + 50,51,52,53,54,55,56,0,1,2, + 60,4,5,63,7,0,1,2,95,69, + 70,71,0,1,2,3,4,5,6,7, + 8,9,10,11,12,0,29,15,16,17, + 18,19,20,21,22,23,24,25,114,115, + 116,29,0,1,2,3,4,5,6,7, + 8,0,0,41,29,0,1,2,46,47, + 5,49,50,51,52,53,54,55,56,57, + 0,1,2,3,4,63,6,0,8,0, + 68,69,70,71,72,0,74,75,0,1, + 2,3,4,5,6,7,8,9,10,11, + 12,0,0,15,16,17,18,19,20,21, + 22,23,24,25,72,13,14,29,48,67, + 0,1,2,0,4,0,114,115,116,41, + 0,1,2,0,46,47,0,49,50,51, + 52,53,54,55,56,57,0,1,2,29, + 4,63,6,102,8,0,68,69,70,71, + 72,0,74,75,3,0,0,6,117,8, + 9,48,11,72,13,14,99,12,0,1, + 2,3,4,5,6,7,8,26,27,28, + 0,1,2,3,4,5,6,7,8,0, + 1,2,114,115,116,72,41,0,0,48, + 0,46,47,58,49,50,51,52,53,54, + 55,56,61,13,14,64,48,61,67,68, + 0,1,2,72,73,5,28,7,48,0, + 1,2,3,0,5,67,7,4,9,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,0,0,0,117,118, + 3,120,0,6,41,8,9,48,11,0, + 13,14,0,1,2,3,4,5,6,7, + 8,0,95,26,27,28,0,6,0,1, + 2,3,73,5,0,7,0,9,12,11, + 4,0,6,48,8,48,0,1,2,3, + 4,5,6,7,8,0,1,2,61,4, + 5,64,7,0,67,68,64,41,0,72, + 73,3,46,47,0,49,50,51,52,53, + 54,55,56,9,29,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,77,91,92,117,118,48,120,0,1, + 2,3,4,5,6,7,8,0,10,0, + 67,13,14,15,16,17,18,19,20,21, + 22,23,24,25,26,27,0,73,30,31, + 32,33,34,35,36,37,38,39,40,0, + 42,43,44,45,0,102,0,104,105,106, + 107,108,109,110,111,112,113,0,60,61, + 117,4,0,65,66,0,1,2,3,4, + 5,6,7,8,9,10,67,0,13,14, + 15,16,17,18,19,20,21,22,23,24, + 25,26,27,67,0,30,31,32,33,34, + 35,36,37,38,39,40,67,42,43,44, + 45,67,0,1,2,3,0,5,0,7, + 0,1,2,58,4,60,6,0,8,9, + 3,13,14,68,0,1,2,3,4,5, + 6,7,8,9,10,0,0,13,14,15, + 16,17,18,19,20,21,22,23,24,25, + 26,27,46,47,30,31,32,33,34,35, + 36,37,38,39,40,48,42,43,44,45, + 0,1,2,3,72,5,0,7,0,9, + 0,11,58,73,60,9,0,1,2,122, + 4,0,68,0,1,2,3,4,5,6, + 7,8,67,10,0,95,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,30,0,30,31,32,33,34,35,36, + 37,38,39,40,30,42,43,44,45,61, + 0,1,2,3,58,5,0,7,0,73, + 0,1,2,60,4,5,10,7,65,66, + 0,1,2,3,4,5,6,7,8,0, + 10,95,0,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,48,67, + 30,31,32,33,34,35,36,37,38,39, + 40,29,42,43,44,45,0,1,2,61, + 4,5,64,7,0,0,1,2,4,4, + 60,6,0,8,0,65,66,0,1,2, + 3,4,5,6,7,8,9,10,0,0, + 13,14,15,16,17,18,19,20,21,22, + 23,24,25,26,27,41,0,30,31,32, + 33,34,35,36,37,38,39,40,0,42, + 43,44,45,0,1,2,3,4,5,6, + 7,8,0,10,28,0,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,0,64,30,31,32,33,34,35,36, + 37,38,39,40,0,42,43,44,45,0, + 1,2,0,4,0,6,0,8,114,115, + 116,58,6,60,0,1,2,3,4,5, + 6,7,8,61,10,118,64,13,14,15, + 16,17,18,19,20,21,22,23,24,25, + 26,27,61,95,30,31,32,33,34,35, + 36,37,38,39,40,90,42,43,44,45, + 0,96,0,61,4,3,64,5,6,0, + 8,0,1,2,60,13,14,0,0,1, + 2,3,0,5,0,7,0,0,26,27, + 28,97,98,31,0,0,12,91,92,15, + 16,17,18,19,20,21,22,23,24,25, + 48,0,1,2,28,4,0,6,0,8, + 0,1,2,61,4,41,64,65,66,67, + 46,47,0,49,50,51,52,53,54,55, + 56,0,1,2,3,0,5,0,7,72, + 88,89,90,91,92,93,94,12,72,97, + 98,99,100,101,102,103,104,105,106,107, + 108,109,110,111,112,113,0,90,0,3, + 64,5,6,96,8,0,41,0,119,13, + 14,46,47,61,49,50,51,52,53,54, + 55,56,26,27,28,0,28,31,0,0, + 1,2,4,28,5,97,98,12,0,1, + 2,0,1,2,48,7,0,1,2,0, + 4,0,3,0,1,2,28,61,29,61, + 64,65,66,67,0,58,41,0,1,2, + 29,46,47,0,49,50,51,52,53,54, + 55,56,29,0,88,89,90,91,92,93, + 94,93,94,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,0, + 10,0,3,13,14,15,16,17,18,19, + 20,21,22,23,24,25,26,27,0,0, + 30,31,32,33,34,35,36,37,38,39, + 40,0,42,43,44,45,5,0,48,0, + 1,2,3,4,5,6,7,8,0,10, + 119,3,13,14,15,16,17,18,19,20, + 21,22,23,24,25,26,27,30,0,30, + 31,32,33,34,35,36,37,38,39,40, + 61,42,43,44,45,0,0,0,1,2, + 3,4,5,6,7,8,10,10,0,60, + 13,14,15,16,17,18,19,20,21,22, + 23,24,25,26,27,67,0,30,31,32, + 33,34,35,36,37,38,39,40,60,42, + 43,44,45,0,1,2,3,4,5,6, + 7,8,0,10,28,59,13,14,15,16, + 17,18,19,20,21,22,23,24,25,26, + 27,76,0,30,31,32,33,34,35,36, + 37,38,39,40,0,42,43,44,45,0, + 1,2,3,4,5,6,7,8,0,10, + 28,3,13,14,15,16,17,18,19,20, + 21,22,23,24,25,26,27,0,0,30, + 31,32,33,34,35,36,37,38,39,40, + 0,42,43,44,45,0,1,2,0,4, + 0,3,0,1,2,10,28,12,64,9, + 15,16,17,18,19,20,21,22,23,24, + 25,0,1,2,0,1,2,0,0,1, + 2,0,0,0,1,2,41,0,6,0, + 9,46,47,0,49,50,51,52,53,54, + 55,56,9,29,11,28,0,29,63,0, + 1,2,29,4,69,70,71,65,66,10, + 0,12,0,73,15,16,17,18,19,20, + 21,22,23,24,25,0,65,66,61,0, + 0,1,2,3,4,5,6,7,8,9, + 41,11,12,0,73,46,47,64,49,50, + 51,52,53,54,55,56,0,28,28,0, + 93,94,63,91,92,9,0,0,69,70, + 71,41,0,1,2,0,46,47,48,49, + 50,51,52,53,54,55,56,0,1,2, + 3,4,5,6,7,8,9,0,11,12, + 3,29,0,73,0,0,9,0,1,2, + 67,0,10,0,1,2,0,58,0,1, + 2,3,4,5,6,7,8,9,41,11, + 12,29,28,46,47,48,49,50,51,52, + 53,54,55,56,0,48,28,29,4,0, + 0,1,2,3,4,5,6,7,8,9, + 73,11,12,0,0,63,3,0,0,0, + 73,58,28,4,118,57,74,59,0,29, + 62,0,0,0,1,2,0,9,0,1, + 2,10,10,75,0,1,2,3,4,5, + 6,7,8,9,0,11,12,57,0,59, + 29,29,62,0,28,0,3,0,68,0, + 1,2,0,29,0,75,0,1,2,3, + 4,5,6,7,8,9,123,11,12,26, + 27,0,64,28,63,63,68,0,0,0, + 0,57,28,59,90,29,62,9,90,9, + 96,48,68,0,96,0,1,2,64,75, + 0,1,2,3,4,5,6,7,8,9, + 72,11,12,57,0,59,0,0,62,0, + 0,0,0,3,68,4,9,0,9,29, + 0,75,0,1,2,3,4,5,6,7, + 8,9,64,11,12,0,103,0,68,28, + 28,73,0,0,0,0,3,57,28,59, + 0,29,62,120,9,0,0,0,68,3, + 0,4,58,28,58,75,0,1,2,3, + 4,5,6,7,8,9,0,11,12,57, + 73,59,73,28,62,0,0,0,3,3, + 68,0,0,0,0,29,3,75,0,1, + 2,3,4,5,6,7,8,9,0,11, + 12,3,0,68,64,3,72,9,58,28, + 0,0,0,57,3,59,0,29,62,3, + 0,0,0,3,3,3,0,0,0,3, + 0,75,0,1,2,3,4,5,6,7, + 8,9,61,11,12,57,48,59,0,72, + 62,67,0,0,72,28,0,0,0,61, + 0,29,64,75,0,0,0,0,0,0, + 0,73,0,0,93,94,0,67,0,0, + 0,0,0,0,0,119,0,0,0,57, + 0,59,0,0,62,0,0,0,0,0, + 0,0,0,0,0,0,0,75,0,0, + 0,0,0,0,0,0,0,0,0,121, + 0,0,0,0,0,0,0,0,0,0, + 0,0,0,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, + 5226,5204,5183,5183,5183,5183,5183,5183,5183,5217, + 1,5211,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,127,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,5226,1, + 1,1,1,1,1,1,1,1567,1304,1565, + 1,5226,2664,1,405,1,1,2330,5233,1, + 1,1,131,5117,5407,5120,2615,3068,3267,2247, + 3120,2870,3321,2997,998,2981,2698,2980,8,5220, + 5220,5220,5220,5220,5220,5220,5220,5220,5220,5220, + 5220,5220,5220,5220,5220,5220,5220,5220,5220,5220, + 5220,5220,5220,5220,5220,5220,2616,2808,5220,5220, + 5220,5220,5220,5220,5220,5220,5220,5220,5220,5220, + 5220,5220,5220,5220,5220,5220,143,5220,5220,5220, + 5220,5220,5220,5220,5220,5220,5220,5220,5220,5226, + 5220,5220,3923,5220,5220,130,5220,5220,5220,5220, + 2616,2808,5220,5226,5220,5220,5220,5220,5220,5220, + 5220,5220,5220,5220,5220,5220,5226,5204,5183,5183, + 5183,5183,5183,5183,5183,5208,1,5211,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,129,5226,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,2270,1,1,1,1,1, + 1,1,1,1567,1304,1565,1,2336,2664,1, + 5226,1,1,2616,2808,1,1,1,128,5236, + 5407,5235,2615,3068,3267,2247,3120,2870,3321,2997, + 998,2981,2698,2980,5226,5204,5183,5183,5183,5183, + 5183,5183,5183,5208,1,5211,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,2616,2808,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,144,1,1,1,1,1,1,1, + 1,1567,1304,1565,1,139,2664,1,43,1, + 1,137,5268,1,1,1,2616,2808,5407,2399, + 2615,3068,3267,2247,3120,2870,3321,2997,998,2981, + 2698,2980,5226,5204,5183,5183,5183,5183,5183,5183, + 5183,5208,1,5211,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 5226,5226,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 5226,1,1,1,1,1,1,1,1,1567, + 1304,1565,1,2336,2664,1,1,1,1,5226, + 352,1,1,1,2369,5236,5407,5235,2615,3068, + 3267,2247,3120,2870,3321,2997,998,2981,2698,2980, + 5226,5204,5183,5183,5183,5183,5183,5183,5183,5208, + 1,5211,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1313,5226, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,5226,1, + 1,1,1,1,1,1,1,1567,1304,1565, + 1,4833,2664,1,1,1,1,5226,325,1, + 1,1,366,197,5407,197,2615,3068,3267,2247, + 3120,2870,3321,2997,998,2981,2698,2980,5226,5204, + 5183,5183,5183,5183,5183,5183,5183,5208,1,5211, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1313,5226,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,3621,1,1,1, + 1,1,1,1,1,1567,1304,1565,1,5226, + 2664,1,2852,1,1,138,5226,1,1,1, + 986,5226,5407,2399,2615,3068,3267,2247,3120,2870, + 3321,2997,998,2981,2698,2980,5226,5204,5183,5183, + 5183,5183,5183,5183,5183,5208,1,5211,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,5226,5226,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1004,1,1,1,1,1, + 1,1,1,1567,1304,1565,1,141,2664,1, + 97,1,1,4999,456,1,1,1,5226,5226, + 5407,5226,2615,3068,3267,2247,3120,2870,3321,2997, + 998,2981,2698,2980,5226,5204,5183,5183,5183,5183, + 5183,5183,5183,5208,1,5211,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,4973,5226,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 1,1,2278,1,1,1,1,1,1,1, + 1,1567,1304,1565,1,142,2664,1,426,1, + 1,5226,455,1,1,1,242,592,5407,5081, + 2615,3068,3267,2247,3120,2870,3321,2997,998,2981, + 2698,2980,5226,2890,1,1,1,1,1,1, + 1,5236,1,5235,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 4976,5226,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1, + 3438,1,1,1,1,1,1,1,1,1567, + 1304,1565,1,362,2664,1,1,1,1,4693, + 41,1,1,1,437,592,5407,5226,2615,3068, + 3267,2247,3120,2870,3321,2997,998,2981,2698,2980, + 43,4851,4848,2639,729,3868,4193,2857,4215,5266, + 924,5226,5488,4171,4149,5495,5493,5502,5501,5497, + 5498,5496,5499,5500,5503,5494,4259,4237,5226,5226, + 5249,1055,1260,1344,5251,1266,4402,1309,5252,5250, + 1078,5491,5245,5247,5248,5246,5567,5568,2289,5485, + 5492,5464,5490,5489,5486,5487,5465,5226,4851,4848, + 1402,729,5005,5624,2857,397,5243,5244,5587,858, + 5625,5626,5226,5068,5068,233,5064,233,233,233, + 233,5072,1,233,1,53,2106,1,1,1, + 1,1,1,1,1,1,1,1,5659,5660, + 5661,5061,5226,5161,5156,939,4982,784,5153,2857, + 5150,145,506,1,920,5226,5243,5244,1,1, + 3329,1,1,1,1,1,1,1,1,1399, + 349,43,43,2701,5268,1,1603,140,5560,5226, + 415,1,1,1,233,5226,5637,5724,5226,5068, + 5068,233,5064,233,233,233,233,5132,1,233, + 1,5226,124,1,1,1,1,1,1,1, + 1,1,1,1,2069,3269,3244,5061,1313,3320, + 397,4851,4848,106,5268,5226,5659,5660,5661,1, + 5226,5243,5244,5226,1,1,5226,1,1,1, + 1,1,1,1,1,1399,442,1,1,43, + 1,1,4970,2299,4970,5226,414,1,1,1, + 233,37,5637,5724,4979,229,5226,4979,3191,4979, + 4979,4707,4979,1948,4979,4979,2369,5488,371,4844, + 4840,2710,1,784,1,2857,1,4979,4979,4979, + 349,4992,4988,2710,5268,784,1603,2857,5560,5226, + 4958,4955,5659,5660,5661,5627,5491,1,5226,4979, + 126,5567,5568,1645,5485,5492,5464,5490,5489,5486, + 5487,5465,4979,3269,3244,4979,1313,2322,4979,4979, + 5226,5243,5244,4979,4979,784,733,2857,1313,1, + 4844,4840,2710,43,784,1081,2857,5268,4866,4979, + 4979,4979,4979,4979,4979,4979,4979,4979,4979,4979, + 4979,4979,4979,4979,4979,4979,4979,4979,4979,4979, + 4979,4979,4979,4979,4979,105,5226,5226,4979,4979, + 5002,4979,163,5002,2940,5002,5002,1313,5002,5226, + 5002,5002,5226,4992,4988,939,5268,784,1603,2857, + 5560,121,5589,5002,5002,5002,230,3826,1,4844, + 4840,5123,4869,5126,5226,5129,43,5236,5488,5235, + 5268,5226,1603,2210,5560,5002,315,5161,5156,939, + 4982,784,5153,2857,5150,5226,4851,4848,5002,729, + 5005,5002,2857,145,5002,5002,1906,5491,351,5002, + 5002,909,5567,5568,5226,5485,5492,5464,5490,5489, + 5486,5487,5465,5232,2195,5002,5002,5002,5002,5002, + 5002,5002,5002,5002,5002,5002,5002,5002,5002,5002, + 5002,5002,5002,5002,5002,5002,5002,5002,5002,5002, + 5002,3173,3803,3780,5002,5002,1313,5002,1,5054, + 5050,2639,5058,3868,4193,2857,4215,5226,5014,504, + 1864,4171,4149,5041,5047,5020,5023,5035,5032,5038, + 5029,5026,5017,5044,4259,4237,374,5231,5249,1055, + 1260,1344,5251,1266,4402,1309,5252,5250,1078,372, + 5245,5247,5248,5246,508,2299,5226,1822,1780,1738, + 1696,1654,1612,1570,1528,1486,1444,1,1402,514, + 3191,390,5226,43,43,43,4851,4848,2639,729, + 3868,4193,2857,4215,5234,569,3654,191,4171,4149, + 5495,5493,5502,5501,5497,5498,5496,5499,5500,5503, + 5494,4259,4237,1136,5226,5249,1055,1260,1344,5251, + 1266,4402,1309,5252,5250,1078,1184,5245,5247,5248, + 5246,1372,1,4844,4840,939,340,784,125,2857, + 1,4985,4985,3768,4982,1402,1603,323,5560,367, + 4854,3269,3244,5233,43,4851,4848,2639,729,3868, + 4193,2857,4215,5234,569,294,5226,4171,4149,5495, + 5493,5502,5501,5497,5498,5496,5499,5500,5503,5494, + 4259,4237,5567,5568,5249,1055,1260,1344,5251,1266, + 4402,1309,5252,5250,1078,1313,5245,5247,5248,5246, + 1,4844,4840,939,2069,784,1,2857,5226,315, + 5226,315,3768,367,1402,367,5226,4851,4848,5223, + 5268,5226,5233,147,4851,4848,2639,729,3868,4193, + 2857,4215,2032,569,5226,367,4171,4149,5495,5493, + 5502,5501,5497,5498,5496,5499,5500,5503,5494,4259, + 4237,3588,418,5249,1055,1260,1344,5251,1266,4402, + 1309,5252,5250,1078,3696,5245,5247,5248,5246,5679, + 1,4844,4840,2710,1771,784,307,2857,5226,367, + 5226,4851,4848,1402,729,784,5532,2857,43,43, + 1,5054,5050,2639,5058,3868,4193,2857,4215,5226, + 5014,367,5226,4171,4149,5041,5047,5020,5023,5035, + 5032,5038,5029,5026,5017,5044,4259,4237,1313,2158, + 5249,1055,1260,1344,5251,1266,4402,1309,5252,5250, + 1078,2367,5245,5247,5248,5246,5226,4851,4848,773, + 729,784,3905,2857,43,443,43,43,5268,5268, + 1402,5114,5226,5111,5226,43,43,43,4851,4848, + 2639,729,3868,4193,2857,4215,5230,569,513,5226, + 4171,4149,5495,5493,5502,5501,5497,5498,5496,5499, + 5500,5503,5494,4259,4237,2677,452,5249,1055,1260, + 1344,5251,1266,4402,1309,5252,5250,1078,1,5245, + 5247,5248,5246,43,4851,4848,2639,729,3868,4193, + 2857,4215,30,569,4857,117,4171,4149,5495,5493, + 5502,5501,5497,5498,5496,5499,5500,5503,5494,4259, + 4237,5226,876,5249,1055,1260,1344,5251,1266,4402, + 1309,5252,5250,1078,135,5245,5247,5248,5246,98, + 1,1,5226,1,5226,5138,123,5138,5659,5660, + 5661,3768,3826,1402,43,4851,4848,2639,729,3868, + 4193,2857,4215,5108,569,5229,5108,4171,4149,5495, + 5493,5502,5501,5497,5498,5496,5499,5500,5503,5494, + 4259,4237,5665,3994,5249,1055,1260,1344,5251,1266, + 4402,1309,5252,5250,1078,4303,5245,5247,5248,5246, + 5226,4325,1,4008,2614,1221,3905,5693,5687,5226, + 5691,54,4958,4955,1402,5685,5686,446,1,4844, + 4840,939,5226,784,228,2857,33,120,5716,5717, + 5696,2456,2428,5694,5226,5226,5488,3803,3780,5495, + 5493,5502,5501,5497,5498,5496,5499,5500,5503,5494, + 800,101,43,43,1519,5268,292,5189,136,5186, + 5226,4851,4848,5697,5268,5491,5718,1685,1692,5695, + 5567,5568,5226,5485,5492,5464,5490,5489,5486,5487, + 5465,1,4844,4840,5123,231,5126,5226,5129,627, + 5707,5706,5719,5688,5689,5712,5713,5488,422,5710, + 5711,5690,5692,5714,5715,5720,5700,5701,5702,5698, + 5699,5708,5709,5704,5703,5705,5226,4303,132,1221, + 1439,5693,5687,4325,5691,438,5491,5226,3087,5685, + 5686,5567,5568,5736,5485,5492,5464,5490,5489,5486, + 5487,5465,5716,5717,5696,232,2565,5694,396,41, + 5141,5141,389,4860,5141,2456,2428,5488,42,4964, + 4961,49,5011,5011,800,615,5226,4851,4848,5226, + 5268,379,3306,5226,5078,5075,1519,5697,3335,4967, + 5718,1685,1692,5695,5226,1897,5491,293,5243,5244, + 5008,5567,5568,5226,5485,5492,5464,5490,5489,5486, + 5487,5465,5266,5226,5707,5706,5719,5688,5689,5712, + 5713,2511,2484,5710,5711,5690,5692,5714,5715,5720, + 5700,5701,5702,5698,5699,5708,5709,5704,5703,5705, + 43,4851,4848,2639,729,3868,4193,2857,4215,5226, + 569,5226,3435,4171,4149,5495,5493,5502,5501,5497, + 5498,5496,5499,5500,5503,5494,4259,4237,5226,5226, + 5249,1055,1260,1344,5251,1266,4402,1309,5252,5250, + 1078,5226,5245,5247,5248,5246,3329,1,2779,43, + 4851,4848,2639,729,3868,4193,2857,4215,317,569, + 3087,2871,4171,4149,5495,5493,5502,5501,5497,5498, + 5496,5499,5500,5503,5494,4259,4237,2658,531,5249, + 1055,1260,1344,5251,1266,4402,1309,5252,5250,1078, + 3849,5245,5247,5248,5246,1,307,43,4851,4848, + 4029,729,3868,4193,2857,4215,5532,569,5226,1402, + 4171,4149,5495,5493,5502,5501,5497,5498,5496,5499, + 5500,5503,5494,4259,4237,1271,33,5249,1055,1260, + 1344,5251,1266,4402,1309,5252,5250,1078,2706,5245, + 5247,5248,5246,43,4851,4848,2639,729,3868,4193, + 2857,4215,5226,569,4863,3591,4171,4149,5495,5493, + 5502,5501,5497,5498,5496,5499,5500,5503,5494,4259, + 4237,3231,389,5249,1055,1260,1344,5251,1266,4402, + 1309,5252,5250,1078,424,5245,5247,5248,5246,43, + 4851,4848,2639,729,3868,4193,2857,4215,5226,569, + 4952,3554,4171,4149,5495,5493,5502,5501,5497,5498, + 5496,5499,5500,5503,5494,4259,4237,5226,5226,5249, + 1055,1260,1344,5251,1266,4402,1309,5252,5250,1078, + 5226,5245,5247,5248,5246,5226,4851,4848,5226,5268, + 1,4653,5226,5243,5244,722,3710,5488,3437,167, + 5495,5493,5502,5501,5497,5498,5496,5499,5500,5503, + 5494,5226,4958,4955,5226,8539,8539,134,41,5135, + 5135,1,122,51,5147,5147,5491,5226,3826,5226, + 5232,5567,5568,5226,5485,5492,5464,5490,5489,5486, + 5487,5465,5236,5266,5235,2565,5226,3054,5624,246, + 4945,4941,5144,4949,858,5625,5626,4281,874,722, + 5226,4896,5226,167,4932,4938,4911,4914,4926,4923, + 4929,4920,4917,4908,4935,5226,4281,874,5102,5226, + 33,389,389,5090,389,389,5090,389,5090,5093, + 4887,5090,389,39,5231,4881,4878,4423,4905,4884, + 4875,4890,4893,4902,4899,4872,5226,3972,4863,5226, + 2511,2484,5624,3803,3780,5230,5226,5226,858,5625, + 5626,389,5226,5170,5166,5226,389,389,5093,389, + 389,389,389,389,389,389,389,36,390,390, + 5084,390,390,5084,390,5084,5087,1,5084,390, + 2701,5266,5226,5093,5226,5226,4866,54,5099,5096, + 3756,5226,817,5226,5243,5244,5226,1304,1,5183, + 5183,233,5183,233,233,233,233,233,390,233, + 7869,623,4078,390,390,5087,390,390,390,390, + 390,390,390,390,54,1313,2359,5180,5244,5226, + 1,5183,5183,233,5183,233,233,233,233,5201, + 5087,233,7869,5226,119,866,1131,5226,118,5226, + 4869,3671,5244,1317,5229,1567,5761,1007,5226,5180, + 2664,1,1,5226,5099,5096,5226,5234,40,5177, + 5174,4834,4834,5724,1,5183,5183,233,5183,233, + 233,233,233,5201,447,233,7869,1567,5226,1007, + 623,623,2664,81,4527,5226,2914,5226,225,5226, + 8413,8266,5226,5180,45,5724,1,5183,5183,233, + 5183,233,233,233,233,5214,2757,233,7869,5294, + 5295,5226,1013,1519,4837,4837,5233,5226,5226,5226, + 5226,1567,4996,1007,4303,5180,2664,5232,4303,5234, + 4325,3164,225,5226,4325,5226,8413,8266,3317,5724, + 1,5183,5183,233,5183,233,233,233,233,5201, + 2121,233,7869,1567,1,1007,5226,1,2664,1, + 5226,54,1,3095,224,5243,527,5226,169,5180, + 5226,5724,1,5183,5183,233,5183,233,233,233, + 233,5201,4702,233,7869,5226,801,5226,5233,5243, + 1519,5231,5226,5226,5226,1,3467,1567,2359,1007, + 314,5180,2664,1355,5198,79,109,5226,225,3661, + 5226,1994,3730,3228,3735,5724,1,5183,5183,233, + 5183,233,233,233,233,233,520,233,7869,1567, + 527,1007,169,5192,2664,5226,283,5226,2749,5195, + 225,133,5226,5226,5226,5180,4641,5724,1,5183, + 5183,233,5183,233,233,233,233,233,1,233, + 7869,2701,5226,5233,4463,4596,5410,345,3736,2565, + 5226,5226,5226,1567,4435,1007,5226,5180,2664,4665, + 5226,5226,5226,2700,4666,2642,5226,2,5226,4710, + 5226,5724,1,5183,5183,233,5183,233,233,233, + 233,233,5105,233,7869,1567,1313,1007,5226,3382, + 2664,3756,5226,5226,5409,41,5226,5226,5226,345, + 5226,5180,345,5724,5226,5226,5226,5226,5226,5226, + 5226,345,5226,5226,2511,2484,5226,1990,5226,5226, + 5226,5226,5226,5226,5226,3087,5226,5226,5226,1567, + 5226,1007,5226,5226,2664,5226,5226,5226,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5724,5226,5226, + 5226,5226,5226,5226,5226,5226,5226,5226,5226,345 + }; + }; + 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, + 1,724,443,6,6,403,499,499,403,247, + 247,820,512,247,713,907,403,62,521,521, + 292,105,106,279,279,102,123,123,619,102, + 123,530,382,745,756,711,756,706,756,708, + 756,740,756,275,102,382,532,6,1088,443, + 443,443,443,275,1088,612,46,614,63,63, + 63,63,63,63,63,63,63,126,132,137, + 134,141,139,146,144,148,147,149,336,150, + 62,62,333,164,536,536,870,277,219,219, + 120,333,568,123,123,443,123,219,568,568, + 534,512,102,116,388,102,703,432,436,440, + 711,445,102,102,102,432,713,534,499,46, + 247,247,247,247,102,574,650,125,568,568, + 46,1047,246,870,46,126,1040,1040,574,62, + 63,63,63,63,63,63,63,63,63,63, + 63,63,63,63,63,63,63,63,63,62, + 62,62,62,62,62,62,62,62,62,62, + 62,63,536,536,100,869,219,219,382,333, + 333,219,568,288,523,386,116,388,703,441, + 703,432,703,445,445,102,432,102,99,568, + 568,821,821,821,821,432,568,62,63,450, + 457,763,763,275,614,333,246,62,100,568, + 99,101,99,568,333,134,134,132,132,132, + 139,139,139,139,137,137,144,141,141,147, + 146,148,704,149,568,568,277,102,821,783, + 820,821,120,821,493,876,116,115,506,102, + 388,704,443,434,995,726,388,703,703,823, + 102,445,506,504,505,102,102,1088,1088,1088, + 1088,102,102,62,102,870,63,247,130,173, + 568,101,870,62,493,691,869,46,493,116, + 870,821,443,99,702,728,96,1088,509,274, + 824,102,506,63,102,62,62,62,62,1088, + 1088,432,100,568,130,382,277,102,100,493, + 691,495,100,910,403,100,703,703,96,169, + 382,210,63,704,214,823,102,275,275,102, + 568,568,568,568,574,574,102,130,131,130, + 62,173,1000,126,277,495,693,495,170,528, + 1002,377,1088,13,946,403,100,703,711,275, + 728,96,63,63,102,102,102,568,568,468, + 130,574,63,333,1000,495,693,1088,831,377, + 528,909,711,711,571,275,820,170,711,26, + 509,102,1088,102,102,131,568,333,537,910, + 909,170,213,169,568,909,909,909,275,102, + 910,954,27,275,102,574,524,909,62,958, + 96,170,506,909,909,909,102,102,954,26, + 704,63,704,170,1088,1088,1088,27,1088,102, + 343,170,170,102,711,568,247,506,568,956, + 506,506,102,170,18,1088,18,704,27,46, + 46,44,738,46,170,170,689,954,956,170, + 876,568,96,568,44,377,1088,568,954,505, + 568,568,481,27,689,27,170,377,62,27, + 24,956,711,711,1080,62,25,574,170,568, + 27,568,170,27 + }; + }; + 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, + 63,10,29,74,0,61,67,64,121,1, + 2,0,1,2,123,58,0,75,114,115, + 116,29,72,119,122,68,74,76,57,59, + 62,78,80,86,84,77,82,83,85,87, + 58,79,81,11,9,49,63,46,69,50, + 12,51,52,53,54,55,70,56,71,41, + 47,60,65,66,10,33,37,35,32,40, + 16,25,15,21,19,20,22,23,18,17, + 24,42,45,43,44,30,39,34,38,26, + 27,13,14,31,36,8,6,3,4,7, + 5,1,2,0,3,9,61,95,67,64, + 73,121,48,0,60,46,7,47,5,1, + 2,4,76,58,121,120,103,26,27,48, + 3,96,90,6,91,92,13,14,89,88, + 28,93,94,97,98,8,99,100,101,61, + 95,73,67,104,105,106,107,108,109,110, + 111,112,113,72,118,68,102,117,64,11, + 9,0,96,90,13,14,91,92,88,89, + 61,93,94,97,98,99,100,101,102,117, + 95,104,105,106,107,108,109,110,111,112, + 113,118,73,68,1,2,4,8,6,72, + 48,28,3,9,64,11,67,0,32,65, + 33,34,66,7,35,36,37,38,60,39, + 40,42,43,44,30,26,27,8,6,13, + 14,5,31,61,45,3,49,15,16,63, + 46,17,69,50,12,18,51,52,19,20, + 53,54,21,22,55,70,56,10,71,23, + 24,47,25,41,1,2,4,0,76,3, + 58,61,72,67,64,11,48,9,73,95, + 0,65,66,3,10,33,37,35,32,40, + 16,25,15,21,19,20,22,23,18,17, + 24,42,45,43,44,30,39,34,38,5, + 7,4,26,27,8,6,13,14,31,36, + 1,2,118,9,0,61,72,95,64,118, + 73,68,15,16,32,65,17,33,34,18, + 19,20,66,35,21,22,36,37,38,60, + 39,40,10,23,24,25,42,43,44,30, + 26,27,13,14,31,45,9,11,7,5, + 3,1,2,8,4,6,0,75,7,114, + 115,116,57,9,3,8,6,5,72,68, + 11,74,49,15,16,63,46,17,69,50, + 12,18,51,52,19,20,53,54,21,22, + 55,70,56,10,71,23,41,24,47,25, + 4,1,2,29,0,4,58,72,0,4, + 58,72,28,0,1,2,9,68,0,9, + 72,118,73,11,64,0,15,16,17,18, + 19,20,21,22,23,24,25,49,46,50, + 12,51,52,53,54,55,56,41,47,11, + 9,73,7,1,2,48,3,8,6,5, + 4,0,46,47,60,9,95,73,61,64, + 121,67,0,67,64,68,9,0,58,64, + 0,8,6,4,3,5,7,48,1,2, + 61,67,95,73,9,64,0,30,0,7, + 5,3,48,6,8,95,49,15,16,63, + 46,17,69,50,12,18,51,52,19,20, + 53,54,21,22,55,70,56,10,71,23, + 41,24,47,25,1,2,4,73,9,0, + 58,67,0,9,73,15,16,32,17,33, + 34,18,19,20,35,21,22,36,37,38, + 60,39,40,10,23,24,25,42,43,44, + 30,3,26,27,8,6,13,14,31,4, + 45,5,7,1,2,66,65,0,49,15, + 16,63,46,17,69,50,12,18,51,52, + 19,20,53,54,21,22,55,70,56,10, + 71,23,41,24,47,25,1,2,4,66, + 65,13,14,6,91,92,99,8,100,5, + 31,28,61,107,108,104,105,106,112,111, + 113,89,88,109,110,97,98,93,94,101, + 102,26,27,64,90,103,3,48,67,0, + 46,47,60,9,3,61,95,67,64,73, + 11,76,58,72,0,29,72,4,1,2, + 58,0,9,61,64,73,1,2,8,6, + 4,3,48,121,0,11,9,72,7,5, + 3,1,2,6,8,4,0,77,0,10, + 69,63,70,71,16,25,15,21,19,20, + 22,23,18,17,24,76,58,72,95,118, + 68,121,7,54,55,56,41,47,1,2, + 53,52,51,12,50,5,4,46,49,9, + 73,11,48,3,120,96,103,90,26,27, + 8,6,13,14,91,92,88,89,28,93, + 94,97,98,99,100,101,102,117,67,104, + 105,106,107,108,109,110,111,112,113,64, + 61,0,41,1,2,4,114,115,116,0, + 62,49,15,16,63,46,17,69,50,75, + 12,18,51,52,19,20,53,59,54,21, + 22,55,70,56,10,71,23,57,41,24, + 47,25,9,3,8,4,11,58,6,7, + 1,2,5,29,0,49,15,16,46,17, + 69,50,12,18,51,52,19,20,53,54, + 21,22,55,70,56,10,71,23,41,24, + 47,25,1,2,4,95,63,0,68,63, + 46,17,69,50,18,51,52,19,20,53, + 54,21,22,55,70,56,71,23,41,24, + 47,25,16,15,49,9,3,8,6,11, + 57,62,75,12,29,7,1,2,5,4, + 10,59,0,119,0,9,68,65,66,60, + 26,27,8,6,13,14,31,36,3,42, + 45,43,44,30,39,34,38,16,25,15, + 21,19,20,22,23,18,17,24,33,37, + 35,32,40,58,7,1,2,4,10,5, + 0,63,46,17,69,50,18,51,52,19, + 20,53,54,21,22,55,70,56,10,71, + 23,41,24,47,25,16,15,49,9,3, + 8,6,11,57,59,62,75,12,28,7, + 4,29,5,1,2,0,65,66,26,27, + 13,14,31,36,42,45,43,44,30,39, + 34,38,16,25,15,21,19,20,22,23, + 18,17,24,10,33,37,35,32,40,8, + 6,4,48,7,5,1,2,3,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, + 56,12,12,58,58,150,12,12,134,171, + 171,12,143,5,138,12,134,35,12,12, + 90,79,79,79,79,199,12,12,163,47, + 12,142,214,223,224,12,224,179,224,255, + 224,217,12,10,199,214,137,58,12,12, + 12,12,12,215,12,41,110,199,35,35, + 251,35,35,35,35,35,35,12,12,12, + 12,12,12,12,12,12,12,12,35,12, + 35,35,95,12,150,150,121,12,150,150, + 160,95,264,12,12,12,12,150,264,264, + 114,17,199,150,150,181,150,167,150,12, + 12,150,167,199,11,12,194,114,12,110, + 171,171,171,171,199,157,165,12,264,264, + 1,35,60,121,110,12,50,50,157,205, + 35,35,35,35,35,35,35,35,35,35, + 35,35,35,35,35,35,35,35,35,35, + 35,35,35,35,35,35,35,35,35,35, + 205,35,134,134,23,69,33,33,214,95, + 95,33,264,12,12,12,31,226,150,150, + 15,105,15,150,256,11,105,181,22,264, + 264,12,12,12,12,120,264,35,35,12, + 12,12,12,10,199,95,171,81,23,264, + 22,199,22,264,95,12,12,12,12,12, + 12,12,12,12,12,12,12,12,12,12, + 12,12,12,12,264,264,12,11,12,12, + 12,12,196,12,150,134,150,31,67,199, + 130,12,12,12,99,186,226,15,15,237, + 181,256,67,12,12,181,199,12,12,12, + 12,181,11,35,199,121,35,171,150,84, + 264,243,121,35,150,150,69,33,31,31, + 121,12,12,215,150,208,145,12,12,215, + 126,167,67,35,256,205,205,205,205,12, + 12,119,181,264,45,196,12,47,181,31, + 31,150,23,246,150,167,150,77,19,130, + 214,12,35,12,101,233,167,215,215,11, + 264,264,264,264,157,157,181,150,184,12, + 205,196,244,12,12,150,150,73,130,12, + 246,187,12,256,99,134,23,77,97,27, + 145,19,35,35,11,167,167,264,264,12, + 45,157,35,95,244,73,73,12,150,208, + 12,150,12,12,12,215,12,130,97,87, + 12,167,12,11,11,184,264,95,262,246, + 150,130,13,12,264,152,150,150,215,167, + 246,150,174,27,11,157,264,152,81,35, + 145,130,67,246,152,152,167,241,103,202, + 12,35,12,130,12,12,12,203,12,256, + 128,130,130,256,108,264,171,67,264,150, + 67,67,241,130,75,12,12,12,203,258, + 258,132,12,258,130,130,12,150,62,130, + 171,264,145,264,170,150,12,264,103,67, + 264,264,150,203,12,203,130,145,205,203, + 75,62,108,108,143,35,12,123,130,264, + 203,264,130,203 + }; + }; + 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,7,10,148,146,121,145,144,5, + 2,0,178,0,111,0,96,95,53,63, + 55,5,7,10,2,0,166,5,165,0, + 60,0,43,4,5,7,10,2,13,0, + 2,7,3,0,139,0,1,3,0,5, + 2,10,7,135,0,169,0,110,0,170, + 0,13,2,10,7,5,64,0,65,134, + 133,0,125,0,115,0,155,0,68,0, + 4,33,0,4,172,0,4,64,0,13, + 2,10,7,5,72,0,156,0,152,0, + 184,0,157,0,2,65,0,59,0,4, + 43,39,0,23,4,5,91,0,2,53, + 65,0,4,173,0,186,0,4,39,38, + 0,39,176,4,23,0,31,95,96,4, + 0,31,96,95,63,53,7,10,2,4, + 0,105,4,47,69,0,4,98,0,4, + 188,0,4,43,167,0,2,61,0,175, + 4,43,0,4,47,39,174,0,5,44, + 2,3,0,137,0,38,53,7,10,2, + 4,154,0,96,95,5,55,0,2,44, + 0,64,47,74,4,39,0,2,63,53, + 7,10,4,91,5,0,2,5,121,117, + 118,119,13,88,0,4,47,69,103,45, + 5,0,5,103,162,0,5,103,185,0, + 151,0,2,116,0,4,47,69,73,0, + 7,10,3,13,5,1,0,4,43,104, + 0,43,4,31,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,117,102, + 122,68,12,13,50,54,62,70,76,77, + 88,89,104,107,109,8,9,20,95,114, + 15,57,63,69,86,90,92,96,99,101, + 106,111,112,113,46,56,108,1,49,66, + 72,75,78,85,91,100,105,3,79,97, + 21,48,55,45,60,80,34,121,65,93, + 103,31,120,123,67,98,110,51,52,58, + 59,61,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,82,83,84,30,119,53,4, + 125,64,124,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, + 132,137,139,0,0,138,236,136,0,230, + 135,0,146,134,0,0,145,151,0,0, + 152,161,182,162,163,164,165,166,167,168, + 128,169,154,170,171,0,144,130,133,172, + 0,141,155,140,180,0,0,0,0,0, + 0,0,0,148,158,0,205,0,175,189, + 0,202,206,129,0,0,0,207,0,0, + 178,127,131,174,0,0,0,0,0,0, + 0,0,0,0,0,0,0,188,0,0, + 203,213,160,209,210,211,0,0,0,0, + 149,208,221,177,181,0,0,0,212,0, + 0,0,0,241,242,150,191,192,193,194, + 195,197,200,0,0,215,218,220,0,239, + 240,0,142,143,147,0,0,157,159,0, + 173,0,183,184,185,186,187,190,0,196, + 198,0,199,204,0,216,217,0,222,225, + 227,229,0,233,234,235,237,238,126,0, + 153,156,0,176,0,179,0,201,214,219, + 0,223,224,226,228,0,231,232,243,244, + 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[] = { + 151,578,597,529,545,556,567,362,261,275, + 297,303,309,42,286,382,420,159,586,472, + 20,51,71,80,85,90,127,187,292,315, + 326,337,267,281,500,27,372,337,605,27, + 209,240,1,14,61,76,106,141,222,320, + 333,342,351,355,438,465,494,521,525,615, + 619,623,97,7,97,141,400,416,429,449, + 513,429,536,552,563,574,199,483,56,56, + 148,214,217,235,256,217,217,56,359,444, + 462,469,148,56,636,110,228,404,456,116, + 116,228,56,228,391,169,104,442,627,634, + 627,634,65,410,134,104,104,245 + }; + }; + 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,5,5,5,5,369,132,95, + 132,132,132,48,272,388,426,165,67,478, + 25,25,25,59,59,95,132,192,132,132, + 331,331,272,101,505,38,377,592,610,32, + 203,203,5,18,5,59,95,132,226,324, + 324,324,95,95,132,238,5,5,5,5, + 5,238,226,11,101,145,369,369,369,453, + 505,433,540,540,540,540,203,487,59,59, + 5,5,220,238,5,259,259,349,95,447, + 5,238,5,498,5,113,346,407,459,119, + 123,231,517,508,394,172,95,95,629,629, + 631,631,67,412,136,194,179,247 + }; + }; + public final static char scopeSuffix[] = ScopeSuffix.scopeSuffix; + public final int scopeSuffix(int index) { return scopeSuffix[index]; } + + public interface ScopeLhs { + public final static char scopeLhs[] = { + 45,17,17,17,17,17,17,77,82,46, + 87,86,119,66,51,77,76,45,17,19, + 3,6,9,162,162,159,117,45,85,119, + 118,120,52,46,135,113,77,17,17,113, + 97,56,132,80,165,162,159,127,58,118, + 118,120,177,49,59,139,18,17,17,17, + 17,17,12,115,159,127,77,76,76,36, + 135,76,17,17,17,17,97,19,166,162, + 178,95,102,68,57,154,71,120,78,75, + 140,139,170,135,16,159,120,104,21,128, + 128,55,135,135,77,45,159,70,133,44, + 133,44,165,104,117,45,45,56 + }; + }; + public final static char scopeLhs[] = ScopeLhs.scopeLhs; + public final int scopeLhs(int index) { return scopeLhs[index]; } + + public interface ScopeLa { + public final static byte scopeLa[] = { + 119,73,73,73,73,73,73,73,68,11, + 68,68,68,61,1,73,122,58,3,73, + 61,61,61,1,1,11,68,58,68,68, + 1,1,1,1,4,61,11,1,1,61, + 73,73,73,119,73,1,11,68,1,1, + 1,1,11,11,68,118,73,73,73,73, + 73,118,1,73,1,64,73,73,73,72, + 4,73,61,61,61,61,73,3,1,1, + 73,73,3,118,73,1,1,1,11,72, + 73,118,73,5,73,1,29,67,73,1, + 1,6,1,29,77,76,11,11,4,4, + 4,4,3,1,58,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[] = { + 58,225,225,225,225,225,225,32,69,58, + 69,69,138,79,60,32,32,58,225,225, + 158,200,201,52,52,88,138,58,69,138, + 138,138,60,58,94,304,32,225,225,304, + 296,142,42,32,24,52,88,288,142,138, + 138,138,20,60,27,49,225,225,225,225, + 225,225,220,6,88,288,32,32,32,257, + 94,32,225,225,225,225,296,225,24,52, + 22,296,298,292,142,55,147,138,32,32, + 46,49,97,94,225,88,138,1,226,138, + 138,99,94,94,32,58,88,11,91,115, + 91,115,24,1,138,58,58,142 + }; + }; + 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, + 314,3,60,0,128,0,313,3,119,0, + 128,175,0,128,183,76,0,217,0,253, + 128,28,126,0,21,0,292,128,28,29, + 0,21,55,0,34,134,0,21,55,0, + 0,292,128,28,29,193,0,21,131,0, + 253,128,28,131,0,185,129,0,144,0, + 222,3,290,0,290,0,2,0,128,0, + 253,128,28,134,0,185,129,227,0,185, + 129,41,227,0,185,129,310,41,0,132, + 189,168,129,0,130,0,189,168,129,0, + 136,130,0,171,0,306,128,171,0,128, + 171,0,223,130,0,168,245,0,139,0, + 0,0,137,0,0,0,305,128,58,252, + 0,129,0,252,0,3,0,0,129,0, + 304,128,58,0,45,129,0,157,3,0, + 128,280,279,128,76,278,171,0,279,128, + 76,278,171,0,216,0,217,0,278,171, + 0,98,0,0,216,0,217,0,204,98, + 0,0,216,0,217,0,279,128,278,171, + 0,216,0,204,0,0,216,0,231,128, + 3,0,128,0,0,0,0,0,231,128, + 3,219,0,226,3,0,215,128,0,209, + 0,189,168,177,0,136,0,168,129,0, + 11,0,0,0,217,48,0,127,0,231, + 128,3,181,0,181,0,2,0,0,128, + 0,0,0,0,0,195,3,0,202,0, + 230,128,58,30,12,0,185,129,59,57, + 0,198,130,0,132,185,129,276,57,0, + 185,129,276,57,0,185,129,67,125,59, + 0,230,128,58,59,0,230,128,58,123, + 59,0,230,128,58,126,59,0,273,128, + 58,125,69,0,273,128,58,69,0,185, + 129,69,0,137,0,189,185,129,245,0, + 139,0,185,129,245,0,189,168,129,10, + 0,168,129,10,0,95,139,0,149,0, + 266,128,147,0,266,128,171,0,163,86, + 0,297,162,299,300,3,83,0,128,174, + 0,299,300,3,83,0,130,0,128,174, + 0,163,3,77,198,82,0,128,130,0, + 198,82,0,110,2,133,128,130,0,228, + 3,77,0,195,167,0,34,172,0,167, + 0,178,34,172,0,228,3,87,0,198, + 155,228,3,85,0,64,174,0,228,3, + 85,0,128,174,64,174,0,298,128,58, + 0,163,0,217,79,0,31,0,163,117, + 159,0,31,172,0,178,3,0,128,152, + 0,222,3,0,217,48,263,0,163,48, + 0,178,3,294,66,129,0,128,0,0, + 0,0,294,66,129,0,2,148,128,0, + 0,0,0,178,3,36,0,150,0,127, + 29,168,129,0,32,150,0,95,139,32, + 150,0,225,185,129,0,149,32,150,0, + 178,3,40,0,163,3,40,0,163,3, + 61,178,28,32,0,178,28,32,0,21, + 2,133,128,0,163,3,61,178,28,35, + 0,178,28,35,0,163,3,61,178,28, + 37,0,178,28,37,0,163,3,61,178, + 28,33,0,178,28,33,0,222,3,127, + 189,168,129,10,0,127,189,168,129,10, + 0,139,2,0,128,0,222,3,126,177, + 168,129,10,0,177,168,129,10,0,137, + 2,0,128,0,222,3,137,0,222,3, + 141,0,163,48,141,0,258,0,32,0, + 32,142,0,166,0,163,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, + 2878,4666,4665,4435,0,2288,3069,1011,1987,0, + 3699,3641,3556,3498,3440,3382,3321,3163,2916,2700, + 0,540,0,3317,627,0,3046,2681,2615,2703, + 1376,3699,3641,3556,3498,3440,3382,3321,3163,2916, + 0,2534,1392,1000,0,3402,2977,0,2745,734, + 0,3437,3438,0,3855,3007,0,4532,3403,3699, + 3641,3556,3498,3440,3382,3321,3163,2916,3093,3025, + 4061,2953,4008,2846,3955,3902,3849,0,3093,3025, + 4061,2953,4008,2846,3955,3902,3849,4532,3403,0, + 2614,986,0,1355,801,0,874,0,2782,4501, + 3752,3958,4490,1981,3294,1118,3585,3027,3028,578, + 2652,1124,860,0,4614,4610,4606,4602,4588,4043, + 3990,3937,4680,4676,4659,3723,3522,4440,4096,3146, + 2865,3409,3311,2799,2941,3150,0,536,3376,2607, + 0,4501,3855,4490,3007,578,3610,4391,4565,4463, + 2782,4423,939,3294,2710,2592,0,4614,4116,4610, + 3646,3100,4606,4602,4588,2969,3650,2295,4043,3990, + 3335,3329,3054,3937,3526,4680,2774,4676,1350,931, + 4659,1180,3723,3522,920,4440,2886,4096,3146,2865, + 795,3409,3311,2799,3376,2941,784,3150,2607,729, + 3610,4391,4565,4463,2782,4501,4423,2284,3855,4490, + 1387,939,3294,3007,659,642,578,2710,2592,2195, + 2106,1372,1355,801,4402,4369,4347,2299,2336,2369, + 592,2456,2428,2399,2808,2616,2565,2538,2511,2484, + 3826,3803,3780,3269,3244,4325,4303,4281,4259,4237, + 4215,4193,4171,4149,3868,1055,1990,2247,2210,2158, + 2121,2069,2032,876,1948,1906,1229,821,740,685, + 1864,1822,1780,1738,1696,1654,1612,1570,1528,1486, + 1444,536,1184,1136,1402,1313,1081,1013,953,1271, + 0,1268,1226,1059,1036,3028,578,3610,2701,2710, + 2984,2592,0,3530,3905,2742,815,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,293,29,10,63,28,234,234,128,67, + 67,292,147,128,167,61,64,67,226,195, + 48,219,220,187,181,177,131,134,7,5, + 126,3,128,267,268,252,269,245,270,69, + 271,272,126,10,129,128,3,63,40,32, + 35,37,33,10,137,4,3,129,36,31, + 5,14,13,6,8,27,26,141,146,149, + 148,151,150,153,152,156,154,158,60,159, + 67,67,217,159,3,3,168,166,28,28, + 167,48,3,65,66,126,125,28,226,195, + 128,215,129,6,58,168,234,129,127,126, + 125,58,129,129,185,168,215,128,234,3, + 28,28,28,28,129,3,7,126,178,163, + 128,65,66,168,3,127,103,120,3,48, + 90,96,14,13,92,91,6,94,93,61, + 28,88,89,8,98,97,100,99,101,113, + 112,111,110,109,108,107,106,105,104,67, + 117,102,128,128,189,4,128,128,128,48, + 48,128,231,232,233,168,128,128,127,126, + 128,185,128,58,128,185,168,29,67,178, + 163,178,178,178,178,168,222,128,155,265, + 137,127,126,10,129,48,294,3,189,178, + 29,129,29,222,163,148,148,146,146,146, + 150,150,150,150,149,149,152,151,151,154, + 153,156,163,158,231,231,258,189,253,135, + 255,253,215,253,155,64,6,184,305,129, + 169,227,29,193,57,171,307,128,128,72, + 189,128,273,125,274,189,129,61,61,61, + 61,189,177,64,129,168,196,3,295,167, + 157,185,168,72,155,155,4,64,128,128, + 168,28,29,276,278,128,3,181,309,227, + 41,129,273,67,64,3,3,3,3,127, + 126,168,29,178,128,128,225,5,29,128, + 128,223,189,61,28,129,76,128,215,306, + 128,126,72,285,195,64,129,41,310,185, + 163,163,163,163,3,3,189,155,260,263, + 48,179,4,125,127,223,223,128,132,12, + 29,171,62,59,57,128,185,128,279,72, + 64,215,72,67,185,129,129,222,222,127, + 128,3,48,163,4,128,128,60,30,128, + 3,58,123,126,125,59,292,132,279,58, + 289,129,290,185,185,260,222,217,3,128, + 58,266,195,277,30,128,58,58,67,129, + 61,280,128,64,185,3,314,128,3,67, + 64,155,230,229,128,128,129,185,128,298, + 81,79,1,163,87,85,83,82,77,84, + 86,80,78,59,76,222,64,230,157,58, + 230,230,185,275,281,119,9,217,72,3, + 3,3,198,3,125,163,125,183,128,275, + 3,228,167,228,300,147,77,228,128,304, + 95,313,167,155,195,155,299,128,3,155, + 281,64,155,155,128,67,198,162,266,163, + 122,297,155,155 + }; + }; + 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", + "original_namespace_name", + "EOF_TOKEN", + "type_parameter_start", + "]", + ")", + "}", + ";", + "declaration", + "identifier_token", + "expression", + "id_expression", + "qualified_or_unqualified_name", + "unqualified_id_name", + "identifier_name", + "operator_function_id_name", + "template_id_name", + "nested_name_specifier", + "class_or_namespace_name", + "nested_name_specifier_with_tem" + + "plate", + "class_or_namespace_name_with_t" + + "emplate", + "class_name", + "postfix_expression", + "simple_type_specifier", + "pseudo_destructor_name", + "type_id", + "type_name", + "destructor_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", + "for_init_statement", + "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", + "namespace_name", + "init_declarator_list", + "init_declarator_complete", + "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_function_id", + "conversion_type_id", + "conversion_declarator", + "mem_initializer_list", + "mem_initializer", + "mem_initializer_name", + "operator_id_name", + "overloadable_operator", + "template_parameter_list", + "template_parameter", + "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 = 74, + SCOPE_UBOUND = 117, + SCOPE_SIZE = 118, + 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 = 524, + NT_OFFSET = 124, + LA_STATE_OFFSET = 5761, + MAX_LA = 2147483647, + NUM_RULES = 535, + NUM_NONTERMINALS = 196, + NUM_SYMBOLS = 320, + SEGMENT_SIZE = 8192, + START_STATE = 815, + IDENTIFIER_SYMBOL = 0, + EOFT_SYMBOL = 121, + EOLT_SYMBOL = 121, + ACCEPT_ACTION = 4833, + ERROR_ACTION = 5226; + + 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/CPPTemplateTypeParameterParsersym.java b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParsersym.java new file mode 100644 index 00000000000..400b269ae80 --- /dev/null +++ b/lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/internal/core/dom/lrparser/cpp/CPPTemplateTypeParameterParsersym.java @@ -0,0 +1,272 @@ +/******************************************************************************* +* 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 CPPTemplateTypeParameterParsersym { + public final static int + TK_asm = 62, + TK_auto = 49, + TK_bool = 15, + TK_break = 78, + TK_case = 79, + TK_catch = 119, + TK_char = 16, + TK_class = 63, + TK_const = 46, + TK_const_cast = 32, + TK_continue = 80, + TK_default = 81, + TK_delete = 65, + TK_do = 82, + TK_double = 17, + TK_dynamic_cast = 33, + TK_else = 122, + TK_enum = 69, + TK_explicit = 50, + TK_export = 75, + TK_extern = 12, + TK_false = 34, + TK_float = 18, + TK_for = 83, + TK_friend = 51, + TK_goto = 84, + TK_if = 85, + TK_inline = 52, + TK_int = 19, + TK_long = 20, + TK_mutable = 53, + TK_namespace = 59, + TK_new = 66, + TK_operator = 7, + TK_private = 114, + TK_protected = 115, + TK_public = 116, + TK_register = 54, + TK_reinterpret_cast = 35, + TK_return = 86, + TK_short = 21, + TK_signed = 22, + TK_sizeof = 36, + TK_static = 55, + TK_static_cast = 37, + TK_struct = 70, + TK_switch = 87, + TK_template = 29, + TK_this = 38, + TK_throw = 60, + TK_try = 76, + TK_true = 39, + TK_typedef = 56, + TK_typeid = 40, + TK_typename = 10, + TK_union = 71, + TK_unsigned = 23, + TK_using = 57, + TK_virtual = 41, + TK_void = 24, + TK_volatile = 47, + TK_wchar_t = 25, + TK_while = 77, + TK_integer = 42, + TK_floating = 43, + TK_charconst = 44, + TK_stringlit = 30, + TK_identifier = 1, + TK_Completion = 2, + TK_EndOfCompletion = 9, + TK_Invalid = 124, + TK_LeftBracket = 48, + TK_LeftParen = 3, + TK_LeftBrace = 58, + TK_Dot = 120, + TK_DotStar = 96, + TK_Arrow = 103, + TK_ArrowStar = 90, + TK_PlusPlus = 26, + TK_MinusMinus = 27, + TK_And = 8, + TK_Star = 6, + TK_Plus = 13, + TK_Minus = 14, + TK_Tilde = 5, + TK_Bang = 31, + TK_Slash = 91, + TK_Percent = 92, + TK_RightShift = 88, + TK_LeftShift = 89, + TK_LT = 28, + TK_GT = 61, + 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 = 117, + TK_Colon = 72, + TK_ColonColon = 4, + TK_DotDotDot = 95, + TK_Assign = 67, + 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 = 64, + TK_zero = 45, + TK_RightBracket = 118, + TK_RightParen = 73, + TK_RightBrace = 68, + TK_SemiColon = 11, + TK_ERROR_TOKEN = 74, + TK_original_namespace_name = 123, + TK_EOF_TOKEN = 121; + + public final static String orderedTerminalSymbols[] = { + "", + "identifier", + "Completion", + "LeftParen", + "ColonColon", + "Tilde", + "Star", + "operator", + "And", + "EndOfCompletion", + "typename", + "SemiColon", + "extern", + "Plus", + "Minus", + "bool", + "char", + "double", + "float", + "int", + "long", + "short", + "signed", + "unsigned", + "void", + "wchar_t", + "PlusPlus", + "MinusMinus", + "LT", + "template", + "stringlit", + "Bang", + "const_cast", + "dynamic_cast", + "false", + "reinterpret_cast", + "sizeof", + "static_cast", + "this", + "true", + "typeid", + "virtual", + "integer", + "floating", + "charconst", + "zero", + "const", + "volatile", + "LeftBracket", + "auto", + "explicit", + "friend", + "inline", + "mutable", + "register", + "static", + "typedef", + "using", + "LeftBrace", + "namespace", + "throw", + "GT", + "asm", + "class", + "Comma", + "delete", + "new", + "Assign", + "RightBrace", + "enum", + "struct", + "union", + "Colon", + "RightParen", + "ERROR_TOKEN", + "export", + "try", + "while", + "break", + "case", + "continue", + "default", + "do", + "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", + "private", + "protected", + "public", + "Question", + "RightBracket", + "catch", + "Dot", + "EOF_TOKEN", + "else", + "original_namespace_name", + "Invalid" + }; + + public final static boolean isValidForParser = true; +}